51. N 皇后（java实现）--LeetCode

题目：

解法1：递归（对角线规律）

/**
 * 思路：
 * 从上往下
 * 核心思路：确定一个皇后的位置，列上，对角线上不能有其他皇后。右侧的对角线上的数，row-col的相同的。左侧对角线上的数，row+col相同。
 * 0,0  0,1 0,2 0,3
 * 1,0  1,1 1,2 1,3
 * 2,0  2,1 2,2 2,3
 * 主对角线（左）row+col相同。从对角线（右）row-col相同
 * 从对角线（右） 0,0 1,1 2,2
 * 主对角线（左） 0,2 1,1 2,0
 * 用栈存放符合要求的皇后的位置
 */
     public List<List<String>> solveNQueens(int n) {
        ArrayList<List<String>> result = new ArrayList<>();
        int[] arr=new int[n];
        HashSet<Integer> col_set = new HashSet<>();
        HashSet<Integer> master_set = new HashSet<>();
        HashSet<Integer> slave_set = new HashSet<>();
        recursive(col_set,slave_set,master_set,result,arr,n,0);
        return result;
    }

    private void recursive(HashSet<Integer> col_set, HashSet<Integer> slave_set, HashSet<Integer> master_set, ArrayList<List<String>> result, int[] arr, int n, int row) {

        if (row==n){
            ArrayList<String> list = new ArrayList<>();
            buildList(list,arr);
            result.add(list);
            return;
        }

        for (int col=0;col<n;col++){
            if (!col_set.contains(col)&&!master_set.contains(row+col)&&!slave_set.contains(row-col)){
                master_set.add(row+col);
                slave_set.add(row-col);
                col_set.add(col);
                arr[row]=col;
                recursive(col_set, slave_set, master_set, result, arr, n, row+1);
                master_set.remove(row+col);
                slave_set.remove(row-col);
                col_set.remove(col);
            }
        }
    }

    private void buildList(ArrayList<String> list, int[] arr) {
        for (int q:arr) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                if (q==i)
                    sb.append("Q");
                else
                    sb.append(".");
            }
            list.add(sb.toString());
        }
    }

时间复杂度：On^2

空间复杂度：On

解法2：递归（遍历每层）

    /**
     * 思路：
     * 核心思路：确定当前Queen的位置，遍历之前所有Queen，不能是 之前Queen的位置+-（当前层-之前的层）
     * 用数组来存储数据，索引就是当前层，值就是Queen的位置
     * 递归的放Queen的位置，达到了数组的长度，就构建结果集
     */
    public List<List<String>> solveNQueens(int n) {
        ArrayList<List<String>> result = new ArrayList<>();
        int[] arr = new int[n];
        recursive2(result,arr,0);
        return result;
    }

    private void recursive2(ArrayList<List<String>> result, int[] arr, int level) {
        if (level==arr.length){
            greateResult(arr,result);
            return;
        }
        HashSet<Integer> set = new HashSet<>();
        for (int j = 0; j < level; j++) {
            set.add(arr[j] - (level-j));
            set.add(arr[j] + (level-j));
            set.add(arr[j]);
        }
        for (int i=0;i<arr.length;i++){
            if (level==0||!set.contains(i)){
                arr[level]=i;
                recursive2(result, arr, level+1);
            }
        }
    }

    private void greateResult(int[] arr, ArrayList<List<String>> result) {
        ArrayList<String> list = new ArrayList<>();
        for (int i=0;i<arr.length;i++){
            StringBuilder sb = new StringBuilder();
            for (int j=0;j<arr.length;j++){
                if (arr[i]==j){
                    sb.append("Q");
                }else {
                    sb.append(".");
                }
            }
            list.add(sb.toString());
        }
        result.add(list);
    }

时间复杂度：On^2

空间复杂度：On

解法3：递归（从下往上）

/**
 * 思路：
 * 从下往上
 * 回溯，一行行确定
 * 用一个数组去存，数组索引是当前行，value是值所的在列的角标
 * 当前行的值确定前，先确定前面的所有行的 上，左上角，右上角查看是否有值
 * 用栈存放每行的Q的位置，每行都满足的时候从栈中还原n皇后
 */
    public List<List<String>> solveNQueens(int n) {
        ArrayList<List<String>> result = new ArrayList<>();
        int[] arr=new int[n];
        recursive3(result,arr,0);
        return result;
    }

    private void recursive3(ArrayList<List<String>> result, int[] arr, int lattice) {
        if (lattice==arr.length){
            ArrayList<String> list = new ArrayList<>();
            buildList(list,arr);
            result.add(list);
            return;
        }
        for (int column=0;column<arr.length;column++){
            boolean put_Q = isOK( column, arr,lattice);
            if (put_Q){
                arr[lattice]=column;
                recursive3(result, arr, lattice+1);
            }
        }
    }

    private boolean isOK(int col, int[] arr, int lattice) {

        for (int i=lattice-1;i>=0;i--){
            if (arr[i]==col)return false;
            if (arr[i]==col-(lattice-i))return false;
            if (arr[i]==col+(lattice-i))return false;
        }
        return true;
    }

    private void buildList(ArrayList<String> list, int[] arr) {
        for (int q:arr) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                if (q==i)
                    sb.append("Q");
                else
                    sb.append(".");
            }
            list.add(sb.toString());
        }
    }

时间复杂度：On^2

空间复杂度：On