LeetCode 37.解数独

最新推荐文章于 2024-05-23 17:21:42 发布
最新推荐文章于 2024-05-23 17:21:42 发布
阅读量54 收藏
点赞数
文章标签： c++ 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33894666/article/details/118710502
版权

解数独

LeetCode 37.解数独

解法一

纯暴力方法，未做任何优化

class Solution {
private:
    bool is_valid_place(vector<vector<char>>& board, int x, int y, char ch) {
        //行或者列放入字符ch是否有效
        for (int i = 0; i < 9; i++) {
            if (board[x][i] == ch || board[i][y] == ch) {
                return false;
            }
        }
        // 3x3 box放入字符ch是否有效
        int xstart = x / 3 * 3;
        int ystart = y / 3 * 3;
        for (int i = xstart; i < xstart + 3; i++) {
            for (int j = ystart; j < ystart + 3; j++) {
                if (board[i][j] == ch) {
                    return false;
                }
            }
        }
        return true;
    }
    bool back_track(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                // 找到空位置，开始从1到9，测试哪个数字有效
                if (board[i][j] == '.') {
                    for (int k = 0; k <= 8; k++) {
                        if (is_valid_place(board, i, j, k + '1')) {
                            board[i][j] = k + '1';
                            if (back_track(board) == true) {
                                return true;
                            }
                            board[i][j] = '.';
                        }
                    }
                    //该位置填入任何数字都无效，返回上一层，改变上一层(也就是前一个数）或更上层的
                    //来使这一层填入有效数字
                    return false;
                }
            }
        }
        //程序能运行到这里，说明一个空位置都没有了，上面的程序又可以确定空位置放入的是正确的数字，且题目保证数独有唯一解，所以返回true，回到第31行
        return true;
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        back_track(board);
    }
};

解法二

解法一纯暴力搜索，只要是’.‘的位置，都会从’1’ - '9’挨个放进去判断，直到放入正确的为止。

解法二用三个数组

row数组记录每一行中，数字1-9的使用情况，被使用为false，反之未被使用为true。

col数组记录每一列。

box数组记录每一个3x3box。

bool row[9][9] = { false };
bool col[9][9] = { false };
bool box[3][3][9] = { false };

一个重要的数组就是tab,记录哪一个点可以使用，因此直接遍历tab就行。

vector<pair<int, int>>tab;

在这里插入图片描述

  列号-1			1		2		3		4		5		6		7		8		9
  row[4]     	    F       T		F		F		T		T		T		F		T     
  col[4]			F		F		T		T		T		F		F		F		F	
  box[3][3]     	T		F		F		T		T		F		T		F		T

class Solution {
private:
    bool row[9][9] = { false };
    bool col[9][9] = { false };
    bool box[3][3][9] = { false };
    vector<pair<int, int>>tab;
    bool flag = false;

    void back_track(vector<vector<char>>& board, int point) {
        if (point >= tab.size()) {
            flag = true;
            return;//返回到上一层函数的调用，即第23行，这一层结束
        }
        int x = tab[point].first;
        int y = tab[point].second;
        for (char ch = 0; ch <= 8; ch++) {
            if (row[x][ch] && col[y][ch] && box[x / 3][y / 3][ch]) {
                board[x][y] = ch + '1';
                //这一数字使已经在这一行出现，标记为false，不能再出现
                row[x][ch] = false;
                //这一数字使已经在这一列出现，标记为false，不能再出现
                col[y][ch] = false;
                //这一数字使已经在这一3x3的box出现，标记为false，不能再出现
                box[x / 3][y / 3][ch] = false; 
                back_track(board, point + 1);
                if (flag) {
                    //如果能进入这个if，那么会返回上一层back_track()函数的调用，即上一句
                    //此后会一直返回
                    return;
                }
                //运行到这，说明填入的数字不对，数组都要回到填入该数字之前的状态
                board[x][y] = '.';
                //让该行的其他列使用该数字
                row[x][ch] = true;
                //让该列的其他行使用该数字
                col[y][ch] = true;
                //让该3x3的box的其他位置使用该数字
                box[x / 3][y / 3][ch] = true;
            }
        }
    }

public:
    void solveSudoku(vector<vector<char>>& board) {
        memset(row, true, sizeof(row));
        memset(col, true, sizeof(row));
        memset(box, true, sizeof(row));

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    //这个点没有数字，保存它的横纵坐标
                    tab.emplace_back(i, j);
                }
                else {
                    //数字num已经被使用，它所在的行，列，box都要作个标记
                    int num = board[i][j] - '1';
                    row[i][num] = false;
                    col[j][num] = false;
                    box[i / 3][j / 3][num] = false;
                }
            }
        }
        //从第一个空位置开始遍历
        back_track(board, 0);
    }
};

解法三

位运算

方法二中，一个数据是否使用，用一个bool来记录，其实可以用一个大小为9个位的变量val，足够记录1-9的使用情况

在这里插入图片描述

  					1		2		3		4		5		6		7		8		9
  row[4]     	    1       0		1		1		0		0		0		1		0     
  col[4]			1		1		0		0		0		1		1		1		1	
  box[3][3]    		0		0		1		0		0		1		0		1		0
  or				1  		1		1		1		0		1		1		1		1

一个数字字符，例如’3’，减去’1’后，为2，将1左移两位，二进制表示为pos = 0 0000 0100这样用一个位就能表示被使用了。用这个方法处理三个数组，和它所在的行、列、box数组对应的数字进行逻辑异或。

pos & -pos的含义是，取出最低位的位置来用，例如上面的3，如果4,5,6都没有被使用，那pos = 0 0011 1100，进行pos & -pos这个操作后等于num = 0 0000 0100，这个数刚是2k=4,k = 2，字符’1’ + 2 = ‘3’。log2(num) = 2。

pos & pos - 1的含义是，删掉最后一个最低位，还用上面的例子，如果4,5,6都没有被使用，那pos = 0 0011 1100，进行pos & pos - 1操作后，等于 0 0011 1000。

这两个操作还可以看我的这篇文章,都有解释

N皇后II C++ 集合 位运算

class Solution {
private:
    short row[9] = { 0 };
    short col[9] = { 0 };
    short box[9][9] = { 0 };
    vector<pair<int, int>>point;
    bool flag = false;
public:

    void lgxor(int x, int y, int num) {
        row[x] ^= num;
        col[y] ^= num;
        box[x / 3][y / 3] ^= num;
    }

    void back_track(vector<vector<char>>& board, int p) {
        if (p >= point.size()) {
            flag = true;//同方法二
            return;
        }
        int x = point[p].first;
        int y = point[p].second;
        // 0x1ff = 1 1111 1111 九个位
        int pos = 0x01ff & ~(row[x] | col[y] | box[x / 3][y / 3]);
        while (0 != pos) {
            int num = pos & (-pos);
            pos &= pos - 1;
            char ch = log2(num);
            board[x][y] = '1' + ch;
            //与num异或，该数字所在行和列和box不能再次出现
            lgxor(x, y, num);
            back_track(board, p + 1);
            if (true == flag) {//同方法二
                return;
            }
            //与num异或，该数字所在行和列和box可以再次出现
            lgxor(x, y, num);
        }
    }

    void solveSudoku(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if ('.' == board[i][j]) {
                    point.emplace_back(i, j);
                }
                else {
                    int num = board[i][j] - '1';
                    lgxor(i, j, 1 << num);
                }
            }
        }
        back_track(board, 0);
    }
};

解法三优化

解法二中，有一些点的数字可以直接确定下来，首先将这些点填好，会省下很多时间。

  					1		2		3		4		5		6		7		8		9
  row[4]     	   	1       0		1		1		0		0		0		1		0     
  col[4]			1		1		0		0		0		1		1		1		1	
  box[3][3]    		0		0		1		0		0		1		0		1		0
  or				1  		1		1		1		0		1		1		1		1

这些点的性质就是，所在行、列、box的数字相或之后，有且仅有一个能放的数字，也就是说进行pos & pos - 1操作，移除最后一个位置后，pos为0。

class Solution {
private:
    short row[9] = { 0 };
    short col[9] = { 0 };
    short box[9][9] = { 0 };
    vector<pair<int, int>>point;
    bool flag = false;
public:

    void lgxor(int x, int y, int num) {
        row[x] ^= num;
        col[y] ^= num;
        box[x / 3][y / 3] ^= num;
    }

    void back_track(vector<vector<char>>& board, int p) {
        if (p >= point.size()) {
            flag = true;
            return;
        }
        int x = point[p].first;
        int y = point[p].second;
        int pos = 0x01ff & ~(row[x] | col[y] | box[x / 3][y / 3]);
        while (0 != pos) {
            int num = pos & (-pos);
            pos &= pos - 1;
            char ch = log2(num);
            board[x][y] = '1' + ch;
            lgxor(x, y, num);
            back_track(board, p + 1);
            if (true == flag) {
                return;
            }
            lgxor(x, y, num);
        }
    }

    void solveSudoku(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if ('.' != board[i][j]) {
                    int num = board[i][j] - '1';
                    lgxor(i, j, 1 << num);
                }
            }
        }

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if ('.' == board[i][j]) {
                    int pos = 0x01ff & ~(row[i] | col[j] | box[i / 3][j / 3]);
                    if (0 == (pos & (pos - 1))) {
                        int num = log2(pos);
                        lgxor(i, j, 1 << num);
                        board[i][j] = '1' + num;
                    }
                    else {
                        point.emplace_back(i, j);
                    }

                }
            }
        }
        back_track(board, 0);
    }
};

性能对比，用同一个解法解同一个数独500次，看它所耗费的时间，测试很粗糙，不具代表性。

单位，毫秒。

在这里插入图片描述

//夜游神
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode——-解数独(回溯法)
01-20
如： 方法：回溯法： 回溯法的思想就是：对于一个问题有多个选择方式，先选择一个方式执行下去，若在执行过程中，发现不符合规则，则回退，回到选择方式的步骤，进而选择其他方式，继续试。 重要：对于回溯法，一定...
Sologala#LeetCode#解数独1
07-25
[37]解数独|sudoku-solverDFS 搜索即可重点在于 可以使用的判断 ，这里建立三种bitset<9> 来作为某个位置是否能够选用这个数字的凭据。
Leetcode 37. 解数独
qq_44653420的博客
08-30 361
Leetcode 37. 解数独
LeetCode37. 解数独
明觉
03-31 207
编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3宫内只能出现一次。 空白格用 ‘.’ 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是...
leetcode 37. 解数独
gq的博客
10-20 180
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。数独部分空格内已填入了数字，空白格用 ‘.’ 表示。board[i][j] 是一位数字或者 ‘.’编写一个程序，通过填充空格来解决数独问题。数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。题目数据 保证 输入数独仅有一个解。
LeetCode 37. 解数独
weixin_43918046的博客
07-20 143
解数独 编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 ‘.’ 表示。 示例： 输入：board = [[“5”,“3”,".",".",“7”,".",".",".","."],[“6”,".",".",“1”,“9”,“5”,".",".","."],[".",“9”,“8”,.
Leetcode37. 解数独
JavaAlliance
07-08 149
题目传送地址: https://leetcode.cn/problems/sudoku-solver/好开心，这道题解出来了 代码如下：
Python描述 LeetCode 37. 解数独
亓官劼的博客
06-11 180
编写一个程序，通过填充空格来解决数独问题。数独的解法需 遵循如下规则：数独部分空格内已填入了数字，空白格用 表示。示例 1： 提示：DFS一路向前搜索，挨个将空格填上数字，当全部满足时，返回结束循环...
leetcode37. 解数独
kkkkuuga的博客
03-01 198
编写一个程序，通过填充空格来解决数独问题。数独的解法需遵循如下规则数字1-9在每一行只能出现一次；数字1-9在每一列只能出现一次；数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次；数独部分空格内已填入了数字，空白格用'.'表示。双层for循环首先找到空的位置，再一个for循环开始1-9数字的递归回溯。因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用返回值。...
leetcode 37.解数独
玛软的垃圾桶
09-18 206
leetcode 37.解数独 题干 编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9 形式的。 题解 dfs+回溯算法 * 回溯算法的核心在于条件重新置false的语句的位置 * 第一遍写
python-leetcode面试题解之第37题解数独-python题解.zip
03-12
python python_leetcode面试题解之第37题解数独_python题解
噪声leetcode-sudoku:给杨咩咩的解数独小程序
06-30
噪声 leetcode
LeetCode解题总结
10-09
10.5 解数独 10.6 单词搜索 10.7 小结 10.7.1 适用场景 10.7.2 思考步骤 10.7.3 代码模板 10.7.4 深搜与回溯、递归的区别 11. 分治法 11.1 实现pow(x, n) 11.2 Sqrt(x) 12. 贪心算法 12.1 跳台阶游戏 12.2 买卖股票...
C语言简要（四）
m0_74057302的博客
05-21 301
有没有好心师傅教教孩子逆向和pwn啊°꒰๑'ꀾ'๑꒱°
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 754
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
c++ const 的多种用途
05-17 180
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
Python教程：使用Python和PyQt编写进制转换器工具
最新发布
复现的博客
05-23 312
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
C/C++免杀--原生态(GG)
金灰的博客
05-20 366
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
leetcode 204.计数质数 python
09-06
# 初始化标记数组，默认所有数都是质数 is_prime = [1] * n is_prime[0] = is_prime[1] = 0 # 埃氏筛法 for i in range(2, int(n ** 0.5) + 1): if is_prime[i]: # 将i的倍数标记为合数 is_prime[i*i:n:i]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值