leetcode：深度优先搜索(DFS)和广度优先搜索(BFS)

DFS的解答步骤

1. 定义全局的存放所有解的对象和存放1个解的对象；
2. 在递归函数中，确定递归终止条件，并在终止时提交一个完整的解；
3. 递归函数中的代码结构应该是：执行动作、调用递归、撤销动作。

51. N皇后问题

在一个N*N的棋盘上放置N个皇后，每行一个并使其不能互相攻击（同一行、同一列、同一斜线上的皇后都会自动攻击）。

思路：
采用递归不断处理子问题。
每次在棋盘上的当前行放置1个皇后，就需要在该行枚举所有情况，当不与前面行的皇后冲突时，就可以递归处理剩下位置。
当到达最后一行的时候，保存结果，递归结束。

关键问题是如何检测在某行某列放置皇后的时候是否造成冲突。

其实，由于每1行只允许放置1个皇后，因此可以采用1个长度为n的整形数组记录每行放置皇后的列位置，这样空间复杂度就降低为O(n)了。然后，在检查当前位置的皇后是否与之前的皇后冲突时，就需要遍历之前的皇后，以检测是否冲突。
由于按行递归，已经限制了皇后都不在同一行，因此只需检测列值是否相同，以及行列差的绝对值是否相同（判断是否在同一斜线）。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        if(n<=0) return res;
        colSite.resize(n,-1);
        dfs(0,n);
        return res;
    }
private:
    vector<vector<string>> res;//存放所有的答案
    vector<int> colSite;//存放每行的皇后所在的列位置信息

    void dfs(int c,const int N) 
    {
        if(c == N)
        {//如果放置完N个皇后,就完成了一个解，保存该结果到res
            vector<string> frame(N,string(N,'.'));
            for(int row=0;row<N;row++)
                frame[row][colSite[row]] = 'Q';
            res.push_back(frame);
            return;
        }
        
        bool valid=true;
        for(int col=0;col<N;col++) 
        {
            valid=true;
            //判断将第c行上的Q放在第col列上是否合法？
            for(int row=0;row<c;row++) 
            {
                //对于之前已经确定的c-1行上的皇后，如果和当前的col同一列，或者在对角线（行-行 == 列-列）上，则不合法
                if(colSite[row]==col || abs(c-row)==abs(col-colSite[row])) 
                {
                    valid=false;
                    break;
                }
            }
            if(valid) 
            {
                //如果将第c行上的Q放在第col列上是合法的，就执行-递归-撤销
                colSite[c]=col;
                dfs(c+1,N);
                colSite[c]=-1;
            }
        }
    }
};

78. 子集

已知一个数集，求它的所有子集。
例如：nums = [1,2,3],它的所有子集是：

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

思路：
同样是很常规的DFS，唯一需要注意的就是，每个解的元素都应该是递增的。

---

PS：这道题还可以使用位运算。例如[1,2,3]，定义每个元素有个标志位，全集为1 1 1，全集表示都取，它的子集有1 0 1 、 1 1 0 、 1 0 0等等，我们通过枚举子集，然后再通过子集获取原来数组的元素即可。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> r;
    vector<int> book;
 
    vector&l