每日一题 51N皇后（排列型回溯）

原创已于 2023-10-28 07:42:04 修改 · 171 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #java

于 2023-09-21 18:45:06 首次发布

博客围绕N皇后问题展开，介绍了该问题是将n个皇后放置在n×n棋盘上，使皇后彼此不能相互攻击。给出了问题的示例及输入输出，还给出了题解的时间和空间复杂度，最后介绍了优化方法，将r+c和r - c存入数组，优化后空间复杂度降为O(1)。

N皇后

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

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

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

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

示例 1：

输入：n = 4
输出：[[“.Q…”,“…Q”,“Q…”,“…Q.”],[“…Q.”,“Q…”,“…Q”,“.Q…”]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：

输入：n = 1
输出：[[“Q”]]

提示：

1 <= n <= 9

题解

class Solution {
    private List<List<String>> ans = new ArrayList<>();
    private int n;
    private int[] col;
    public List<List<String>> solveNQueens(int n) {
        this.n = n;
        col = new int[n];
        dfs(0);
        return ans;
    }

    private void dfs(int row) {
        if (row == n) {
            //使用数组来存放答案
            List<String> temp = new ArrayList<>();
            for (int i : col) {
                char[] rows = new char[n];
                Arrays.fill(rows,'.');
                rows[i] = 'Q';
                temp.add(new String(rows)); 
            }
            ans.add(temp);
            return;
        }
        for (int c = 0; c < col.length; c++) {
            if (valid(row,c)) {
                col[row] = c;
                dfs(row + 1);
            }
        }
    }

    private boolean valid(int r, int c) {
        for (int R = 0; R < r; R++) {
            int C = col[R];
            //横向或者左下到右上或者左上到右下
            if ((c == C) || (R + C) == (r + c) || (R - C) == (r - c)){
                return false;
            } 
        }
        return true;
    }
}

时间复杂度：O(n! * n * n)
空间复杂度：O(n)

优化

将r+c和r-c存入数组

class Solution {
    private List<List<String>> ans = new ArrayList<>();
    private int n;
    private int[] col;
    //onPath记录列是否被使用 diag1记录r+c diag2记录r-c
    private boolean[] onPath,diag1,diag2;
    public List<List<String>> solveNQueens(int n) {
        this.n = n;
        col = new int[n];
        onPath = new boolean[n];
        diag1 = new boolean[n * 2 - 1];
        diag2 = new boolean[n * 2 - 1];
        dfs(0);
        return ans;
    }

    private void dfs(int r) {
        if (r == n) {
            //使用数组来存放答案
            List<String> temp = new ArrayList<>();
            for (int i : col) {
                char[] rows = new char[n];
                Arrays.fill(rows,'.');
                rows[i] = 'Q';
                temp.add(new String(rows)); 
            }
            ans.add(temp);
            return;
        }
        for (int c = 0; c < n; c++) {
            int r_c = r - c + n - 1;//避免r-c负数 右上角得到-(n-1)
            if (!onPath[c] && !diag1[r + c] && !diag2[r_c]) {
                col[r] = c;
                onPath[c] = diag1[r+c] = diag2[r_c] = true;
                dfs(r + 1);
                onPath[c] = diag1[r+c] = diag2[r_c] = false;//恢复现场
            } 
        }
    }

}