N-Queens

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

 

分析
这是一个回溯算法，和二叉树遍历有点像。用一个stack来装当前探查的路径，基本框架还是：

初始化栈和当前探查的指针，以及方向变量while(栈不空)（或者指针有效吧之类的判断){if(往前){if(有子节点可用)去子节点(指针后移或者当前节点进栈);else方向变量反向}else{if(有兄弟节点可用){去兄弟节点;方向变量反向;}else回退(出栈或者指针前移);}}

这里看到有两个重要判断，一个是判断是否有子节点可用，一个是判断是否有兄弟节点可用。这两部分判断有时候是有重复的部分。
拿到这道题上说，子节点可用，需要判断的是比如已经放了3个queen，再放一个的话，要看子节点是否满足第4个queen和前三个不冲突；
兄弟节点可用，比如第一个queen放在了位置0，第二个queen放在了位置2，此时回退到queen2，那么就要看如果将这个queen放在位置3时是否与第一个queen冲突。
可以看最后那个代码，就是两个判断都有，但是两段代码非常接近。
其实这两个判断是重复的。

可以将之合并，办法就是：
比如这道题的话对于子节点的判断要优先一些（先剔除没必要进行的判断），就可以把这个强判断放到子节点部分执行；而兄弟节点判断部分只是简单的看是否越界。

 

public class Solution {
    ArrayList<String[]> result = null;
    public ArrayList<String[]> solveNQueens(int n) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        result = new ArrayList<String[]>();
        if(n < 1) return result;
        int[] s = new int[n];
        String[] out = new String[n];
        solveNQ(0, s, out);
        return result;
    }
    //0 valid
    //1 ocuppied
    //2 cannot put, column
    //3 cannot put, slop/left
    //4 cannot put, slop/right
    public void solveNQ(int r,int[] map, String[] s)
    {
        if(r == map.length)
        {
            result.add(s);
            return;
        }
        for(int i = 0; i < map.length; i ++)
        {
            if(map[i] == 1)
            {
                if(i > 0 && map[i - 1] == 0)
                {
                    map[i - 1] = 3;
                }
                if(i + 1 < map.length && map[i + 1] == 0)
                {
                    map[i + 1] = 4;
                }
                map[i] = 2;
            }
            if(map[i] == 3)
            {
                if(i > 0 && map[i - 1] == 0)
                {
                    map[i - 1] = 3;
                }
                map[i] = 0;
            }
            if(map[i] == 4)
            {
                if(i + 1 < map.length && map[i + 1] == 0)
                {
                    map[i + 1] = 4;
                }
                map[i] = 0;
            }
        }
        for(int i = 0; i < map.length; i ++)
        {
            if(map[i] == 0)
            {
                s[r] = generateRow(map.length, i + 1);
                solveNQ(r + 1, map, s);
            }
        }
    }
    public String generateRow(int n, int k){
        assert(k>0 && k<=n);
        StringBuilder res = new StringBuilder("");
        for(int i=0;i<k-1;i++){
            res.append(".");
        }
        res.append("Q");
        for(int i=k;i<n;i++){
            res.append(".");
        }
        return res.toString();
    }
}

没发现那里错了，但是跑不出来。

正解::

public class Solution {
    public ArrayList<String[]> solveNQueens(int n) {
        // Start typing your Java solution below
        // DO NOT write main() function
        assert(n>=0);
        ArrayList<String[]> res = new  ArrayList<String[]>();
        solveNQueues(1, new int[n], res);
        return res;
    }
    
    public void solveNQueues(int k, int[] solu, ArrayList<String[]> res){
        int n= solu.length;
        main:
        for(int i=0;i<n;i++){
            for(int j=0;j<k-1;j++)
                if(solu[j]==i || Math.abs(solu[j]-i)==Math.abs(j-k+1)) continue main;   
            solu[k-1]=i;
            if(k==n){
                String[] temp = new String[n];
                for(int l=0;l<n;l++){
                    temp[l]=generateRow(n,solu[l]+1);
                }
                res.add(temp);
            }else
                solveNQueues(k+1,solu,res);
        }
    }
    
    public String generateRow(int n, int k){
        assert(k>0 && k<=n);
        StringBuilder res = new StringBuilder("");
        for(int i=0;i<k-1;i++){
            res.append(".");
        }
        res.append("Q");
        for(int i=k;i<n;i++){
            res.append(".");
        }
        return res.toString();
    }
}

 把棋盘存储为一个N维数组a[N]，数组中第i个元素的值代表第i行的皇后位置，这样便可以把问题的空间规模压缩为一维O(N)，在判断是否冲突时也很简单，首先每行只有一个皇后，且在数组中只占据一个元素的位置，行冲突就不存在了，其次是列冲突，判断一下是否有a[i]与当前要放置皇后的列j相等即可。至于斜线冲突，通过观察可以发现所有在斜线上冲突的皇后的位置都有规律即它们所在的行列互减的绝对值相等，即| row – i | = | col – a[i] | 。这样某个位置是否可以放置皇后的问题已经解决。

 

我的解法：

注意 查对角线的方法是：

对于两个queen (x1, y1) 和 (x2, y2)， 如果 Math.abs(x1 - x2) == Math.abs(y1 - y2)， 则在同一条对角线上。

public class Solution {
    ArrayList<String[]> result = null;
    public ArrayList<String[]> solveNQueens(int n) {
        // Start typing your Java solution below
        // DO NOT write main() function
        result = new ArrayList<String[]>();
        solve(new int[n], 0);
        return result;
    }
    public int solve(int[] arr, int pos){
        int size = arr.length;
        if(pos == size) return generate(arr);
        for(int i = 0; i < size; i ++)
            if(isValid(arr, pos, i)){
                arr[pos] = i;
                solve(arr, pos + 1);    
            } 
        return -1;
    }
    public boolean isValid(int[] arr, int pos, int check){
        for(int i = 0; i < pos; i ++)
            if(check == arr[i] || Math.abs(pos - i) == Math.abs(check - arr[i])) return false;
        return true;
    }
    public int generate(int[] arr){
        String[] exp = new String[arr.length];
        for(int i = 0; i < arr.length; i ++){
            StringBuffer sb = new StringBuffer();
            for(int j = 0; j < arr.length; j ++){
                if(j == arr[i]) sb.append("Q");
                else sb.append(".");
            }
            exp[i] = sb.toString();
        }
        result.add(exp);
        return 1;
    }
}

 

 

---