LeetCode 37. 解数独

一、题目描述

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

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

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 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”]
]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

board.length == 9
board[i].length == 9
board[i][j] 是一位数字或者 ‘.’ 需要我们填的空 就是 “.”
题目数据 保证 输入数独仅有一个解

二、题目分析&解题思路

我们先看一下如何来逐个填入数字并判断数字是否合理

那我们先写出来判断数字在每一行、每一列、每一个九宫格里是否重复

bool isValid(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 j = 0; j < 9; j++) 
    { 
        if (board[j][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;
}

每一个数字如何判断的代码已经写好了，那么接下来如何去填数字，才能把所有的情况都试一遍呢？
那就是所有 需要填数字的位置都得遍历一遍，而且每一个位置都需要从 1~ 9 都试一遍
那么代码来了：

    for (int i = 0; i < board.size(); i++) // 遍历行
    {        
        for (int j = 0; j < board[0].size(); j++) // 遍历列
        { 
            if (board[i][j] == '.') //该位置为空，需要我们填数字
            {
                for (char k = '1'; k <= '9'; k++) //从 1 ~ 9 都逐个试
                {     
                    if (isValid(i, j, k, board)) // (i, j) 判断 k是否 可以放这个位置
                    {
                        board[i][j] = k;                // 放置k
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false 
            }                
        }
	}
	return true;

这样对吗？显然不对，这样只能得出来一组结果，无论成功与否都只看这一把了，属实离谱
例如这里，第一行第三列 除了填 1 还可以 填 2 、4

那么从该位置起 一共需要 循环 3 次，得到 3 个 9 × 9 结果(x 代表填入得数字，示例)

如果 其中每个 格子 1 - 9 都试过了都不行返回false,如果其中有一组适合则return true
而每一组得结果只需要一直递归下去即可，并且每个位置得每一个数字试完之后记得回溯，也就是试下一组数字

                    if (isValid(i, j, k, board)) 
                    {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) //递归试每个位置的每一个数字
                        {
                        	return true// 如果找到合适一组立刻返回
                        }; 
                        board[i][j] = '.';              // 回溯，撤销k，接下来试下一个数字
                    }

三、代码实现

class Solution {
private:
bool backtracking(vector<vector<char>>& board) 
{
    for (int i = 0; i < board.size(); i++) // 遍历行
    {        
        for (int j = 0; j < board[0].size(); j++) // 遍历列
        { 
            if (board[i][j] == '.') 
            {
                for (char k = '1'; k <= '9'; k++) 
                {     
                    if (isValid(i, j, k, board)) // (i, j) 这个位置放k是否合适
                    {
                        board[i][j] = k;  // 放置k
                        if (backtracking(board)) //递归填每种情况的接下来每一个数字
                        {
                            return true;// 如果找到合适一组立刻返回
                        } 
                        board[i][j] = '.';  // 回溯，撤销k，接下来试下一个数字
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false 
            }                
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(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 j = 0; j < 9; j++) 
    {
        if (board[j][col] == val) 
        {
            return false;
        }
    }
    // 判断9方格里是否重复
    int startRow = (row / 3) * 3;//计算每个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;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

运行结果：