回溯算法例题2

37. 解数独

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

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

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

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

示例：

输入：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"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

这题可以将每一个‘.’的位置用一个数组存起来，然后遍历这些位置，往里面尝试填写数字digit，每个数字填完之后，往下深搜，然后再回来讨论没填这个数字digit的情况，就跟我们解数独一样，典型的回溯问题（也可以当dfs理解）

以下是代码，将分段讲解。

第一部分：准备工作

我们填数独时，肯定要看同一行同一列同一个3x3方块里面有没有我们要填的数字，这题也是一样。

那么怎么判断有没有重复数字呢，不妨整一个二维数组row[行数][数字]，用true/false来表示某一行有没有某数字，列column[9][9]，和块block[3][3][9]同理。

即：

    bool row[9][9];//行
    bool column[9][9];//列
    bool block[3][3][9];//块

然后就是上面提到的，将每一个‘.’的位置用一个数组存起来，这个数组space的每一个元素就是位置，可以用数对（x，y）来表示。

即：

vector<pair<int,int>> space;

调用的时候，数据类型用auto即可。

auto [i,j]=space[pos];

然后怎么判断回溯终点呢，回溯到最后，数独填完了，没有“.”存在了，这就是回溯终点。也就是说回溯的层数=space的元素个数。

用pos表示回溯层数。

用valid表示最后的数独是否合法。

void backtrack(vector<vector<char>>& board,int pos){
        if(pos==space.size()){
            valid=true;
            return;
        }

第二部分：回溯

原理就是找到"."的位置，用符合条件的数去试，不断往下搜索，再回溯回来。

    void backtrack(vector<vector<char>>& board,int pos){
        if(pos==space.size()){
            valid=true;
            return;
        }
        auto [i,j]=space[pos];
        for(int digit=0;digit<9&&!valid;digit++){//遍历1-9的每个数，一开始先将valid置为false，当valid等于true时数独合法，停止遍历
            if(!row[i][digit]&&!column[j][digit]&&!block[i/3][j/3][digit]){//当没有重复数的时候，说明这个数可以填
                row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=true;//填完了那么同一行同一列同一个方块都有这个数了，将数组置1，方便下一个数的遍历
                board[i][j]=digit+'0'+1;//将数填入
                backtrack(board,pos+1);//考虑填完数的情况
                row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=false;//再置0，往下遍历，digit++，考虑不填这个数的情况
            }
        }
    }

配合注释应该很好理解。

第三部分：主函数

先将row，column，block置false，并把valid起始值设为false。

    void solveSudoku(vector<vector<char>>& board) {
        memset(row,false,sizeof(row));
        memset(column,false,sizeof(column));
        memset(block,false,sizeof(block));
        valid=false;

然后遍历初始数独表，遇到数，则将该数所在行、列、块置ture，遇到“.”，则将位置填入space数组。

        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                if(board[i][j]=='.'){
                    space.emplace_back(i,j);
                } 
                else{
                    int digit=board[i][j]-'0'-1;
                    row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=true;
                }  
            }
        }

最后用回溯法，完成数独。

backtrack(board,0);

完整代码：

class Solution {
public:
    bool row[9][9];
    bool column[9][9];
    bool block[3][3][9];
    bool valid;
    vector<pair<int,int>> space;

    void backtrack(vector<vector<char>>& board,int pos){
        if(pos==space.size()){
            valid=true;
            return;
        }
        auto [i,j]=space[pos];
        for(int digit=0;digit<9&&!valid;digit++){
            if(!row[i][digit]&&!column[j][digit]&&!block[i/3][j/3][digit]){
                row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=true;
                board[i][j]=digit+'0'+1;
                backtrack(board,pos+1);
                row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=false;
            }
        }
    }
    void solveSudoku(vector<vector<char>>& board) {
        memset(row,false,sizeof(row));
        memset(column,false,sizeof(column));
        memset(block,false,sizeof(block));
        valid=false;
        
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                if(board[i][j]=='.'){
                    space.emplace_back(i,j);
                } 
                else{
                    int digit=board[i][j]-'0'-1;
                    row[i][digit]=column[j][digit]=block[i/3][j/3][digit]=true;
                }  
            }
        }
        backtrack(board,0);
    }
};

这个方法还可以优化，详见官方题解，本文只是讨论回溯算法。