51 N皇后（c++，回溯） 52 N皇后

问题

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

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

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

示例 1：

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

输入：n = 1
输出：[[“Q”]]

class Solution {
public:
    vector<vector<string>> result;//存储所有的排列结果
    vector<string> path;//存储当前递归中的一个排列
    vector<int> p;//存储当前递归中皇后在该行中的列数，即Q的下标

    void backtracking(int n, vector<bool>& used, int index){
        if(path.size() == n){//递归边界，此时已经找到一种全排列方式
            result.push_back(path);//将path加入到result中并返回
            return;
        }
        for(int i = 0; i<n ; i++){//在第index行，逐个枚举每一列
            if(used[i] == false){//如果第i列还没有皇后
                bool flag = true;//flag为true表示当前的皇后不会和以前的皇后冲突
                for(int pre = 0; pre<index;pre++){//遍历以前的皇后
                //index表示当前皇后的行，pre表示以前皇后的行
                //i表示当前皇后的列，p[pre]表示以前皇后的列
                    if(abs(index - pre) == abs(i - p[pre])){//如果两个皇后的行数之差等于列数之差，即它们在一个对角线上
                        flag = false;//此时表示两个皇后冲突，不能将皇后放在i列
                        break;
                    }
                }
                if(flag){//如果可以把皇后放在i列
                	//实现题目中要求的奇葩输出
                    string s(n,'.');//创建一个string类型的变量，存储每一行
                    s[i] = 'Q';//将该行中的i列值改为Q，即皇后的位置
                    path.push_back(s);//将该行加入到排列中
                    p.push_back(i);//存储该行中皇后的列数，在判断是否在对角线上时使用
                    used[i] = true;//表示该列已经有皇后了
                    backtracking(n,used, index+1 );//递归处理index+1行的皇后
                    path.pop_back();
                    p.pop_back();
                    used[i] = false;//递归完毕，还原i列未被占用
                }
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        path.clear();
        vector<bool> used(n,false);//存储当前排列中该列是否已经被放置皇后，初始化全部为未放置皇后
        backtracking(n, used,0);//从0行开始找起
        return result;//返回存储所有皇后全排列的向量
    }
};

• N皇后问题
  • 在n*n的棋盘上放置皇后，使得这n个皇后两两不在同一行、同一列、同一条对角线上，求合法方案
  • 将其转化为全排列问题解决
• 思路
  • 每行只能放一个皇后，每列也只能放一个皇后，如果把n列皇后所在的行号依次写出，就是一个1~n的全排列。
  • 枚举1~n的全排列，通过检查是否满足对角线只有一个皇后，查看每个排列是否合法。
  • 优化：当已经放置一部分皇后时，可能剩余的皇后无论怎样放置都不可能合法，此时直接返回，不必继续递归。
• 代码解析
  • 定义一个二维向量result存储皇后的所有排列方式。定义一个向量path存储当前排列，每完成一次全排列就将path加入到result中。为了判断两个皇后是否冲突，即行之差与列之差是否相等，定义一个向量p存储当前排列中Q所处的列数，与path中每一行Q的下标一一对应。定义一个向量used存储当前列是否已经放置了皇后。
  • 将used全部初始化为false，调用回溯函数，传入index为0，表示从第一行开始填皇后。
  • for循环实现对该行遍历每一列，如果i列还没有皇后，即used[i]为false，将flag设置为true，表示该列可以放置皇后。
  • 遍历之前的皇后，判断该列放置皇后是否与之前的皇后发生冲突，如果冲突则将flag设置为false。
  • 循环结束后如果flag依然为true，表示当前列可以放置皇后。创建一个string类型的变量s实现题目要求的输出，同时将i的值加入到p向量中，将s加入到path向量中，将used[i]标记为true表示i列已经放置了皇后。
  • 递归调用填下一行的皇后，传入index+1.
  • 递归完毕还原i列未被占用，即还原path、p、used[i]
  • 递归边界为path的长度等于n，此时已经有了一种全棋盘的排列方式，将path加入到resu中，返回。

N皇后II

• 题目：同51，求排列方法数

class Solution {
public:
    int totalNQueens(int n) {
        vector<int> used(n, false);
        dfs(used, n, 0);
        return count;
    }
private:
    int count=0;//记录排列方法数
    vector<int> p;//记录上一个排列的行号所对应的列号
    //index表示行号，对每一行枚举它的每一列
    void dfs(vector<int>& used, int n, int index){
        if(index==n){//如果行号为n，表示已经找到了一种排列方法
            ++count;
            return;
        }
        //枚举每一列
        for(int i=0; i<n; ++i){
            if(used[i]==false){//如果该数字还没有被使用
                bool flag=true;//判断对角线上是否有皇后
                //pre是此前已经确定的行号，p[pre]是它对应的列号
                for(int pre=0; pre<index; ++pre){
                    if(abs(index-pre)==abs(i-p[pre])){
                        flag=false;
                        break;
                    }
                }
                if(flag){//flag为false表示对角线上冲突，不能放皇后
                    p.push_back(i);//记录当前的行列号i
                    used[i]=true;//将该数字标记为used
                    dfs(used,n,index+1);//递归查找下一个数字
                    used[i]=false;//恢复原状
                    p.pop_back();
                }
            }
        }
    }
};