leetcode-51. N 皇后

深度优先搜索(dfs)

回溯算法

---

题目详情

n 皇后问题 研究的是如何将 n 个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中'Q' 和 '.'分别代表了皇后和空位。

---

示例1：

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

示例2:

输入：n = 1
输出：[["Q"]]

这道题其实就是逐行遍历,每一行的每一个位置尝试放置,如果此列(上下),左上角,右上角没有Q,则满足条件

易理解代码：

copy自代码随想录

class Solution {
private:
vector<vector<string>> result;
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
    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(n, row + 1, chessboard);
            chessboard[row][col] = '.'; // 回溯，撤销皇后
        }
    }
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    int count = 0;
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

另一种更简洁代码:

//这里起初我没理解的是为什么bool型vector ldiag和rdiag能验证对角线
//看了上面的文字解释就知道了,主对角线上的每一个点的行号-列号值是固定的(验证左上角)
//副对角线上每一个点的行号+列号是固定的(验证右上角)
//但是为什么是n-row+i-1,因为row-i可能为负数,vector下标不能为负数,所以要转正
//即为n-1-(row-i) == n-row+i-1,也是固定的
class Solution 
{
public:
    void backtracking(vector<vector<string>> &ans, vector <string> &board, vector<bool> &column, vector<bool> &ldiag, vector<bool> &rdiag, int row, int n)
    {
        if(row == n)                //摆完了,即一组满足条件的解
        {
            ans.push_back(board);
            return;
        }
        for(int i = 0;i < n; ++i)   //
     {      //纵列         左上角             右上角
         if(column[i] || ldiag[n-row+i-1] || rdiag[row+i])  //有一个不满足则不能摆放在这里
         continue;
     

     board[row][i] = 'Q';                           //摆上
     column[i] = ldiag[n-row+i-1] = rdiag[row+i] = true;         //这个点的三元素(纵列,左右上角)置true

     backtracking(ans, board, column, ldiag, rdiag, row+1, n);  //继续dfs下一行

    board [row][i] = '.';                                       //回溯,将Q挪走
    column[i] = ldiag[n-row+i-1] = rdiag[row+i] = false;        //三元素移除
     }
    }
    vector<vector<string>> solveNQueens(int n) 
    {
        vector<vector<string>> ans;
        if (n == 0)
        return ans;
        vector<string> board(n, string(n,'.'));
        vector<bool> column(n, false), ldiag(2*n-1, false), rdiag(2*n-1, false);  //这里构造大小 因为row+i最大值是2n-1(row:0->n i:0->n-1)
        backtracking(ans, board, column, ldiag, rdiag, 0, n);   //注意这里为什么从0开始,因为如果从1开始,一皇后就直接push'.'了(可以试一下)
        return ans;
    }
};

难想!但是效率高多了

涉及知识点:

1.深度优先搜索(dfs)

深度优先搜索（depth-first seach，DFS）在搜索到一个新的节点时，立即对该新节点进行遍历；因此遍历需要用先入后出的栈来实现，也可以通过与栈等价的递归来实现。对于树结构而言，由于总是对新节点调用遍历，因此看起来是向着“深”的方向前进。

2.回溯法

回溯法（backtracking）是优先搜索的一种特殊情况，又称为试探法，常用于需要记录节点状
态的深度优先搜索。通常来说，排列、组合、选择类问题使用回溯法比较方便。
顾名思义，回溯法的核心是回溯。在搜索到某一节点的时候，如果我们发现目前的节点（及
其子节点）并不是需求目标时，我们回退到原来的节点继续搜索，并且把在目前节点修改的状态
还原。这样的好处是我们可以始终只对图的总状态进行修改，而非每次遍历时新建一个图来储存
状态。在具体的写法上，它与普通的深度优先搜索一样，都有 [修改当前节点状态]→[递归子节
点] 的步骤，只是多了回溯的步骤，变成了 [修改当前节点状态]→[递归子节点]→[回改当前节点
状态]。