代码随想录算法训练营第30天| 51. N皇后、37. 解数独

51. N皇后

题目链接：N皇后

题目描述：按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 **n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

解题思想：

首先来看一下皇后们的约束条件：

1. 不能同行
2. 不能同列
3. 不能同斜线

确定完约束条件，来看看究竟要怎么去搜索皇后们的位置，其实搜索皇后的位置，可以抽象为一棵树。

下面我用一个 3 * 3 的棋盘，将搜索过程抽象为一棵树，如图：

那么我们用皇后们的约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        string s(n, '.');
        vector<string> chessboard(n, s);
        backtracking(chessboard, n, 0);
        return result;
    }

private:
    vector<vector<string>> result;
    void backtracking(vector<string>& chessboard, int n, int row) {
        if (row >= n) {
            result.push_back(chessboard);
            return;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(chessboard, n, row, col)) {
                chessboard[row][col] = 'Q';
            } else
                continue;
            backtracking(chessboard, n, row + 1);
            chessboard[row][col] = '.';
        }
    }
    bool isValid(vector<string>& chessboard, int n, int row, int col) {
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
};

37. 解数独

题目链接：全排列 II

题目描述：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

解题思想：

**N皇后问题**是因为每一行每一列只放一个皇后，只需要一层for循环遍历一行，递归来遍历列，然后一行一列确定皇后的唯一位置。

本题就不一样了，本题中棋盘的每一个位置都要放一个数字（而N皇后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深。

回溯三部曲

• 递归函数以及参数
  递归函数的返回值需要是bool类型，为什么呢？
  因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。
• 递归终止条件
  本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。
• 递归单层搜索逻辑
  **一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！**因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！那么会直接返回， 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！

判断棋盘是否合法

• 同行是否重复
• 同列是否重复
• 9宫格里是否重复

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) { backtracking(board); }

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(board, i, j, k)) {
                            board[i][j] = k;
                            bool result = backtracking(board);
                            if (result)
                                return true;
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }
    bool isValid(const vector<vector<char>>& board, int row, int col,
                 char num) {
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == num)
                return false;
            if (board[i][col] == num)
                return false;
        }
        int row_id = row / 3;
        int col_id = col / 3;
        for (int i = 3 * row_id; i < 3 * (row_id + 1); i++) {
            for (int j = 3 * col_id; j < 3 * (col_id + 1); j++) {
                if (board[i][j] == num)
                    return false;
            }
        }
        return true;
    }
};