技術標籤：遞迴算髮題演算法題leetcode資料結構演算法java

文章目錄

• • 題目：
  • 解法1：遞迴（對角線規律）
  • 解法2：遞迴（遍歷每層）
  • 解法3：遞迴（從下往上）

題目：

解法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