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

已于 2023-10-11 23:10:28 修改
阅读量1.1k 收藏 9
点赞数 7
分类专栏： 进阶算法 文章标签： 深度优先 算法 c++ c语言 数据结构 dfs 搜索
于 2023-10-11 11:05:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gmfengyi/article/details/133760088
版权

目录

什么是数独？ 

数独的解法？

数独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（十进制）；

//设置9*9数独表
const int N = 9;
//设置mask长度 M的二进制：111111111，从右到左分别表示1 2 3 4 5 6 7 8 9 
const int M = 1 << N;

//row、col、cell分别表示行、列、宫可填写数的编码
//ones、map是一个映射关系，ones表示有多少个1，map表示9位二进制的1代表的数字
int row[N], col[N], cell[3][3];
int ones[M], map[M];

//数独表
int arr[9][9] = {
    4,0,0,9,0,0,0,0,3,
    0,8,0,0,0,1,0,9,0,
    0,0,0,0,2,0,7,0,0,
    0,3,0,0,0,0,0,0,4,
    0,0,6,7,0,0,5,0,0,
    2,0,0,0,0,0,0,6,0,
    0,0,7,0,3,0,6,0,0,
    0,5,0,6,0,0,0,0,0,
    1,0,0,0,0,9,0,0,2
};

那么M是用来干嘛的？

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

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

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

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

//只需一次初始化的数组map、ones
void _init()
{
    //once设置成false后不再执行这个函数
    once = false;

    //map和ones是一个映射关系，下标（二进制）->值（十进制）
    // 
    //map[10] = 2,意思是二进制为10的数十进制为2
    for (int i = 0; i < N; i++)
    {
        map[1 << i] = i + 1;
    }

    //ones[11] = 2,意思是二进制为11的数十进制为2
    for (int i = 0; i < M; i++)
    {
        for (int j = 0; j < N; j++)
        {
            ones[i] += i >> j & 1;
        }
    }
}

//初始化条件数组
int init(int _arr[N][N])
{
    //设置row，col为111111111，代表1`9都在可填写状态
    for (int i = 0; i < N; i++)
    {
        row[i] = col[i] = M - 1;
    }

    //在9个宫中设置值为111111111，代表1`9都在可填写状态
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cell[i][j] = M - 1;
        }
    }

    //只初始化一次
    if (once)
    {
        _init();
    }

    //填入数独表的已知数字，完成初始化工作。
    return fill(_arr);
}

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

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

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

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

//将数组上已知数的位置、值信息做初始化记录，并记录需要填写的格子数
int fill(int _arr[N][N])
{
    //cnt为待填格子数
    int cnt = 0;

    //设置cnt，row、col、cell条件
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (!_arr[i][j])
            {
                cnt++;
            }
            else
            {
                col[j] -= 1 << (_arr[i][j] - 1);
                row[i] -= 1 << (_arr[i][j] - 1);
                cell[i / 3][j / 3] -= 1 << (_arr[i][j] - 1);
            }
        }
    }

    return cnt;
}

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

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

3. 填数独

前置有3个功能函数。

这里说一下getmask，

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

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

//获得可填数的编码位（截断到最靠右的1） 例如10110 lowbit后得到10 
inline int lowbit(int x)
{
    return x & -x;
}


//获取可填数据 col，row，cell经过位运算可得到一串二进制数字，二进制的1代表可以填进数独的数字
int getmask(int x, int y)
{
    //printBinary(row[x]);
    //std::cout << " ";

    //printBinary(col[y]);
    //std::cout << " ";

    //printBinary(cell[x/3][y/3] );
    //std::cout << " ";

    //printBinary(col[y] & row[x] & cell[x / 3][y / 3]);

    return col[y] & row[x] & cell[x / 3][y / 3];
}


//填数字
void draw(int _arr[9][9], int x, int y, int num, bool is_set)
{
    //如果这个位置已经被填过，那么消除这个位置上的数字
    //如果没有，就设置成num
    if (is_set)
    {
        _arr[x][y] = 0;
    }
    else
    {
        _arr[x][y] = num;
    }

    //将数字num转化成二进制码
    int v = 1 << (num - 1);

    //根据这个位置是否有数字，修改 + - 的逻辑
    if (is_set)
    {
        v = -v;
    }

    // -v 代表此位置行，列，宫的可填数num已经填入，该行，列，宫不可再填num
    row[x] -= v;
    col[y] -= v;
    cell[x / 3][y / 3] -= v;
}

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

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

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

//填数独
bool dfs(int _arr[9][9], int cnt, int& t_ret)
{
    //如果可填数为0，则代表已经完成数独
    if (!cnt)
    {
        return true;
    }

    //找出最小可选位置，x、y表示坐标，minv代表可填数
    int minv = 10;
    int x, y;

    //每一个为0的位置都可以通过getmask(x,y)找到一个9位的二进制数，每一个位置上的1都代表对应数字可填
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            //如果状态码state中的1比minv小，则记录下该位置的xy坐标，并记录下最小可填值minv
            if (!_arr[i][j])
            {
                int state = getmask(i, j);
                if (ones[state] < minv)
                {
                    minv = ones[state];
                    x = i, y = j;
                    //std::cout << std::endl;
                    //printBinary(state);
                }
            }
        }
    }

    //拿到状态码
    int state = getmask(x, y);

    //lowbit取到可填数（从小到大），填了就从状态码中消除对应位置上的1
    for (int i = state; i; i -= lowbit(i))
    {
        //拿到二进制对应的十进制数字num
        int num = map[lowbit(i)];
        //填入num
        draw(_arr, x, y, num, false);
        //开始填数，如果已经填完数独，则打印，并记录解的数量t_ret，最大解max_ret
        if (dfs(_arr, cnt - 1, t_ret))
        {
            //print_arr(_arr);

            t_ret++;
            max_ret = t_ret > max_ret ? t_ret : max_ret;
        }
        //撤销填入的num
        draw(_arr, x, y, num, true);
    }

    //如果 i = state 的值是0，那么就代表没有数字可以填的，返回失败，并消除上一位的数字
    return false;
}

 4. 拓展问题

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

 删除的是哪两个数？

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

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

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

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

//得到所有的数组，并记录下数独的最大解
int _getallarr(int tmp[9][9], int& time)
{
    //将每一个已知数字的x，y坐标记录到vii
    std::vector<std::pair<int, int>> vii;
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            if (arr[i][j])
            {
                vii.push_back({ i,j });
            }
        }
    }

    //tmp1.tmp2存要删掉的两个数
    int tmp1, tmp2;
    //记录删除的数的坐标
    int max_ret_tmp = max_ret;
    //vpii的每一个元素都是一对坐标，我们只保留2对坐标
    std::vector<std::pair<int, int>> vpii;
    //依次删除两个数，为了保护源数独，把数据传入到tmp中
    for (int i = 0; i < vii.size(); i++)
    {
        for (int j = i + 1; j < vii.size() - 1; j++)
        {
            //存下要删掉的数，搜索完还原。
            tmp1 = tmp[vii[i].first][vii[i].second];
            tmp[vii[i].first][vii[i].second] = 0;

            tmp2 = tmp[vii[j].first][vii[j].second];
            tmp[vii[j].first][vii[j].second] = 0;


            //计算最大解
            int t_ret = 0;
            int cnt = init(tmp);
            dfs(tmp, cnt, t_ret);

            //如果最大解的数值发生变化，那么记录下该点的坐标。
            if (max_ret > max_ret_tmp)
            {
                //此处还可做优化，比如说把2改成time，删time个数的最大解是哪三个？
                max_ret_tmp = max_ret;
                if (vpii.size() == 2)
                {
                    vpii.erase(vpii.begin(), vpii.end());
                }
                vpii.push_back(vii[i]);
                vpii.push_back(vii[j]);
            }

            //还原删除的数
            tmp[vii[i].first][vii[i].second] = tmp1;
            tmp[vii[j].first][vii[j].second] = tmp2;
        }
    }

    std::cout << "删除的坐标是：(" << vpii[0].first << vpii[0].second << ") && (" << vpii[1].first << vpii[1].second << ")" << std::endl;
    return max_ret;
}

//计算最大解
int getMaxRet()
{
    //time为要删的数的个数
    int time = 2;
    //tmp为临时数组
    int tmp[9][9] = { 0 };
    copy_arr(tmp);

    //
    return _getallarr(tmp, time);
}

 最终代码

//设置9*9数独表
const int N = 9;
//设置mask长度 M的二进制：111111111，从右到左分别表示1 2 3 4 5 6 7 8 9 
const int M = 1 << N;

//row、col、cell分别表示行、列、宫可填写数的编码
//ones、map是一个映射关系，ones表示有多少个1，map表示9位二进制的1代表的数字
//max_ret表示数独的最大解
//once 卡关，ones和map数组只需初始化一次 
int row[N], col[N], cell[3][3];
int ones[M], map[M];
int max_ret;
bool once = true;

//数独表
int arr[9][9] = {
    4,0,0,9,0,0,0,0,3,
    0,8,0,0,0,1,0,9,0,
    0,0,0,0,2,0,7,0,0,
    0,3,0,0,0,0,0,0,4,
    0,0,6,7,0,0,5,0,0,
    2,0,0,0,0,0,0,6,0,
    0,0,7,0,3,0,6,0,0,
    0,5,0,6,0,0,0,0,0,
    1,0,0,0,0,9,0,0,2
};

//打印二进制格式（调试用）
void printBinary(int num) 
{
    if (num == 0) {
        std::cout << "0";
        return;
    }

    int binary[32];
    int i = 0;

    while (num > 0) {
        binary[i] = num % 2;
        num /= 2;
        i++;
    }

    for (int j = i - 1; j >= 0; j--) {
        std::cout << binary[j];
    }
}

//获得可填数的编码位（截断到最靠右的1） 例如10110 lowbit后得到10 
inline int lowbit(int x)
{
    return x & -x;
}

//打印数独表
void print_arr(int _arr[9][9])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            std::cout << _arr[i][j];
        }
        std::cout << std::endl;
    }

    std::cout << std::endl;
}

//复制数独表到tmp
void copy_arr(int tmp[][9])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            tmp[i][j] = arr[i][j];
        }
    }

    std::cout << std::endl;
}



//获取可填数据 col，row，cell经过位运算可得到一串二进制数字，二进制的1代表可以填进数独的数字
int getmask(int x, int y)
{
    //printBinary(row[x]);
    //std::cout << " ";

    //printBinary(col[y]);
    //std::cout << " ";

    //printBinary(cell[x/3][y/3] );
    //std::cout << " ";

    //printBinary(col[y] & row[x] & cell[x / 3][y / 3]);

    return col[y] & row[x] & cell[x / 3][y / 3];
}

//填数字
void draw(int _arr[9][9], int x, int y, int num, bool is_set)
{
    //如果这个位置已经被填过，那么消除这个位置上的数字
    //如果没有，就设置成num
    if (is_set)
    {
        _arr[x][y] = 0;
    }
    else
    {
        _arr[x][y] = num;
    }

    //将数字num转化成二进制码
    int v = 1 << (num - 1);

    //根据这个位置是否有数字，修改 + - 的逻辑
    if (is_set)
    {
        v = -v;
    }

    // -v 代表此位置行，列，宫的可填数num已经填入，该行，列，宫不可再填num
    row[x] -= v;
    col[y] -= v;
    cell[x / 3][y / 3] -= v;
}

//将数组上已知数的位置、值信息做初始化记录，并记录需要填写的格子数
int fill(int _arr[N][N])
{
    //cnt为待填格子数
    int cnt = 0;

    //设置cnt，row、col、cell条件
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (!_arr[i][j])
            {
                cnt++;
            }
            else
            {
                col[j] -= 1 << (_arr[i][j] - 1);
                row[i] -= 1 << (_arr[i][j] - 1);
                cell[i / 3][j / 3] -= 1 << (_arr[i][j] - 1);
            }
        }
    }

    return cnt;
}

//只需一次初始化的数组map、ones
void _init()
{
    //once设置成false后不再执行这个函数
    once = false;

    //map和ones是一个映射关系，下标（二进制）->值（十进制）
    // 
    //map[10] = 2,意思是二进制为10的数十进制为2
    for (int i = 0; i < N; i++)
    {
        map[1 << i] = i + 1;
    }

    //ones[11] = 2,意思是二进制为11的数十进制为2
    for (int i = 0; i < M; i++)
    {
        for (int j = 0; j < N; j++)
        {
            ones[i] += i >> j & 1;
        }
    }
}

//初始化条件数组
int init(int _arr[N][N])
{
    //设置row，col为111111111，代表1`9都在可填写状态
    for (int i = 0; i < N; i++)
    {
        row[i] = col[i] = M - 1;
    }

    //在9个宫中设置值为111111111，代表1`9都在可填写状态
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cell[i][j] = M - 1;
        }
    }

    //只初始化一次
    if (once)
    {
        _init();
    }

    //填入数独表的已知数字，完成初始化工作。
    return fill(_arr);
}



//填数独
bool dfs(int _arr[9][9], int cnt, int& t_ret)
{
    //如果可填数为0，则代表已经完成数独
    if (!cnt)
    {
        return true;
    }

    //找出最小可选位置，x、y表示坐标，minv代表可填数
    int minv = 10;
    int x, y;

    //每一个为0的位置都可以通过getmask(x,y)找到一个9位的二进制数，每一个位置上的1都代表对应数字可填
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            //如果状态码state中的1比minv小，则记录下该位置的xy坐标，并记录下最小可填值minv
            if (!_arr[i][j])
            {
                int state = getmask(i, j);
                if (ones[state] < minv)
                {
                    minv = ones[state];
                    x = i, y = j;
                    //std::cout << std::endl;
                    //printBinary(state);
                }
            }
        }
    }

    //拿到状态码
    int state = getmask(x, y);

    //lowbit取到可填数（从小到大），填了就从状态码中消除对应位置上的1
    for (int i = state; i; i -= lowbit(i))
    {
        //拿到二进制对应的十进制数字num
        int num = map[lowbit(i)];
        //填入num
        draw(_arr, x, y, num, false);
        //开始填数，如果已经填完数独，则打印，并记录解的数量t_ret，最大解max_ret
        if (dfs(_arr, cnt - 1, t_ret))
        {
            //print_arr(_arr);

            t_ret++;
            max_ret = t_ret > max_ret ? t_ret : max_ret;
        }
        //撤销填入的num
        draw(_arr, x, y, num, true);
    }

    //如果 i = state 的值是0，那么就代表没有数字可以填的，返回失败，并消除上一位的数字
    return false;
}

//得到所有的数组，并记录下数独的最大解
int _getallarr(int tmp[9][9], int& time)
{
    //将每一个已知数字的x，y坐标记录到vii
    std::vector<std::pair<int, int>> vii;
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            if (arr[i][j])
            {
                vii.push_back({ i,j });
            }
        }
    }

    //tmp1.tmp2存要删掉的两个数
    int tmp1, tmp2;
    //记录删除的数的坐标
    int max_ret_tmp = max_ret;
    std::vector<std::pair<int, int>> vpii;
    //依次删除两个数，为了保护源数独，把数据传入到tmp中
    for (int i = 0; i < vii.size(); i++)
    {
        for (int j = i + 1; j < vii.size() - 1; j++)
        {
            tmp1 = tmp[vii[i].first][vii[i].second];
            tmp[vii[i].first][vii[i].second] = 0;

            tmp2 = tmp[vii[j].first][vii[j].second];
            tmp[vii[j].first][vii[j].second] = 0;


            //计算最大解
            int t_ret = 0;
            int cnt = init(tmp);
            dfs(tmp, cnt, t_ret);

            if (max_ret > max_ret_tmp)
            {
                max_ret_tmp = max_ret;
                if (vpii.size() == 2)
                {
                    vpii.erase(vpii.begin(), vpii.end());
                }
                vpii.push_back(vii[i]);
                vpii.push_back(vii[j]);
            }

            //还原删除的数
            tmp[vii[i].first][vii[i].second] = tmp1;
            tmp[vii[j].first][vii[j].second] = tmp2;
        }
    }

    std::cout << "删除的坐标是：(" << vpii[0].first << vpii[0].second << ") && (" << vpii[1].first << vpii[1].second << ")" << std::endl;
    return max_ret;
}

//计算最大解
int getMaxRet()
{
    //time为要删的数的个数
    int time = 2;
    //tmp为临时数组
    int tmp[9][9] = { 0 };
    copy_arr(tmp);

    //
    return _getallarr(tmp, time);
}

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

int main()
{
    int t_ret = 0;
    int cnt = init(arr);
    dfs(arr,cnt, t_ret);
    std::cout << max_ret;
    std::cout << getMaxRet();

    return 0;
}

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

C语言学习日记（17）——回溯法解数独（2）
u010340279的博客
06-12 614
通过前面的分析，就可以写出解数独的代码了。 #include <stdio.h> void fill(int sd[][9]); //使用回溯法求解数独 int main() { int sd[9][9] = { // “世界最难数独”信息 8,0,0,0,0,0,0,0,0, 0,0,3,6,0,0,0,0,0, 0,7,0,0,9,0,2,0,0, 0,5,0,0,0,7,0,0,0,
标准数独解题之旅（用一道数独题讲解最基本的5种解题技巧）
weixin_33826268的博客
10-10 711
转载请注明出自独数之道以下我们将叙述一道标准数独的全部解题过程，在此过程中涉及到的技巧有摒除法、余数法、区块法、数对法、X-Wing这几个常在数独书籍中会涉及到的技巧，文中将描述各个技巧的结构及作用效果，相信在看完解题过程之后，您能相当程度地掌握到数独的基本解题技巧，也能在解题的过程中发现数独给您带来的乐趣。谜题如下图第一招：摒除法大家之前已阅读过数独的规则：在每个单元中...
C#语言实现数独解题专家
最新发布
weixin_42610671的博客
09-26 1141
本文还有配套的精品资源，点击获取 简介：数独是一种广受欢迎的逻辑游戏，本文章将详细探讨如何使用C#语言开发一个数独破解程序。文章将解释数独的规则，并讨论C#面向对象的特性如何适用于逻辑程序的编写。数独破解算法通常涉及回溯法和递归深度优先搜索，本程序通过递归方法填充数独网格中的空单元格，并在遇到规则冲突时回溯。文章分析了可能的主文件“SudokuCrack”，它包含了数独网格...
数独求解算法
nicebooks的专栏
04-20 5236
算法基本思想：1.数据结构，利用short来存每个格子的值。利用低位的9个bit来表示每个格子的值，如果是待确定的格子，则初始化时将最高位的bit置1，低位9个bit全部置1. 如果是已给出或推算出确定的唯一值，只要置上低位9个bit里对应的1个bit。2.求解思路   （1）遍历每个待确定的格子S,    首先排除S所在9宫其他已确定的值，将那些值对应的bit置0。   第二，排除S所在列的其他已确定的值，将那些值对应的bit置0。   第三，排除S所在行的其他已确定的值，将那些值对应的bit置0。  
数独算法-递归与回溯
热门推荐
後雪寒的专栏
12-07 2万+
1.概述数独（Sudoku）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 1)终盘数量: 数独中的数字排列千变万化，那么究竟有多少种终盘的数字组合呢？ 6,670,903,752,021,072,936,960（约为6.67×10的21次方）种组合
C语言解数独
03-14
一个用C语言写出来的解数独的程序，在一个叫yuan.txt的文本文件中把数独的题写上去，空格用0代替，然后运行就会生成一个叫jie.txt的文件，里边是已经解好的。
用C语言求解数独
u010179747的博客
06-05 1699
今天中午无聊之际，玩了下数独，玩了一把，速度很慢，于是想着，怎样用程序来解题呢，第一个想法就是暴力搜索，于是写了代码如下，暂时没有想到其他的算法，有更有算法的同学，欢迎一起交流。 #include <stdio.h> #include <stdlib.h> int SolveCount = 0 ; //! 解法计数 //! 需要求解的数独数据 0表示未知数，需要求解的值，不同的数独，修改此数组的值 int SudokuArr[9][9] = { /*{0
数独算法
编程资料大全
06-14 125
1.产生符合数独规则的初始矩阵 第一行是随机生成的1~9的排列，第2到9行就要通过搜索来产生了。对于第2到9行的每一个空格，要从1到9逐个尝试放入，看同一列、同一行、同一个3×3的小方阵中是否出现过相同的数字，若没有就尝试放入，然后递归地搜索下一个位置的数字，若1到9都不行就返回上一个位置尝试下一个数字。直到找到一组解就返回。 先上C++代码： #include&lt;iost...
数独的计算机求解
weixin_33796205的博客
12-18 288
今天晚上抽空把数独的计算机求解也给实现了一下，由于时间有限，我这里追求的是简洁而有效的解法，故用的是最原始而直观的回溯算法。速度也还可以接受，解网上最难的数独也大概就0.0X秒的样子。最开始是一个面向过程的实现，考虑到用的是C#的实现，便把这个算法给OO化了一下。 class Sudoku{    public int[,] Numbers { get; set; }    ...
c语言实现数独问题
12-08
只适合初学者学习：设计程序的思路是排除法，排除'0'格子所在行、列、九宫内出现过的数字 填充唯一可能的数字 由于程序的功能不是很全面，测试的题目不能太复杂，尽量是一级难度的
一种高效的剪枝解数独策略
Leo_h
03-24 1473
数独是一种经典的智力游戏。数独可以转化为精确覆盖问题，从而使用精确覆盖问题的通用解法：舞蹈链(DLX)来解决。本文将介绍一种通过通过回溯法与剪枝来解决数独的方法。经OJ测验，其效率与DLX相差无几，甚至比DLX略快。
解数独程序
10-21
想写这个程序源于芬兰的某数学家设计出了个号称史上最难的数独，本来想自己算算，可惜自己真的算不出来。于是便想写个程序把结果解出来。自动填充该数独。
数独程序算法，有用的算法
05-21
数独，算法，java，很简单实现数独的算法
一个解数独的程序
03-18
NULL 博文链接：https://lc-wangchao.iteye.com/blog/652165
c语言求解的数独问题
05-23
c语言求解的数独问题。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
软工个人项目之生成和求解数独
hhhhhhh455的博客
12-29 511
生成和求解数独 在这次完成个人项目的过程中，我第一次尝试了写csdn博客，用vs进行性能分析，在vs里面写单元测试，这次收获了很多。虽然还有很多需要改进的地方，但我会做得越来越好的~ 1、Github地址 https://github.com/hll455/Project-Sodoku 2、psp表格—估计花费时间 psp2.1 Personal Software Process ...
ZZNUOJ算法题目录(C语言)
彬sir哥的博客
09-25 5069
1、ZZNUOJ的ZZNU和OJ各是什么 ZZNU是Zhengzhou Normal University的缩写，翻译：郑州师范学院 OJ是Online Judge系统的简称，用来在线检测程序源代码的正确性。OJ系统能够编译并执行代码，使用预设的数据对这些程序进行测试。提交的代码一般会在受限的环境下运行，包括时间限制、内存限制、安全限制等。Online Judge系统最初使用于ACM-ICPC国际大学生程序设计竞赛和OI信息学奥林匹克竞赛中的自动判题和排名。现广泛应用于世界各地高校学生程序设计的训练、参
第五章——回溯法
weixin_55835175的博客
06-05 1483
对于回溯法的概念，我们需要先从回溯法在实际解决问题中的表现来理解。书上称：回溯法实际上是一个类似穷举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现不满足求解条件时，就“回溯”（即回退），然后尝试别的可能。就我个人的角度而言，我不认为回溯法是一个类似于穷举的方法，而是针对于一些通过穷举法求解的问题：问题求解过程中的各个可能出现的状态作为结点，通过决策将两两结点连边构成一棵有向树，存在一个或多个我们想要求解的目标状态。为了得到我们的目标状态(或者是初始状态到目标状态的路径)，我们采取深度优先遍历的策
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Laxinues

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值