leetcode热题HOT 51. N 皇后

一、问题描述：

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

二、解题思路：

1、初始化：代码首先初始化一个 n x n 大小的棋盘 chessboard，并将所有位置都设置为 ‘.’（表示空位置）。

2、递归回溯：使用 backtracking 方法递归地在棋盘上放置皇后。

递归的基础条件是：当已经放置了 n 个皇后 (num == n) 时，将当前棋盘转换成字符串列表并添加到 result 中。
在递归中，循环遍历每一列尝试放置皇后。对于每一列，在当前行放置皇后之前，会先调用 correct 方法检查当前位置是否可以放置皇后（不与之前放置的皇后冲突）：
①如果当前位置可以放置皇后，就将皇后放置在棋盘上，然后递归调用 backtracking 继续放置下一个皇后。
②如果递归返回，表示无法继续放置皇后，则回溯，撤销当前行的皇后放置（将棋盘位置设为 ‘.’）。

3、正确性检查：correct() 方法用于检查在 row 行和 col 列是否可以放置皇后。它通过检查同一列、左上对角线和右上对角线是否有其他皇后来判断。

4、结果转换：Array2List() 方法将棋盘的 char[][] 转换为 List 以存储结果。

5、回溯模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }
    for (选择：本层集合中的元素) {
        处理单个节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

三、代码示例：

class Solution {
    List<List<String>> result = new ArrayList<>(); // 存储最终结果的列表
    char[][] chessboard; // 棋盘数组
    public List<List<String>> solveNQueens(int n) {
        chessboard = new char[n][n]; // 初始化棋盘
        for (char[] c : chessboard) {
            Arrays.fill(c, '.'); // 将棋盘所有位置初始化为空（'.'表示空位置）
        }
        backtracking(n, 0); // 开始回溯搜索
        return result; // 返回结果列表
    }

    // 回溯搜索方法
    public void backtracking(int n, int num){
        if(num == n) result.add(Array2List(chessboard)); // 如果已经放置了n个皇后，将当前棋盘转换成字符串列表并添加到结果中
        for(int i = 0; i < n; i++){
            if(correct(num, i, n) == true){
                chessboard[num][i] = 'Q';
                backtracking(n, num + 1);//继续搜索下一行
                chessboard[num][i] = '.';//回溯，返回上一步
            }
        }
    }
    // 将棋盘数组转换为字符串列表的方法
    public List Array2List(char[][] chessboard) {
        List<String> list = new ArrayList<>();
        for (char[] c : chessboard) {
            list.add(String.copyValueOf(c)); // 将每一行转换为字符串并添加到列表中
        }
        return list;
    }

    // 检查当前位置是否可以放置皇后的方法
    public boolean correct(int row, int col, int n){
        if(row == 0) return true; // 如果是第一行，直接返回true，因为不会有冲突
        for(int i = 0; i < row; i++){
            if(chessboard[i][col] == 'Q') return false; // 检查同一列是否已经有皇后
        }
        if(col > 0){
            for(int i = row, j = col; i >= 0 && j >= 0; i--,j--){
                if(chessboard[i][j] == 'Q') return false; // 检查左上对角线是否有皇后
            }
        }
        if(col < n - 1){
            for(int i = row, j = col; i >= 0 && j < n; i--, j++){
                if(chessboard[i][j] == 'Q') return false; // 检查右上对角线是否有皇后
            }
        }
        return true; // 如果没有冲突，返回true
    }
}

• 时间复杂度分析：
  ①回溯搜索：算法通过回溯搜索尝试所有可能的皇后放置方案。每个皇后都可以放置在一行的某一列上，因此最坏情况下是 n^n 的方案数（尽管实际上远远小于这个数）。
  ②冲突检查：在 correct 方法中，检查是否有冲突的操作花费了 O(n) 的时间复杂度。
  总体上，该算法的时间复杂度估计为 O(n!)，因为它试图在棋盘上放置 n 个皇后，每个皇后在不同行尝试不同列的位置。而每一个选择可能会导致回溯，因此每次递归都可能产生 n! 个可能的放置方案。这是一个非常复杂的问题，因为时间复杂度会随着 n 的增加快速增长。