LeetCode第51题解析

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

上图为 8 皇后问题的一种解法。

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

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

示例:

输入: 4
输出: [
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。

提示：

皇后，是国际象棋中的棋子，意味着国王的妻子。皇后只做一件事，那就是“吃子”。当她遇见可以吃的棋子时，就迅速冲上去吃掉棋子。当然，她横、竖、斜都可走一到七步，可进可退。（引用自 百度百科 - 皇后 ）

解题思路：

回溯算法其实是搜索一个决策树，每次搜索完一层重置状态到搜索之前，以做出别的选择，这样就可以不重不漏。
所以解题思路第一步是分析如何做决策。
因为要在NxN的棋盘上摆N个皇后，且皇后不能在同一行，所以我们可以一行一行的放置皇后，每行放一个。（当然一列一列放也可以）
而在一行中放置皇后时，需要遍历该行的每一列的位置，看该位置是否可以放置皇后，这就需要根据当前棋盘的状态进行判断。
最后如果我们搜索到最后一行的下一行，说明所有的行都找到了合适的位置，则此时的棋盘状态就是N皇后的一个解。
当然N皇后可以是无解的（比如N=3时），这种情况在没有搜索到最后一行之前就会退出。

OK，看一下具体的步骤：

1、需要定义一个全局的棋盘状态，因为题目要求返回vector<vector<string>>,所以定义棋盘状态为：
vector<string> board(n, string(n, '.'));
即所有的位置初始化为不放置皇后。

2、定义回溯函数（即深度优先搜索的递归函数）
void backtrack(vector<string>& board, int row, vector<vector<string>>& res)
首先我们需要传入棋盘状态 board, 我们需要不断的修改这个状态，也需要用这个状态来判断某位置是否可以放置皇后
然后，因为我们是一行一行搜索的，所以需要有参数row表示当前是哪一行。
最后，我们传入最终返回的结果集合的引用 vector<vector<string>>& res

3、成功退出条件

    if(row==board.size()){
        res.emplace_back(board);
        return;
    }

我们一行一行搜索，每搜索成功一行，将row+1并再次递归调用 backtrack 函数，因此当最后一行搜索成功后，row就等于N (row从0开始)，只要判断 row==board.size()即可只此时的棋盘状态已经成功放置了N个皇后。由于本题c++中返回的是vector<vector<string>>,其中保存的不是棋盘状态的引用（java),所以直接使用 res.emplace_back(board）即可，不需要像java那样拷贝一个新的对象。

4、核心搜索过程（剪枝+回溯）

for(int col=0; col<n; ++col){
    if(!isValid(board, row, col)){
        continue;
    }

    board[row][col] = 'Q';
    backtrack(board, row+1, res);
    board[row][col] = '.';
}

backtrack函数中我们针对当前row的每一列进行选择，首先要根据N皇后的规则进行剪枝，如果满足条件则棋盘当前位置(row,col)被放置上一个皇后，然后我们继续搜索下一层：backtrack(board, row+1, res); 这会在当前的状态下一直递归下去，直到成功或失败退出。无论是否成功，从此处的下一层调用返回本层后，我们撤销当前位置放置的皇后（回溯），然后选择下一列进行检测，如果位置有效，则继续向下一层搜索。
关于isValid:
判断当前位置(row,col)是否有效，只需要在当前状态的基础上检查即可。因为是row从0开始向下搜索的，所以只需向上检查[0~row-1]的行中是否有和当前位置冲突的皇后。

注意：这个检测只需要检测皇后所在行的上半部分就行了。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> res = { };
        //边界条件
        if(n <= 0) return res;
        //保存路径,并进行初始化,匿名对象
        vector<string> track(n, string(n,'.'));
        backtrack(0, track, res);
        return res;
    }
    //回溯法
    void backtrack(int row, vector<string>& track, vector<vector<string>>& res) {
        //terminator
        if(row == track.size()) {
            res.push_back(track);
            return;
        }
        for(int col = 0; col < track.size(); ++col) {
            //判断当前位置是否合理
            if(!isValid(track, row, col)) continue;
            //process
            track[row][col] = 'Q';
            //drill dowm
            backtrack(row+1, track, res);
            //reverse state
            track[row][col] = '.';
        }
    }
    //判断当前位置是否合理
    bool isValid(vector<string>& track, int row, int col) {
        //检测列
        for(int i = 0; i < row; ++i) {
            if(track[i][col] == 'Q') return false;
        }
        //检测右上
        for(int i = row-1, j = col+1; i >= 0 && j < track.size(); --i, ++j) {
            if(track[i][j] == 'Q') return false;
        }
        //检测左上
        for(int i = row-1, j = col-1; i >= 0 && j >= 0; --i, --j) {
            if(track[i][j] == 'Q') return false;
        }
        return true;
    }
};