补录代码随想录Day25打卡--回溯经典之N皇后问题

逝去的秋风

已于 2024-08-13 19:43:01 修改

阅读量972

点赞数 42

分类专栏：代码随想录打卡文章标签： leetcode 回溯 N皇后棋盘

于 2024-08-11 18:14:14 首次发布

本文链接：https://blog.csdn.net/2303_79786049/article/details/141108487

版权

代码随想录打卡专栏收录该内容

52 篇文章 0 订阅

订阅专栏

补卡

这里补一下昨天的回溯部分打卡--N皇后问题。

N皇后问题算是回溯在棋盘问题上最经典的应用了，其中需要在n x n的棋盘上放置n个皇后，使得她们互不攻击。（皇后能攻击同一行、同一列或同一对角线上的其他皇后）

题目一：51.N皇后

题目链接

51. N 皇后 - 力扣（LeetCode）

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

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

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

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

示例 1：
输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1
输出：[["Q"]]
提示：

1 <= n <= 9

题解：回溯

首先说明：棋盘：chessboard 行：row 列：col(column) 棋盘大小：n（即n x n棋盘）

三部分：主函数 -> 回溯函数 -> 判断当前位置合法性函数（按照这个顺序你能清晰地知道你下一步需要干嘛，我个人喜欢从下往上写）

Part1：主函数部分：

1.初始化棋盘：初始化一个大小为n的棋盘（题目要求n x n棋盘），初始化每个位置都为'.'

2.调用回溯函数：回溯遍历搜索整个棋盘放置皇后'Q'

3.返回结果：最后返回存放结果（合法棋盘）的数组

vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));       //初始化一个大小为n x n的棋盘，所有位置都是'.'
        backtrack(n, 0, chessboard);
        return ans;
    }

Part2：回溯函数部分（按照代码随想录回溯模板）：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

1.终止条件：成功在n行上（每一行）都放置了皇后

2.for循环部分横向遍历棋盘宽度：遍历当前行的每一列，通过判断当前位置是否合法（允许放置）进行放置皇后'Q'

3.递归部分纵向遍历棋盘高度：从下一行开始遍历每一行

4.回溯：撤销皇后

void backtrack(int n, int row, vector<string>& chessboard) {        //回溯：尝试在棋盘的每一行上放皇后
        if (row == n) {             //如果已经成功在n行上都放置了皇后，说明找到了一个有效布局（棋盘）
            ans.push_back(chessboard);
            return;
        }
        for (int col = 0; col < n; col++) {         //遍历当前行的每一列
            if (isValid(row, col, chessboard, n)) {             //检查在(row, col)位置放置皇后是否合法
                chessboard[row][col] = 'Q';         //合法就在该位置放置皇后'Q'（注意：这里在当前行放置了一个皇后'Q'后就进行递归来到下一行）
                backtrack(n, row + 1, chessboard);          //递归：纵向遍历--从下一行开始
                chessboard[row][col] = '.';     //回溯，撤销皇后
            }
        }
    }

Part3：判断当前位置合法性函数

下面操作都以当前位置（row,col）进行

1.判断列：在同列不同行之下进行判断这一列是否已经有皇后了（一个for循环即可）

2.判断左上方：for循环从当前位置开始，每次都上移一格，左移一格即可（注意边界）

3.判断右上方：for循环从当前位置开始，每次都上移一格，右移一格即可（注意边界）

这里为什么不考虑行以及下方的情况呢？

很简单，我们在回溯函数那里在某一行成功放置了皇后Q之后，进行递归函数直接从下一行开始，这样就保证了每一行只有一个皇后；然后我们当前位置的下方，现在根本都还没有遍历到，所以没必要考虑。

bool isValid(int row, int col, vector<string>& chessboard, int n) {    //检查在(row, col)位置放置皇后是否合法
        for (int i = 0; i < row; i++) {                 //检查列（列不变行变）：如果当前列已经有皇后'Q'了，说明该处不能再放置
            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;
    }

好了，这就是所有的思路和讲解，具体的含义可以看如下代码（含注释）：

class Solution {
public:
    vector<vector<string>> ans;
    bool isValid(int row, int col, vector<string>& chessboard, int n) {    //检查在(row, col)位置放置皇后是否合法
        for (int i = 0; i < row; i++) {                 //检查列（列不变行变）：如果当前列已经有皇后'Q'了，说明该处不能再放置
            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;
    }
    void backtrack(int n, int row, vector<string>& chessboard) {        //回溯：尝试在棋盘的每一行上放皇后
        if (row == n) {             //如果已经成功在n行上都放置了皇后，说明找到了一个有效布局（棋盘）
            ans.push_back(chessboard);
            return;
        }
        for (int col = 0; col < n; col++) {         //遍历当前行的每一列
            if (isValid(row, col, chessboard, n)) {             //检查在(row, col)位置放置皇后是否合法
                chessboard[row][col] = 'Q';         //合法就在该位置放置皇后'Q'（注意：这里在当前行放置了一个皇后'Q'后就进行递归来到下一行）
                backtrack(n, row + 1, chessboard);          //递归：纵向遍历--从下一行开始
                chessboard[row][col] = '.';     //回溯，撤销皇后
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));       //初始化一个大小为n x n的棋盘，所有位置都是'.'
        backtrack(n, 0, chessboard);
        return ans;
    }
};

题目二：52.N皇后 II

题目链接

52. N 皇后 II - 力扣（LeetCode）

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

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

示例 1：
输入：n = 4
输出：2
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1
输出：1
提示：

1 <= n <= 9

题解：回溯

有了上边的基础，这道题就很简单了，思路代码几乎一样。

class Solution {
public:
    int ans = 0;    //唯一的不同，这里用来记录方案数
    bool isValid(int n, int row, int col, vector<string>& chessboard) {
        for (int i =0; i < n; 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;
    }
    void backtrack(int n, int row, vector<string>& chessboard) {
        if (row == n) {
            ans++;
            return;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(n, row, col, chessboard)) {
                chessboard[row][col] = 'Q';
                backtrack(n, row + 1, chessboard);
                chessboard[row][col] = '.';
            }
        }
    }
    int totalNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));       //全部初始化为什么都行，本题不做要求
        backtrack(n, 0, chessboard);
        return ans;
    }
};