《代码随想录》Ⅶ 回溯算法-棋盘 37. 解数独-优快云博客

《代码随想录》Ⅶ 回溯算法-棋盘 37. 解数独

‍

努力学习！

题目：力扣链接

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

数独的解法需 遵循如下规则：
1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。

一、思想

这道题的核心思想是使用回溯算法。回溯算法是一种通过递归来枚举所有可能的解，并在每一步尝试中剪枝（即排除无效解）的算法。在数独问题中，我们需要在每一个空格中尝试填入数字1-9，并检查是否符合数独的规则。如果符合，则继续递归地填充下一个空格；如果不符合，则回溯到上一步，尝试下一个数字。

二、代码

class Solution
{
public:
    // 判断在指定位置填入数字是否有效
    bool isValiad(vector<vector<char>> &board, int row, int col, char num)
    {
        // 检查行是否有效
        for (int i = 0; i < 9; ++i)
            if (num == board[row][i])
                return false;

        // 检查列是否有效
        for (int i = 0; i < 9; ++i)
            if (num == board[i][col])
                return false;

        // 检查3x3宫格是否有效
        int startRow = row - row % 3; // 计算所在宫格的起始行
        int startCol = col - col % 3; // 计算所在宫格的起始列
        for (int i = startRow; i < startRow + 3; ++i) {
            for (int j = startCol; j < startCol + 3; ++j) {
                if (num == board[i][j]) {
                    return false;
                }
            }
        }
        return true; // 所有检查通过，返回true
    }
    // 回溯算法核心函数
    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] == '.') {
                    // 尝试填入数字1-9
                    for (char k = '1'; k <= '9'; ++k) {
                        // 如果当前数字有效
                        if (isValiad(board, i, j, k)) {
                            board[i][j] = k; // 填入数字
                            
                            // 递归尝试解决剩余棋盘
                            if (backtracking(board)) {
                                return true; // 如果找到解，返回true
                            }

                            board[i][j] = '.'; // 回溯，撤销当前选择
                        }
                    }
                    return false; // 如果1-9都尝试过都不行，返回false
                }
            }
        }
        return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
    }
    void solveSudoku(vector<vector<char>> &board) { backtracking(board); }
};

三、代码解析

1. 算法工作原理分解

1.1 回溯函数 `backtracking`

目的：递归地尝试在每一个空格中填入数字，并通过剪枝操作避免生成无效的解。
实现：
- 遍历棋盘：遍历整个数独棋盘，找到空位（用'.'表示）。
- 尝试填入数字：在空位中尝试填入数字1-9。
- 有效性检查：通过isValiad函数检查当前填入的数字是否符合数独规则。
- 递归与回溯：
  - 如果填入的数字有效，则递归地尝试填充下一个空格。
  - 如果递归返回true，说明找到了解，直接返回true。
  - 如果递归返回false，则回溯，撤销当前选择，尝试下一个数字。
- 终止条件：如果所有空格都填充完毕且没有返回false，则返回true，表示找到了解。

1.2 解决数独函数 `solveSudoku`

目的：调用回溯函数，解决数独问题。
实现：
- 调用回溯函数：从棋盘的第一个空格开始调用backtracking函数，尝试填充整个棋盘。

2. 关键点说明

2.1 路径的选择与回溯

路径：board变量用于存储当前数独棋盘的布局。
选择：每次选择一个空位，并尝试填入数字1-9。
回溯：在递归调用返回后，撤销当前选择的数字，以便尝试其他可能的数字。

2.2 有效性检查

有效性检查：通过isValiad函数检查当前填入的数字是否满足数独的规则，即在同一行、同一列和同一个3x3宫格内是否没有重复的数字。

四、复杂度分析

时间复杂度：O(9^m)
- 其中m是数独棋盘中的空位数。在最坏情况下，我们需要尝试每一个空位的所有可能数字（1-9），因此时间复杂度为O(9^m)。
空间复杂度：O(m)
- 递归调用栈的深度最多为m，因此空间复杂度为O(m)。
- 结果集board的空间复杂度为O(9*9)，但在通常情况下，我们只考虑递归栈的空间复杂度。