第51题 N皇后

题目描述：

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

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

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

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

Level	AC rate
Hard	74.1%

---

题目解析：

规则其实非常简单，debug de了很久，题目的意思就是说给你一个n*n大小的棋盘，你往里面放置n个棋子，棋子两两之间不共行不共列不共45度角平分线，首先我们看到题目肯定想到用递归来解，我们使用一个record数组来记录第i行放置的棋子位置j，即record[i] = j，然后通过递归得到结果输出即可，代码如下：

class Solution {
    List<List<String>> ans;
    public List<List<String>> solveNQueens(int n) {
        int[] record = new int[n];
        ans = new ArrayList<>();
        process(0,n,record);
        return ans;
    }

    void process(int col , int n , int[] record){
        if(col>=n){
            List<String> temp = new ArrayList<String>();
            for(int i = 0 ; i<n ; i++){
                String str="";
                for(int j = 0 ; j<n ; j++){
                    if(record[i]==j)str+="Q";
                    else str+=".";
                }
                temp.add(str);
            }
            ans.add(temp);
            return;
        }
        for(int i = 0 ; i<n ; i++){
            if(isValid(col,i,record)){
                record[col] = i;
                process(col+1,n,record);
            }
            else continue;
        }
    }

    boolean isValid(int col , int idx , int[] record){
        for(int i = 0 ; i<col ; i++){
            if(record[i]==idx||Math.abs(record[i]-idx)==Math.abs(col-i))return false;
        }
        return true;
    }
}

执行用时：4 ms, 在所有 Java 提交中击败了38.92%的用户

内存消耗：42.4 MB, 在所有 Java 提交中击败了8.79%的用户

这种题目在时间复杂度等级上没有更好的优化方法，但如果使用位运算的话会在时间复杂度的常数级别进行一定的优化，大概差不多是25倍左右，怎么弄呢，假如所给的n=4，设定限制为1<<4-1，这样可以判断递归什么时候结束，还是使用了一个record数组来记录，但是在放置有效性的方面进行了优化，我们在给的限制中去除掉不能放置的位后，将其与补码与可以得到能够放置的最右一位，然后while循环进行遍历即可，代码如下：

// 位运算
class Solution {
    List<List<String>> ans;
    int limit;
    int n;
    public List<List<String>> solveNQueens(int num) {
        n = num;
        limit = (1<<n)-1;
        int[] record = new int[n];
        ans = new ArrayList<>();
        process(record,0,0,0,0);
        return ans;
    }

    void process(int[] record , int colim , int leftlim , int rightlim , int level){
        if(colim==limit){
            List<String> temp = new ArrayList<String>();
            for(int i = 0 ; i<n ; i++){
                String str="";
                for(int j = 0 ; j<n ; j++){
                    if(record[i]==j)str+="Q";
                    else str+=".";
                }
                temp.add(str);
            }
            ans.add(temp);
        }
        int pos = 0;
        int mostright = 0;
        pos = limit&(~(colim|leftlim|rightlim));
        while(pos!=0){
            mostright = pos&(~pos+1);
            pos = pos-mostright;
            record[level] = cal(mostright);
            process(record,colim|mostright,(leftlim|mostright)<<1,(rightlim|mostright)>>1,level+1);
        }
    }

    int cal(int num){
        int ans = 0;
        while(num>1){
            num/=2;
            ans++;
        }
        return ans;
    }
}

执行用时：2 ms, 在所有 Java 提交中击败了92.92%的用户

内存消耗：42.2 MB, 在所有 Java 提交中击败了14.30%的用户