javaN皇后（力扣Leetcode51）

N 皇后问题

力扣原题链接

问题描述

N 皇后问题是一个经典的回溯算法问题，研究的是如何将 N 个皇后放置在 N×N 的棋盘上，并且使皇后彼此之间不能相互攻击。在国际象棋中，皇后可以攻击与之处在同一行、同一列或同一斜线上的棋子。给定一个整数 n，表示棋盘的大小，求所有不同的 N 皇后问题的解决方案。

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

解题思路

1. 初始化一个棋盘 box，其中所有格子都为 '.'，表示空位。
2. 使用回溯算法，在棋盘的每一行依次尝试放置皇后。
3. 对于当前行，遍历每一个列，尝试放置皇后并检查是否满足条件。
4. 如果当前位置满足条件，则标记为放置了皇后，并递归调用回溯函数进入下一行。
5. 当放置完最后一行的皇后后，将当前棋盘加入结果列表。

算法步骤

1. 初始化一个空的字符串列表 box，用于表示棋盘。
2. 遍历棋盘的每一行，初始化每一行的字符串为 '.'。
3. 调用回溯函数 backtrack，传入参数 n、box 和起始行 0。
4. 在回溯函数中，首先判断是否到达最后一行，如果是则将当前棋盘加入结果列表并返回。
5. 遍历当前行的每一个列，尝试放置皇后：
   • 判断当前位置是否满足条件，如果满足则标记为放置了皇后，并递归调用回溯函数进入下一行。
   • 回溯结束后，撤销当前位置的皇后标记。
6. 当所有位置都尝试完毕后，回溯结束。

复杂度分析

• 时间复杂度：O(N!)，其中 N 表示棋盘的大小。
• 空间复杂度：O(N^2)，主要取决于棋盘的大小和结果列表的空间。

Java 代码

class Solution {
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        List<String> box = new ArrayList<>();
        // 初始化棋盘
        for (int i = 0; i < n; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < n; j++) {
            // 填充棋盘，初始皇后位置都为 '.'
                sb.append('.');
            }
            box.add(sb.toString());
        }
          // 回溯求解 N 皇后问题
        backstrack(n, box, 0);
        return res;
    }

    public void backstrack(int n, List<String> pathbox, int row) {
    // 如果已经处理到最后一行，将当前棋盘状态加入解集
        if (row == n) {
            res.add(new ArrayList<>(pathbox));
            return;
        }
        // 遍历当前行的所有列
        for (int i = 0; i < n; i++) {
        // 如果当前位置可以放置皇后，则进行放置，并继续处理下一行
            if (isvalid(pathbox, row, i)) {
                change(pathbox, row, i, 'Q');// 放置皇后
                backstrack(n, pathbox, row + 1); // 继续处理下一行
                change(pathbox, row, i, '.');// 回溯，将当前位置恢复为空
            }
        }
    }

    public boolean isvalid(List<String> pathbox, int row, int col) {
        for (int i = 0; i < row; i++) {
            if (pathbox.get(i).charAt(col) == 'Q') return false; // 检查列是否冲突
            int diff = row - i;
            // 检查左上到右下对角线是否冲突
            if (col - diff >= 0 && pathbox.get(i).charAt(col - diff) == 'Q') return false; 
            // 检查右上到左下对角线是否冲突
            if (col + diff < pathbox.size() && pathbox.get(i).charAt(col + diff) == 'Q') return false; 
        }
        return true;
    }

    public void change(List<String> pathbox, int row, int col, char c) {
        StringBuilder sb = new StringBuilder(pathbox.get(row));
        sb.setCharAt(col, c);
        pathbox.set(row, sb.toString

());
    }
}

优化

算法步骤

1. 初始化一个空的二维字符数组 board，用于表示棋盘。
2. 调用回溯函数 backtrack，传入参数 board、当前行 0 和结果列表 res。
3. 在回溯函数中，首先判断是否到达最后一行，如果是则将当前棋盘加入结果列表并返回。
4. 遍历当前行的每一个位置，尝试放置皇后：
   • 判断当前位置是否满足条件，如果满足则标记为放置了皇后，并递归调用回溯函数进入下一行。
   • 回溯结束后，撤销当前位置的皇后标记。
5. 当所有位置都尝试完毕后，回溯结束。

复杂度分析

• 时间复杂度：O(N!)，其中 N 表示棋盘的大小。
• 空间复杂度：O(N^2)，主要取决于棋盘的大小和结果列表的空间。

Java 代码

class Solution {
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        char[][] board = new char[n][n]; // 初始化棋盘
        for (char[] row : board) {
            Arrays.fill(row, '.');
        }
        backtrack(board, 0); // 回溯函数入口
        return res; // 返回结果列表
    }

    // 回溯函数，用于寻找皇后放置方案
    private void backtrack(char[][] board, int row) {
        // 如果已经到达最后一行，将当前棋盘加入结果列表并返回
        if (row == board.length) {
            res.add(construct(board));
            return;
        }
        // 遍历当前行的每一个位置，尝试放置皇后
        for (int col = 0; col < board.length; col++) {
            // 判断当前位置是否满足条件，如果满足则标记为放置了皇后，并递归调用回溯函数进入下一行
            if (isValid(board, row, col)) {
                board[row][col] = 'Q';
                backtrack(board, row + 1);
                board[row][col] = '.';
            }
        }
    }

    // 判断当前位置是否可以放置皇后
    private boolean

 isValid(char[][] board, int row, int col) {
        int n = board.length;
        // 检查列是否有皇后冲突
        for (int i = 0; i < n; i++) {
            if (board[i][col] == 'Q') {
                return false;
            }
        }
        // 检查左上方是否有皇后冲突
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        // 检查右上方是否有皇后冲突
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        return true; // 当前位置可以放置皇后
    }

    // 将棋盘转换为字符串列表
    private List<String> construct(char[][] board) {
        List<String> path = new ArrayList<>();
        for (char[] row : board) {
            path.add(new String(row));
        }
        return path;
    }
}

优化分析

1. 数据结构差异：

   • 第一份代码使用了 List<String> 作为棋盘的表示方式，其中每个字符串代表棋盘的一行。这样的数据结构比较灵活，但在判断皇后是否冲突时需要进行多次字符串操作。
   • 第二份代码使用了二维字符数组 char[][] 来表示棋盘，其中字符 'Q' 表示皇后，'.' 表示空白。这种表示方式更直观，也更方便进行冲突判断。

2. 回溯实现方式差异：

   • 第一份代码使用了递归的回溯方式，通过遍历每个位置并尝试放置皇后，然后递归进入下一行进行搜索。在搜索过程中，会不断地修改棋盘的状态，并且通过 List<String> 来存储和记录每个棋盘状态。
   • 第二份代码也是使用了递归的回溯方式，但是使用了二维字符数组来表示棋盘，并且通过遍历每个位置并判断是否可以放置皇后来进行搜索。在搜索过程中，直接修改二维字符数组的状态，并且通过转换为字符串列表来记录每个棋盘状态。

3. 优化点：

   • 第二份代码在判断皇后是否冲突时，只需要遍历当前行之前的行数，而不需要像第一份代码一样需要遍历整个棋盘。这样可以大大减少了冲突判断的时间复杂度，提高了算法的效率。
   • 第二份代码通过使用二维字符数组表示棋盘，省去了在每次递归中创建新的字符串列表的开销，节省了内存空间和时间开销。