当前位置：首页 > news >正文

leetcode51.N皇后：回溯算法与冲突检测的核心逻辑

news 来源：原创 2025/6/23 14:01:20

一、题目深度解析与N皇后问题本质

题目描述

n皇后问题研究的是如何将n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给定一个整数n，返回所有不同的n皇后问题的解决方案。每一种解法包含一个明确的n皇后问题的棋子放置方案，该方案中'Q'和'.'分别代表了皇后和空位。

核心特性分析

攻击规则：皇后可以攻击同一行、同一列、同一斜线上的棋子
约束条件：每行、每列、每条对角线上只能有一个皇后
解的形式：每个解是棋盘的一种合法布局，需返回所有可能解

二、回溯解法的核心实现与冲突检测

完整回溯代码实现

class Solution {List<List<String>> res = new ArrayList<>();  // 存储所有合法布局public List<List<String>> solveNQueens(int n) {char[][] chessBoard = new char[n][n];  // 初始化棋盘for (char[] c : chessBoard) {Arrays.fill(c, '.');  // 填充空位}backtracking(n, 0, chessBoard);  // 从第0行开始回溯return res;}public void backtracking(int n, int row, char[][] chessBoard) {if (row == n) {  // 所有行处理完毕，找到一个解res.add(arrayToList(chessBoard));  // 转换为List并存储return;}for (int i = 0; i < n; i++) {  // 遍历当前行的每一列if (isValid(n, row, i, chessBoard)) {  // 检查当前位置是否合法chessBoard[row][i] = 'Q';  // 放置皇后backtracking(n, row + 1, chessBoard);  // 递归处理下一行chessBoard[row][i] = '.';  // 回溯：撤销放置}}}// 将棋盘转换为List<String>格式public List<String> arrayToList(char[][] chessBoard) {List<String> chessList = new ArrayList<>();for (char[] c : chessBoard) {chessList.add(String.copyValueOf(c));}return chessList;}// 检查当前位置(row, col)是否可以放置皇后public boolean isValid(int n, int row, int col, char[][] chessBoard) {// 检查列冲突：当前列上方是否有皇后for (int i = 0; i < row; i++) {if (chessBoard[i][col] == 'Q') {return false;}}// 检查左上对角线冲突for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {if (chessBoard[i][j] == 'Q') {return false;}}// 检查右上对角线冲突for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {if (chessBoard[i][j] == 'Q') {return false;}}return true;  // 无冲突，位置合法}
}

核心组件解析：

棋盘表示：
- 使用二维字符数组char[][] chessBoard表示棋盘
- '.'表示空位，'Q'表示皇后
回溯函数：
- backtracking函数递归处理每一行
- 每行选择一个合法位置放置皇后，然后递归处理下一行
冲突检测：
- isValid函数检查当前位置是否与已放置的皇后冲突
- 检查范围：当前列、左上对角线、右上对角线

三、回溯逻辑的核心流程与剪枝策略

1. 回溯算法的执行流程

关键步骤：

行优先处理：从第0行开始，逐行放置皇后
列遍历选择：对当前行的每一列进行检查
合法性验证：通过isValid函数检查冲突
递归与回溯：
- 合法位置：放置皇后，递归处理下一行
- 回溯操作：撤销当前选择，尝试下一列

示例流程（n=4）：

初始棋盘：
....
....
....
....处理第0行：
Q...  合法，递归处理第1行

2. 冲突检测的核心逻辑

检查范围：

列冲突：当前列上方是否有皇后
左上对角线：从当前位置向左上方检查
右上对角线：从当前位置向右上方检查

代码实现：

// 列冲突检查
for (int i = 0; i < row; i++) {if (chessBoard[i][col] == 'Q') return false;
}// 左上对角线检查
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {if (chessBoard[i][j] == 'Q') return false;
}// 右上对角线检查
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {if (chessBoard[i][j] == 'Q') return false;
}

为什么不检查下方？

由于回溯是按行处理，当前行下方的行尚未放置皇后，因此无需检查

四、回溯过程深度模拟：以n=4为例

关键递归路径：

初始状态：
```
....
....
....
....
```
- 处理第0行，选择第0列放置皇后
```
Q...
....
....
....
```
- 递归处理第1行
处理第1行：
- 第0列冲突（列冲突）
- 第1列冲突（左上对角线冲突）
- 第2列合法，放置皇后
```
Q...
..Q.
....
....
```
- 递归处理第2行
处理第2行：
- 所有列均冲突，回溯到第1行
回溯到第1行：
- 撤销第1行第2列的皇后，选择第3列
```
Q...
...Q
....
....
```
- 递归处理第2行
处理第2行：
- 第1列合法，放置皇后
```
Q...
...Q
.Q..
....
```
- 递归处理第3行
处理第3行：
- 所有列均冲突，回溯到第2行

最终找到解：

.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

五、算法复杂度分析

1. 时间复杂度

O(n!)：
- 最坏情况下需要尝试所有可能的排列
- 每个解需要O(n)时间验证合法性

2. 空间复杂度

O(n²)：
- 主要用于存储棋盘状态
- 递归栈深度为O(n)

六、核心技术点总结：回溯与冲突检测的协同设计

1. 回溯算法的关键点

行优先策略：逐行处理，避免行冲突
选择与撤销：合法位置放置皇后，回溯时撤销选择
剪枝优化：通过合法性检查提前排除无效路径

2. 冲突检测的高效实现

三维约束检查：列、左上对角线、右上对角线
方向优化：仅检查当前位置上方的区域，避免重复检查

3. 解的转换与存储

棋盘转换：二维数组转换为List
深度复制：每次找到解时复制棋盘状态，避免后续修改

七、常见误区与优化建议

1. 忽略对角线检查方向

错误做法：检查对角线时遍历整个棋盘

// 错误：检查范围过大
for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {// ...检查逻辑}
}

正确做法：仅检查当前位置上方的对角线

2. 未进行深度复制

错误做法：直接添加棋盘引用

res.add(Arrays.asList(chessBoard)); // 错误：所有解指向同一对象

正确做法：转换为不可变List

res.add(arrayToList(chessBoard)); // 正确：复制棋盘内容

3. 优化建议：位运算加速

// 使用三个整数表示列、左对角线、右对角线的占用情况
private void backtrack(int row, int cols, int diag1, int diag2) {if (row == n) {// 生成解的逻辑return;}// 计算当前行所有合法位置int availablePositions = ((1 << n) - 1) & (~(cols | diag1 | diag2));while (availablePositions != 0) {int p = availablePositions & (-availablePositions);availablePositions &= availablePositions - 1;int col = Integer.bitCount(p - 1);// 递归处理下一行backtrack(row + 1, cols | p, (diag1 | p) << 1, (diag2 | p) >> 1);}
}