Leetcode:51.N皇后

代码的思路为传统的回溯法，代码思路与全排列以及求子集的思路基本相同，利用深度优先搜索（DFS）以及剪枝操作，N皇后问题的剪枝操纵为减去同对角线以及同列的枝。

首先列出我刚开始写出的代码，能够成功运行，但是忽略一个十分重要的地方，导致运行时间和空间复杂度大大提升。

class Solution {
public:
    
    vector> solveNQueens(int n) {
        vector> maps;
        vector map;
        return SortQueens(n, 0, map, maps);
    }
    
    bool ValidQueens(vector &map, int col, int row){
        int num = map.size();
        for(int i = 0; i < num; i++){
            if(map[i] == col)
                return false;
            else if((map[i] + i) == (col + row))
                return false;
            else if((map[i] - i) == (col - row))
                return false;
        }
        return true;
    }
    
     vector> SortQueens(int n, int row, vector &map, vector> &maps){ 
        int num = map.size(); 
        if(num == n){
            vector ans(num, string(num, '.'));
            for(int i = 0; i < num; i++)
                ans[i][map[i]] = 'Q';
            maps.push_back(ans); 
        }
        
        for(int col = 0; col < n; col++){     
            if(ValidQueens(map, col, row)){
                map.push_back(col);
                SortQueens(n, row + 1, map, maps);
                map.pop_back();
            }
        }  
        return maps;
    } 
};

比较重要的是ValidQueens这个函数，判断方法：

0，0（Q）	0，1	0，2	0，3
1，0	1，1	1，2（Q）	1，3
2，0	2，1	2，2	2，3
3，0	3，1	3，2	3，3

以上为四皇后的棋盘，（0,0）以及（1,2）已经放好一个皇后，接下来而皇后放在哪里该如何判断?列方向很容易判断，对角线方向向有个特点，同一对角线横纵坐标相加或者相减为同一个常数，以此为判断（好像我给的这个例子第三行无法放置皇后了，只能进行回溯操作）。

但是这个代码跑了1500ms，占用了500M内存，因为这里有个致命错误，引用！最终结果已经存在maps中，直接通过引用就可以将其返回，我居然给SortQueen返回值，又拷贝占用很多空间，这里直接void即可，引用就是为了方便解决void无法返回数值的问题，随即纠正。

​​​​class Solution {
public:
    
    vector> solveNQueens(int n) {
        vector> maps;
        //vector map(n, -1);
        vector map;
        SortQueens(n, 0, map, maps);
        return maps;
    }
    
    bool ValidQueens(vector &map, int col, int row){
        int num = map.size();
        for(int i = 0; i < num; i++){
            if(map[i] == col)
                return false;
            else if((map[i] + i) == (col + row))
                return false;
            else if((map[i] - i) == (col - row))
                return false;
        }
        return true;
    }
    
     void SortQueens(int n, int row, vector &map, vector> &maps){ 
        int num = map.size(); 
        if(num == n){
            vector ans(num, string(num, '.'));
            for(int i = 0; i < num; i++)
                ans[i][map[i]] = 'Q';
            maps.push_back(ans); 
        }
        
        for(int col = 0; col < n; col++){     
            if(ValidQueens(map, col, row)){
                map.push_back(col);
                SortQueens(n, row + 1, map, maps);
                map.pop_back();
            }
        }  
    } 
};

NICE！