• 【C语言】求解数独 求数独的解的个数 多解数独算法

    目录

    什么是数独？ 

    数独的解法？

    数独DFS算法详解

    1. 初始化条件

    2. 填入已初始化的数独表

    3. 填数独

     4. 拓展问题

    请问删掉数独中的哪两个数可以使得数独的解最大？

     删除的是哪两个数？

     最终代码

     main函数（如何执行这些代码） 

    什么是数独？ 

    数独的要求是每一行，每一列，每一宫都包括1~9，但是不能有重复数字。

    数独的解法？

    主流为深度优先搜索算法，如果使用数据结构，有舞蹈链算法，本篇介绍深度优先搜索算法。

    数独DFS算法详解

    1. 初始化条件

    我们的初始条件准备了5个，分别是row[N], col[N], cell[3][3]，ones[M], map[M]。

    N = 9；

    M = 111111111（二进制），511（十进制）；

    1. //设置9*9数独表
    2. const int N = 9;
    3. //设置mask长度 M的二进制：111111111，从右到左分别表示1 2 3 4 5 6 7 8 9 
    4. const int M = 1 << N;
    5.  
    6. //row、col、cell分别表示行、列、宫可填写数的编码
    7. //ones、map是一个映射关系，ones表示有多少个1，map表示9位二进制的1代表的数字
    8. int row[N], col[N], cell[3][3];
    9. int ones[M], map[M];
    10.  
    11. //数独表
    12. int arr[9][9] = {
    13.     4,0,0,9,0,0,0,0,3,
    14.     0,8,0,0,0,1,0,9,0,
    15.     0,0,0,0,2,0,7,0,0,
    16.     0,3,0,0,0,0,0,0,4,
    17.     0,0,6,7,0,0,5,0,0,
    18.     2,0,0,0,0,0,0,6,0,
    19.     0,0,7,0,3,0,6,0,0,
    20.     0,5,0,6,0,0,0,0,0,
    21.     1,0,0,0,0,9,0,0,2
    22. };

    那么M是用来干嘛的？

    我使用了二进制来优化DFS算法，在下图中只有7不能填，因为mask为0。

        map和ones是一个映射关系，下标（二进制）->值（十进制）
        
        map[10] = 2,意思是二进制为10的数十进制为2 

        ones[11] = 2,意思是二进制为11的数十进制为2

    下面初始化的意思是把所有位置都设置成所有数都可填的状态。

    1. //只需一次初始化的数组map、ones
    2. void _init()
    3. {
    4.     //once设置成false后不再执行这个函数
    5.     once = false;
    6.  
    7.     //map和ones是一个映射关系，下标（二进制）->值（十进制）
    8.     // 
    9.     //map[10] = 2,意思是二进制为10的数十进制为2
    10.     for (int i = 0; i < N; i++)
    11.     {
    12.         map[1 << i] = i + 1;
    13.     }
    14.  
    15.     //ones[11] = 2,意思是二进制为11的数十进制为2
    16.     for (int i = 0; i < M; i++)
    17.     {
    18.         for (int j = 0; j < N; j++)
    19.         {
    20.             ones[i] += i >> j & 1;
    21.         }
    22.     }
    23. }
    24.  
    25. //初始化条件数组
    26. int init(int _arr[N][N])
    27. {
    28.     //设置row，col为111111111，代表1`9都在可填写状态
    29.     for (int i = 0; i < N; i++)
    30.     {
    31.         row[i] = col[i] = M - 1;
    32.     }
    33.  
    34.     //在9个宫中设置值为111111111，代表1`9都在可填写状态
    35.     for (int i = 0; i < 3; i++)
    36.     {
    37.         for (int j = 0; j < 3; j++)
    38.         {
    39.             cell[i][j] = M - 1;
    40.         }
    41.     }
    42.  
    43.     //只初始化一次
    44.     if (once)
    45.     {
    46.         _init();
    47.     }
    48.  
    49.     //填入数独表的已知数字，完成初始化工作。
    50.     return fill(_arr);
    51. }

     fill函数是干嘛的？请往下看

    2. 填入已初始化的数独表

    fill函数的作用是填入数独表中已知的数字，返回一个整形代表待填入数独表的空位。

    我们利用空位作为DFS的制约条件。

    1. //将数组上已知数的位置、值信息做初始化记录，并记录需要填写的格子数
    2. int fill(int _arr[N][N])
    3. {
    4.     //cnt为待填格子数
    5.     int cnt = 0;
    6.  
    7.     //设置cnt，row、col、cell条件
    8.     for (int i = 0; i < N; i++)
    9.     {
    10.         for (int j = 0; j < N; j++)
    11.         {
    12.             if (!_arr[i][j])
    13.             {
    14.                 cnt++;
    15.             }
    16.             else
    17.             {
    18.                 col[j] -= 1 << (_arr[i][j] - 1);
    19.                 row[i] -= 1 << (_arr[i][j] - 1);
    20.                 cell[i / 3][j / 3] -= 1 << (_arr[i][j] - 1);
    21.             }
    22.         }
    23.     }
    24.  
    25.     return cnt;
    26. }

     在行，列，宫对应的位置减去对应数的二进制码，这样可以把该数字在行、列、宫对应的二进制码设置为0，代表该数字在该行，该列，该宫已经不可以填写。

    可举例填写4和6，三个条件的变化，等式右边为二进制码。 

    3. 填数独

    前置有3个功能函数。

    这里说一下getmask，

    因为&的特点，col & row & cell运算，如果这三个其中一个的二进制码的某个位置上为0，那么返回的计算结果的那个位置的二进制码也为0。

    draw是我们递归的灵魂，他的功能是在数组上填数，然后根据填的数修改row、col、cell。

    1. //获得可填数的编码位（截断到最靠右的1） 例如10110 lowbit后得到10 
    2. inline int lowbit(int x)
    3. {
    4.     return x & -x;
    5. }
    6.  
    7.  
    8. //获取可填数据 col，row，cell经过位运算可得到一串二进制数字，二进制的1代表可以填进数独的数字
    9. int getmask(int x, int y)
    10. {
    11.     //printBinary(row[x]);
    12.     //std::cout << " ";
    13.  
    14.     //printBinary(col[y]);
    15.     //std::cout << " ";
    16.  
    17.     //printBinary(cell[x/3][y/3] );
    18.     //std::cout << " ";
    19.  
    20.     //printBinary(col[y] & row[x] & cell[x / 3][y / 3]);
    21.  
    22.     return col[y] & row[x] & cell[x / 3][y / 3];
    23. }
    24.  
    25.  
    26. //填数字
    27. void draw(int _arr[9][9], int x, int y, int num, bool is_set)
    28. {
    29.     //如果这个位置已经被填过，那么消除这个位置上的数字
    30.     //如果没有，就设置成num
    31.     if (is_set)
    32.     {
    33.         _arr[x][y] = 0;
    34.     }
    35.     else
    36.     {
    37.         _arr[x][y] = num;
    38.     }
    39.  
    40.     //将数字num转化成二进制码
    41.     int v = 1 << (num - 1);
    42.  
    43.     //根据这个位置是否有数字，修改 + - 的逻辑
    44.     if (is_set)
    45.     {
    46.         v = -v;
    47.     }
    48.  
    49.     // -v 代表此位置行，列，宫的可填数num已经填入，该行，列，宫不可再填num
    50.     row[x] -= v;
    51.     col[y] -= v;
    52.     cell[x / 3][y / 3] -= v;
    53. }

    我们 按照标题2. 的逻辑对数独表和三个条件进行增、改，然后搜索。

    t_ret表示解的数量。max_ret表示最大解。

    位置优化：通过两层循环，找出可填数最少的位置。

    1. //填数独
    2. bool dfs(int _arr[9][9], int cnt, int& t_ret)
    3. {
    4.     //如果可填数为0，则代表已经完成数独
    5.     if (!cnt)
    6.     {
    7.         return true;
    8.     }
    9.  
    10.     //找出最小可选位置，x、y表示坐标，minv代表可填数
    11.     int minv = 10;
    12.     int x, y;
    13.  
    14.     //每一个为0的位置都可以通过getmask(x,y)找到一个9位的二进制数，每一个位置上的1都代表对应数字可填
    15.     for (int i = 0; i < N; i++)
    16.     {
    17.         for (int j = 0; j < N; j++)
    18.         {
    19.             //如果状态码state中的1比minv小，则记录下该位置的xy坐标，并记录下最小可填值minv
    20.             if (!_arr[i][j])
    21.             {
    22.                 int state = getmask(i, j);
    23.                 if (ones[state] < minv)
    24.                 {
    25.                     minv = ones[state];
    26.                     x = i, y = j;
    27.                     //std::cout << std::endl;
    28.                     //printBinary(state);
    29.                 }
    30.             }
    31.         }
    32.     }
    33.  
    34.     //拿到状态码
    35.     int state = getmask(x, y);
    36.  
    37.     //lowbit取到可填数（从小到大），填了就从状态码中消除对应位置上的1
    38.     for (int i = state; i; i -= lowbit(i))
    39.     {
    40.         //拿到二进制对应的十进制数字num
    41.         int num = map[lowbit(i)];
    42.         //填入num
    43.         draw(_arr, x, y, num, false);
    44.         //开始填数，如果已经填完数独，则打印，并记录解的数量t_ret，最大解max_ret
    45.         if (dfs(_arr, cnt - 1, t_ret))
    46.         {
    47.             //print_arr(_arr);
    48.  
    49.             t_ret++;
    50.             max_ret = t_ret > max_ret ? t_ret : max_ret;
    51.         }
    52.         //撤销填入的num
    53.         draw(_arr, x, y, num, true);
    54.     }
    55.  
    56.     //如果 i = state 的值是0，那么就代表没有数字可以填的，返回失败，并消除上一位的数字
    57.     return false;
    58. }

     4. 拓展问题

    请问删掉数独中的哪两个数可以使得数独的解最大？

     删除的是哪两个数？

    函数的逻辑是删除两个数，然后进行DFS，再然后把删除的数填回去，继续删除。

    DFS进行之前，我们都初始化row，col，cell三个条件，这样能保证正常递归。

     这里我们使用vector和pair（C++），也就是数组和键值对的数据结构。

    first代表x坐标，second代表y坐标。

    1. //得到所有的数组，并记录下数独的最大解
    2. int _getallarr(int tmp[9][9], int& time)
    3. {
    4.     //将每一个已知数字的x，y坐标记录到vii
    5.     std::vectorint, int>> vii;
    6.     for (int i = 0; i < 9; i++)
    7.     {
    8.         for (int j = 0; j < 9; j++)
    9.         {
    10.             if (arr[i][j])
    11.             {
    12.                 vii.push_back({ i,j });
    13.             }
    14.         }
    15.     }
    16.  
    17.     //tmp1.tmp2存要删掉的两个数
    18.     int tmp1, tmp2;
    19.     //记录删除的数的坐标
    20.     int max_ret_tmp = max_ret;
    21.     //vpii的每一个元素都是一对坐标，我们只保留2对坐标
    22.     std::vectorint, int>> vpii;
    23.     //依次删除两个数，为了保护源数独，把数据传入到tmp中
    24.     for (int i = 0; i < vii.size(); i++)
    25.     {
    26.         for (int j = i + 1; j < vii.size() - 1; j++)
    27.         {
    28.             //存下要删掉的数，搜索完还原。
    29.             tmp1 = tmp[vii[i].first][vii[i].second];
    30.             tmp[vii[i].first][vii[i].second] = 0;
    31.  
    32.             tmp2 = tmp[vii[j].first][vii[j].second];
    33.             tmp[vii[j].first][vii[j].second] = 0;
    34.  
    35.  
    36.             //计算最大解
    37.             int t_ret = 0;
    38.             int cnt = init(tmp);
    39.             dfs(tmp, cnt, t_ret);
    40.  
    41.             //如果最大解的数值发生变化，那么记录下该点的坐标。
    42.             if (max_ret > max_ret_tmp)
    43.             {
    44.                 //此处还可做优化，比如说把2改成time，删time个数的最大解是哪三个？
    45.                 max_ret_tmp = max_ret;
    46.                 if (vpii.size() == 2)
    47.                 {
    48.                     vpii.erase(vpii.begin(), vpii.end());
    49.                 }
    50.                 vpii.push_back(vii[i]);
    51.                 vpii.push_back(vii[j]);
    52.             }
    53.  
    54.             //还原删除的数
    55.             tmp[vii[i].first][vii[i].second] = tmp1;
    56.             tmp[vii[j].first][vii[j].second] = tmp2;
    57.         }
    58.     }
    59.  
    60.     std::cout << "删除的坐标是：(" << vpii[0].first << vpii[0].second << ") && (" << vpii[1].first << vpii[1].second << ")" << std::endl;
    61.     return max_ret;
    62. }
    63.  
    64. //计算最大解
    65. int getMaxRet()
    66. {
    67.     //time为要删的数的个数
    68.     int time = 2;
    69.     //tmp为临时数组
    70.     int tmp[9][9] = { 0 };
    71.     copy_arr(tmp);
    72.  
    73.     //
    74.     return _getallarr(tmp, time);
    75. }

     最终代码

    1. //设置9*9数独表
    2. const int N = 9;
    3. //设置mask长度 M的二进制：111111111，从右到左分别表示1 2 3 4 5 6 7 8 9 
    4. const int M = 1 << N;
    5.  
    6. //row、col、cell分别表示行、列、宫可填写数的编码
    7. //ones、map是一个映射关系，ones表示有多少个1，map表示9位二进制的1代表的数字
    8. //max_ret表示数独的最大解
    9. //once 卡关，ones和map数组只需初始化一次 
    10. int row[N], col[N], cell[3][3];
    11. int ones[M], map[M];
    12. int max_ret;
    13. bool once = true;
    14.  
    15. //数独表
    16. int arr[9][9] = {
    17.     4,0,0,9,0,0,0,0,3,
    18.     0,8,0,0,0,1,0,9,0,
    19.     0,0,0,0,2,0,7,0,0,
    20.     0,3,0,0,0,0,0,0,4,
    21.     0,0,6,7,0,0,5,0,0,
    22.     2,0,0,0,0,0,0,6,0,
    23.     0,0,7,0,3,0,6,0,0,
    24.     0,5,0,6,0,0,0,0,0,
    25.     1,0,0,0,0,9,0,0,2
    26. };
    27.  
    28. //打印二进制格式（调试用）
    29. void printBinary(int num) 
    30. {
    31.     if (num == 0) {
    32.         std::cout << "0";
    33.         return;
    34.     }
    35.  
    36.     int binary[32];
    37.     int i = 0;
    38.  
    39.     while (num > 0) {
    40.         binary[i] = num % 2;
    41.         num /= 2;
    42.         i++;
    43.     }
    44.  
    45.     for (int j = i - 1; j >= 0; j--) {
    46.         std::cout << binary[j];
    47.     }
    48. }
    49.  
    50. //获得可填数的编码位（截断到最靠右的1） 例如10110 lowbit后得到10 
    51. inline int lowbit(int x)
    52. {
    53.     return x & -x;
    54. }
    55.  
    56. //打印数独表
    57. void print_arr(int _arr[9][9])
    58. {
    59.     for (int i = 0; i < N; i++)
    60.     {
    61.         for (int j = 0; j < N; j++)
    62.         {
    63.             std::cout << _arr[i][j];
    64.         }
    65.         std::cout << std::endl;
    66.     }
    67.  
    68.     std::cout << std::endl;
    69. }
    70.  
    71. //复制数独表到tmp
    72. void copy_arr(int tmp[][9])
    73. {
    74.     for (int i = 0; i < N; i++)
    75.     {
    76.         for (int j = 0; j < N; j++)
    77.         {
    78.             tmp[i][j] = arr[i][j];
    79.         }
    80.     }
    81.  
    82.     std::cout << std::endl;
    83. }
    84.  
    85.  
    86.  
    87. //获取可填数据 col，row，cell经过位运算可得到一串二进制数字，二进制的1代表可以填进数独的数字
    88. int getmask(int x, int y)
    89. {
    90.     //printBinary(row[x]);
    91.     //std::cout << " ";
    92.  
    93.     //printBinary(col[y]);
    94.     //std::cout << " ";
    95.  
    96.     //printBinary(cell[x/3][y/3] );
    97.     //std::cout << " ";
    98.  
    99.     //printBinary(col[y] & row[x] & cell[x / 3][y / 3]);
    100.  
    101.     return col[y] & row[x] & cell[x / 3][y / 3];
    102. }
    103.  
    104. //填数字
    105. void draw(int _arr[9][9], int x, int y, int num, bool is_set)
    106. {
    107.     //如果这个位置已经被填过，那么消除这个位置上的数字
    108.     //如果没有，就设置成num
    109.     if (is_set)
    110.     {
    111.         _arr[x][y] = 0;
    112.     }
    113.     else
    114.     {
    115.         _arr[x][y] = num;
    116.     }
    117.  
    118.     //将数字num转化成二进制码
    119.     int v = 1 << (num - 1);
    120.  
    121.     //根据这个位置是否有数字，修改 + - 的逻辑
    122.     if (is_set)
    123.     {
    124.         v = -v;
    125.     }
    126.  
    127.     // -v 代表此位置行，列，宫的可填数num已经填入，该行，列，宫不可再填num
    128.     row[x] -= v;
    129.     col[y] -= v;
    130.     cell[x / 3][y / 3] -= v;
    131. }
    132.  
    133. //将数组上已知数的位置、值信息做初始化记录，并记录需要填写的格子数
    134. int fill(int _arr[N][N])
    135. {
    136.     //cnt为待填格子数
    137.     int cnt = 0;
    138.  
    139.     //设置cnt，row、col、cell条件
    140.     for (int i = 0; i < N; i++)
    141.     {
    142.         for (int j = 0; j < N; j++)
    143.         {
    144.             if (!_arr[i][j])
    145.             {
    146.                 cnt++;
    147.             }
    148.             else
    149.             {
    150.                 col[j] -= 1 << (_arr[i][j] - 1);
    151.                 row[i] -= 1 << (_arr[i][j] - 1);
    152.                 cell[i / 3][j / 3] -= 1 << (_arr[i][j] - 1);
    153.             }
    154.         }
    155.     }
    156.  
    157.     return cnt;
    158. }
    159.  
    160. //只需一次初始化的数组map、ones
    161. void _init()
    162. {
    163.     //once设置成false后不再执行这个函数
    164.     once = false;
    165.  
    166.     //map和ones是一个映射关系，下标（二进制）->值（十进制）
    167.     // 
    168.     //map[10] = 2,意思是二进制为10的数十进制为2
    169.     for (int i = 0; i < N; i++)
    170.     {
    171.         map[1 << i] = i + 1;
    172.     }
    173.  
    174.     //ones[11] = 2,意思是二进制为11的数十进制为2
    175.     for (int i = 0; i < M; i++)
    176.     {
    177.         for (int j = 0; j < N; j++)
    178.         {
    179.             ones[i] += i >> j & 1;
    180.         }
    181.     }
    182. }
    183.  
    184. //初始化条件数组
    185. int init(int _arr[N][N])
    186. {
    187.     //设置row，col为111111111，代表1`9都在可填写状态
    188.     for (int i = 0; i < N; i++)
    189.     {
    190.         row[i] = col[i] = M - 1;
    191.     }
    192.  
    193.     //在9个宫中设置值为111111111，代表1`9都在可填写状态
    194.     for (int i = 0; i < 3; i++)
    195.     {
    196.         for (int j = 0; j < 3; j++)
    197.         {
    198.             cell[i][j] = M - 1;
    199.         }
    200.     }
    201.  
    202.     //只初始化一次
    203.     if (once)
    204.     {
    205.         _init();
    206.     }
    207.  
    208.     //填入数独表的已知数字，完成初始化工作。
    209.     return fill(_arr);
    210. }
    211.  
    212.  
    213.  
    214. //填数独
    215. bool dfs(int _arr[9][9], int cnt, int& t_ret)
    216. {
    217.     //如果可填数为0，则代表已经完成数独
    218.     if (!cnt)
    219.     {
    220.         return true;
    221.     }
    222.  
    223.     //找出最小可选位置，x、y表示坐标，minv代表可填数
    224.     int minv = 10;
    225.     int x, y;
    226.  
    227.     //每一个为0的位置都可以通过getmask(x,y)找到一个9位的二进制数，每一个位置上的1都代表对应数字可填
    228.     for (int i = 0; i < N; i++)
    229.     {
    230.         for (int j = 0; j < N; j++)
    231.         {
    232.             //如果状态码state中的1比minv小，则记录下该位置的xy坐标，并记录下最小可填值minv
    233.             if (!_arr[i][j])
    234.             {
    235.                 int state = getmask(i, j);
    236.                 if (ones[state] < minv)
    237.                 {
    238.                     minv = ones[state];
    239.                     x = i, y = j;
    240.                     //std::cout << std::endl;
    241.                     //printBinary(state);
    242.                 }
    243.             }
    244.         }
    245.     }
    246.  
    247.     //拿到状态码
    248.     int state = getmask(x, y);
    249.  
    250.     //lowbit取到可填数（从小到大），填了就从状态码中消除对应位置上的1
    251.     for (int i = state; i; i -= lowbit(i))
    252.     {
    253.         //拿到二进制对应的十进制数字num
    254.         int num = map[lowbit(i)];
    255.         //填入num
    256.         draw(_arr, x, y, num, false);
    257.         //开始填数，如果已经填完数独，则打印，并记录解的数量t_ret，最大解max_ret
    258.         if (dfs(_arr, cnt - 1, t_ret))
    259.         {
    260.             //print_arr(_arr);
    261.  
    262.             t_ret++;
    263.             max_ret = t_ret > max_ret ? t_ret : max_ret;
    264.         }
    265.         //撤销填入的num
    266.         draw(_arr, x, y, num, true);
    267.     }
    268.  
    269.     //如果 i = state 的值是0，那么就代表没有数字可以填的，返回失败，并消除上一位的数字
    270.     return false;
    271. }
    272.  
    273. //得到所有的数组，并记录下数独的最大解
    274. int _getallarr(int tmp[9][9], int& time)
    275. {
    276.     //将每一个已知数字的x，y坐标记录到vii
    277.     std::vectorint, int>> vii;
    278.     for (int i = 0; i < 9; i++)
    279.     {
    280.         for (int j = 0; j < 9; j++)
    281.         {
    282.             if (arr[i][j])
    283.             {
    284.                 vii.push_back({ i,j });
    285.             }
    286.         }
    287.     }
    288.  
    289.     //tmp1.tmp2存要删掉的两个数
    290.     int tmp1, tmp2;
    291.     //记录删除的数的坐标
    292.     int max_ret_tmp = max_ret;
    293.     std::vectorint, int>> vpii;
    294.     //依次删除两个数，为了保护源数独，把数据传入到tmp中
    295.     for (int i = 0; i < vii.size(); i++)
    296.     {
    297.         for (int j = i + 1; j < vii.size() - 1; j++)
    298.         {
    299.             tmp1 = tmp[vii[i].first][vii[i].second];
    300.             tmp[vii[i].first][vii[i].second] = 0;
    301.  
    302.             tmp2 = tmp[vii[j].first][vii[j].second];
    303.             tmp[vii[j].first][vii[j].second] = 0;
    304.  
    305.  
    306.             //计算最大解
    307.             int t_ret = 0;
    308.             int cnt = init(tmp);
    309.             dfs(tmp, cnt, t_ret);
    310.  
    311.             if (max_ret > max_ret_tmp)
    312.             {
    313.                 max_ret_tmp = max_ret;
    314.                 if (vpii.size() == 2)
    315.                 {
    316.                     vpii.erase(vpii.begin(), vpii.end());
    317.                 }
    318.                 vpii.push_back(vii[i]);
    319.                 vpii.push_back(vii[j]);
    320.             }
    321.  
    322.             //还原删除的数
    323.             tmp[vii[i].first][vii[i].second] = tmp1;
    324.             tmp[vii[j].first][vii[j].second] = tmp2;
    325.         }
    326.     }
    327.  
    328.     std::cout << "删除的坐标是：(" << vpii[0].first << vpii[0].second << ") && (" << vpii[1].first << vpii[1].second << ")" << std::endl;
    329.     return max_ret;
    330. }
    331.  
    332. //计算最大解
    333. int getMaxRet()
    334. {
    335.     //time为要删的数的个数
    336.     int time = 2;
    337.     //tmp为临时数组
    338.     int tmp[9][9] = { 0 };
    339.     copy_arr(tmp);
    340.  
    341.     //
    342.     return _getallarr(tmp, time);
    343. }
    344.

     main函数（如何执行这些代码） 

    1. int main()
    2. {
    3.     int t_ret = 0;
    4.     int cnt = init(arr);
    5.     dfs(arr,cnt, t_ret);
    6.     std::cout << max_ret;
    7.     std::cout << getMaxRet();
    8.  
    9.     return 0;
    10. }

    觉得写的不错的话给个三连加关注吧~

  • 相关阅读:
    React技术栈 --》组件对比和评论列表案例 ## Day4
    CSDN竞赛第四期季军 解题思路及参赛经历分享
    神经网络和深度学习-均方误差Mean Square Error
    排序——交换排序
    Centos修改系统时间
    【Kafka】——Producer
    Oracle：常用函数CASE WHEN，DECODE，NVL，SUBSTR，listagg，instr，to_char，to_number
    anaconda安装python 3.11
    RustGUI学习（iced）之小部件（二）：如何使用滑动条部件
    【Vue基础四】Vue检测数据改变的原理
  • 原文地址：https://blog.csdn.net/GMfengyi/article/details/133760088