题目描述

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 皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

回溯（BFS思想）

public class Solution {
          
   

    private int n;
    /**
     * 记录某一列是否放置了皇后
     */
    private boolean[] col;
    /**
     * 记录从左到右的单元格是否放置了皇后
     * 规律是每一条对角线上的差是相同的
     * 用哈希set来存储的话 之后的判断部分不需要将值映射到0-2n 有正有负也可以
     */
    private boolean[] left;
    /**
     * 记录了从右到左的单元格是否放置了皇后
     * 规律是每一条对角线上的和是相同的
     */
    private boolean[] right;
    private List<List<String>> res;

    public List<List<String>> solveNQueens(int n) {
          
   
        res = new ArrayList<>();
        if (n == 0) return res;

        // 设置成员变量，减少参数传递，具体作为方法参数还是作为成员变量，请参考团队开发规范
        this.n = n;
        this.col = new boolean[n];

        this.left = new boolean[2 * n - 1];
        this.right = new boolean[2 * n - 1];

        Deque<Integer> path = new ArrayDeque<>();
        dfs(0, path);
        return res;
    }

    private void dfs(int row, Deque<Integer> path) {
          
   
        if (row == n) {
          
   
            // 深度优先遍历到下标为 n，表示 [0.. n - 1] 已经填完，得到了一个结果
            List<String> board = convert2board(path);
            res.add(board);
            return;
        }

        // 针对下标为 row 的每一列，尝试是否可以放置
        for (int j = 0; j < n; j++) {
          
   
            //对角线使用 row-j 和 row+j 来判断的 但是row-j会有负数 所以将答案转化到0-2n之间

            if (!col[j] && !left[row - j + n - 1] && !right[row + j]) {
          
   
                path.addLast(j);
                col[j] = true;
                left[row - j + n - 1] = true;
                right[row + j] = true;

                dfs(row + 1, path);
                // 复位
                right[row + j] = false;
                left[row - j + n - 1] = false;
                col[j] = false;
                path.removeLast();
            }
        }
    }

    //将答案转化为 标准的格式
    private List<String> convert2board(Deque<Integer> path) {
          
   
        List<String> board = new ArrayList<>();
        for(Integer num:path){
          
   
            StringBuilder sb = new StringBuilder();
            sb.append(".".repeat(n));
            sb.replace(num, num+1, "Q");

            board.add(sb.toString());
        }

        return board;
    }
}