一套模板，秒杀八皇后问题~

写在前面

本文为基于程序员carl所写题解的笔记，原网址

代码随想录

力扣原题链接

N 皇后

关于题目

在国际象棋中，“皇后”这一棋子可以在水平、竖直和两条斜线方向上移动任意格数，并吃掉在这些方向上的棋子。

而N皇后问题，就是指在NxN大小的棋盘上，要摆放N个皇后，而这些皇后互相不能吃到；而八皇后问题，就是指在经典的8x8棋盘上，如何摆放8个皇后。例如下图是4皇后问题的两种解法。

我们再来看看题目代码。题目要求的返回值是vector<vector<string>>,也就是说，每一种解法用一个vector<string>表示，再把这些答案用一个vector装起来。准备就绪，可以开始分析了。

这一题在不考虑耗时的情况下，可以用N重for循环暴力解决出结果。不过实际上，每一次for循环都会重新计算之前以及被否定的方案。还有一个问题，这样写能计算的皇后个数N就被写死了，我们希望能够根据输入的皇后数量来计算结果。因此，我们可以利用回溯法来实现剪枝操作。

先上回溯代码模板(来自程序员Carl)：

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

    for (遍历本层元素) {
        处理节点;
        backtracking(新参数); // 递归
        回溯，撤销处理结果
    }
}

例如力扣第77题 https://leetcode.cn/problems/combinations/ ，我们就可以这样做：

class Solution {
public:
    vector<vector<int>> res; //返回的结果
    vector<int> path; 		//每一次回溯的路径
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            res.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n; i++) {
            path.push_back(i); // 处理节点
            backtracking(n, k, i + 1); // 递归
            path.pop_back(); // 回溯，撤销处理结果
        }
    }

    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1);
        return res;
    }
};

具体到N皇后问题，我们先来看看，可以把判断棋盘布局是否符合要求放到第一段if里面吗？

答案是不行的，因为这样意味着，假设说我们是在四皇后问题，棋盘布局有64x63x62x61种可能性。如果n继续增长，需要处理的数据量增长会非常快。因此为了实现剪枝，我们在处理节点时就要判断在某一个点放置皇后里是否合法。

再来看看第二段for代码。在这里会进行两重遍历，一重是for，还有一重是backtracing里面的递归(不知道这里能不能叫遍历，总之是表达按顺序处理数据的意思)。我们可以用for来控制列遍历，用递归处理行遍历。那么代码将会是这样：

for(int i=0;i<col;i++){
	//处理节点
	backtracking(参数，row+1);
	//回溯，撤销节点处理
}

别忘了我们还需要判断结点处理是否合法。也就是代码得写成这样：

for(int i=0;i<col;i++) {
	if(isValid(处理了结点后的棋盘)) {
		//处理节点
		backtracking(处理节点后的棋盘，row+1);
		//回溯，撤销节点处理
	}
}

在这里，我们对结点的操作无非是把棋盘上某行某列的棋子设为皇后。所以：

for(int i=0;i<col;i++) {
	if(isValid(处理了结点后的棋盘)) {
		chessboard[row][col]='Q';
		backtracking(处理节点后的棋盘，row+1);
		chessboard[row][col]='.';
	}
}

既然我们不需要在结果里判断棋盘是否合法，那么if段代码就很好写了，只要判断递归调用backtracking时，传进来的row值，也就是已经确定的行数，是否等于棋盘行数，就把当前的结果塞进result里面。这里并不是塞进去就结束了，而是会在return后继续寻找其它可能性。最后backtracking函数整体如下。其中参数里的n指的是需要放置的皇后数量，或者说棋盘的行数列数:

void backtracking(vector<string>& chessboard, int row,int n ) {
    if (row == n) {
        result.push_back(chessboard);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(row, col, chessboard, n)) { 
            chessboard[row][col] = 'Q'; 
            backtracking(chessboard, row + 1, n);
            chessboard[row][col] = '.'; 
        }
    }
}

接下来就是判断是否合法的函数。这个函数不难：

bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { 
        if (chessboard[i][col] == 'Q') {
            return 0;
        }
    }
    // 检查 45度角
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return 0;
        }
    }
    // 检查 135度角
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return 0;
        }
    }
    return 1;
}

注意这里没有检查行的代码，因为在递归时只会选for循环里面的一个元素，也就是只在这一行里选，下一次递归就到下一行选了，所以在行里不会重复。这块可能有点绕，具体可以参考Carl的原文章。

最后是题目提供的接口：

vector<vector<string>> solveNQueens(int n) {
        
}

在这里，我们先要初始化一个没有放置元素的棋盘，然后将这个空棋盘用回溯函数处理，最后返回该棋盘。整体代码如下：

class Solution {
public:
    vector<vector<string>> result;

    bool isValid(int row, int col, vector<string>& chessboard, int n) {
        // 检查列
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') {
                return 0;
            }
        }
        // 检查 45度角
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return 0;
            }
        }
        // 检查 135度角
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return 0;
            }
        }
        return 1;
    }
    void backtracking(vector<string>& chessboard, int row, int n) {
        if (row == n) {
            result.push_back(chessboard);
            return;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(row, col, chessboard, n)) {
                chessboard[row][col] = 'Q';
                backtracking(chessboard, row + 1, n);
                chessboard[row][col] = '.';
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));
        backtracking(chessboard, 0, n);
        return result;
    }
};

相关洛谷题目链接:P1219 [USACO1.5] 八皇后 Checker Challenge

声明

本文为基于程序员carl所写题解的笔记，原网址

代码随想录