Leetcode：37. 解数独（C++）

Cosmoshhhyyy

已于 2023-01-28 18:32:25 修改

阅读量383

点赞数

分类专栏： LeetCode 文章标签： c++ leetcode 算法数据结构

于 2023-01-27 12:36:02 首次发布

本文链接：https://blog.csdn.net/Cosmoshhhyyy/article/details/128769752

版权

LeetCode 专栏收录该内容

234 篇文章 5 订阅

订阅专栏

问题描述：

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

实现代码与解析：

回溯：

class Solution {
public:
    bool backtracking(vector<vector<char>>& board)
    {
        //两层循环找位置
       for(int row=0;row<board.size();row++)
       {
           for(int col=0;col<board[0].size();col++)
           {
               //找到位置
               if(board[row][col]=='.')
               {
                    //选择1~9的数字
                    for(char i='1';i<='9';i++)
                    {
                        //判断此数是否有效
                        if(isvaild(row,col,i,board))
                        {
                            board[row][col]=i;
                            bool flag=backtracking(board);//递归
                            //这里只用寻找一个符合的结果就行，找到后直接返回
                            if(flag==true)
                            {
                                return true;
                            }
                            board[row][col]='.';//回溯
                        }                       
                    }
                    return false;//都不成立，返回false
               }              
           }          
       }
       return true;//未找到位置，说明已经填满，返回true
    }

    bool isvaild(int row,int col,char val,vector<vector<char>>& board)
    {
        //一行是否有重复
        for(int i=0;i<9;i++)
        {
            if(board[row][i]==val) return false;
        }
        //一列是否有重复
        for(int i=0;i<9;i++)
        {
            if(board[i][col]==val) return false;
        }
        //9格内是否有重复
        int startrow=(row/3)*3;//起始行
        int startcol=(col/3)*3;//起始列
        for(int i=startrow;i<startrow+3;i++)
        {
            for(int j=startcol;j<startcol+3;j++)
            {
                if(board[i][j]==val) return false;
            }
        }
        return true;
    }

    void solveSudoku(vector<vector<char>>& board) 
    {
        backtracking(board);
    }
};

原理思路：

此题最大的难点其实就是维度上了，因为这里我们不仅要在二维的棋盘上找到没有填入数字的位置，还要找出要填入的正确的数字，所以虽然此题用了递归和回溯，但是还是要写好几层循环，下面讲讲具体如何实现的。

1、这里我们只用得到一个结果，所以我们回溯函数的返回值为bool类型，后面我们会设置一个flag来接收，判断若已经找到一个结果，我么直接停止寻找。

2、回溯函数的参数只有一个board，因为我们每次寻找位置都是从头开始寻找，就不再传入额外参数来寻找开始位置了。

3、回溯函数的终止条件，这里我们不用像其他题一样在开头给出终止条件，我们写在最后，当我们找不到位置时，没有进行下一次循环，说明棋盘格已经被填满了，就找到结果了，返回true。

4、就开始写寻找位置和寻找合适的数的代码逻辑了，同时还要判断填入数字是否有效，若有效才进行下一次递归，否则直接返回false，重新寻找，很简单，直接给出代码：

//两层循环找位置
       for(int row=0;row<board.size();row++)
       {
           for(int col=0;col<board[0].size();col++)
           {
               //找到位置
               if(board[row][col]=='.')
               {
                    //选择1~9的数字
                    for(char i='1';i<='9';i++)
                    {
                        //判断此数是否有效
                        if(isvaild(row,col,i,board))
                        {
                            board[row][col]=i;
                            bool flag=backtracking(board);//递归
                            //这里只用寻找一个符合的结果就行，找到后直接返回
                            if(flag==true)
                            {
                                return true;
                            }
                            board[row][col]='.';//回溯
                        }                       
                    }
                    return false;//都不成立，返回false
               }              
           }          
       }

5、然后就是判断当前位置的数字是否有效了，根据题意也是很好写出的，如下：‘

     bool isvaild(int row,int col,char val,vector<vector<char>>& board)
    {
        //一行是否有重复
        for(int i=0;i<9;i++)
        {
            if(board[row][i]==val) return false;
        }
        //一列是否有重复
        for(int i=0;i<9;i++)
        {
            if(board[i][col]==val) return false;
        }
        //9格内是否有重复
        int startrow=(row/3)*3;//起始行
        int startcol=(col/3)*3;//起始列
        for(int i=startrow;i<startrow+3;i++)
        {
            for(int j=startcol;j<startcol+3;j++)
            {
                if(board[i][j]==val) return false;
            }
        }
        return true;
    }

其实看起来很难，如果逻辑搞清楚，其实还是很好写出的。回溯其实就是模拟嵌套循环的过程，适合解决的就是不知道要嵌套循环多少次的情况，比如这题，我们不知道没有填入数字的棋盘格有多少，这里为什么和其他题不一样，而是是嵌套了三层循环才开始递归回溯呢？其实上面也解释了，我们要在二维上找位置，还要找数字，如果还是不太理解的话，当写回溯的题，可以假设一下棋盘格空余位置的数量是固定的，也就是假设循环次数是固定的，看看若不用回溯的话我们如何写，然后找出循环嵌套重复的代码，你就知道为什么回溯要这样写了。