LeetCode: 37. 解数独(困难)

题目描述

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

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

• 数字 1-9 在每一行只能出现一次。
• 数字 1-9 在每一列只能出现一次。
• 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
  空白格用 . 表示。
  

提示：

• 给定的数独序列只包含数字 1-9 和字符 .。
• 你可以假设给定的数独只有唯一解。
• 给定数独永远是 9x9 形式的。

题解

以下内容来自37. 解数独:【回溯搜索算法】详解

回溯三部曲

1. 递归函数以及参数
   递归函数的返回值需要是bool类型，为什么呢？
   因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。

bool backtracking(vector<vector<char>>& board)

2. 递归终止条件
   本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。
   不用终止条件会不会死循环？
   递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！
   那么有没有永远填不满的情况呢？
   这个问题我在递归单层搜索逻辑里在来讲！
3. 递归单层搜索逻辑
   在树形图中可以看出我们需要的是一个二维的递归（也就是两个for循环嵌套着递归）
   一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

代码如下：（详细看注释）

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] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {
          // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
      
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';    // 回溯，撤销k,再进行循环,换不同的k进board
                }
            }
            return false;                           // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

注意这里return false的地方，这里放return false 是有讲究的。

因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！

那么会直接返回， 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！

• 判断棋盘是否合法

判断棋盘是否合法有如下三个维度：
同行是否重复
同列是否重复
9宫格里是否重复
代码如下：

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;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) {
      // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
     
            if (board[i][j] == val ) {
     
                return false;
            }
        }
    }
    return true;
}

整体代码如下:

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] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {
          // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
      
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';              // 回溯，撤销k,再进行循环,换不同的k进board
                }
            }
            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;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) {
      // 判断9方格里是否重复
        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);
    }
};

回溯算法复杂度如何分析呢?
复杂度分析

• 时间复杂度:
• 空间复杂度:

参考

37. 解数独:【回溯搜索算法】详解