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

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

题目描述

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

核心特性分析

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

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

完整回溯代码实现

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;  // 无冲突，位置合法
    }
}

核心组件解析：

1. 棋盘表示：

   • 使用二维字符数组char[][] chessBoard表示棋盘
   • '.'表示空位，'Q'表示皇后

2. 回溯函数：

   • backtracking函数递归处理每一行
   • 每行选择一个合法位置放置皇后，然后递归处理下一行

3. 冲突检测：

   • isValid函数检查当前位置是否与已放置的皇后冲突
   • 检查范围：当前列、左上对角线、右上对角线

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

1. 回溯算法的执行流程

关键步骤：

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

示例流程（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为例

关键递归路径：

1. 初始状态：

   ....
   ....
   ....
   ....

   • 处理第0行，选择第0列放置皇后

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

   • 递归处理第1行

2. 处理第1行：

   • 第0列冲突（列冲突）

   • 第1列冲突（左上对角线冲突）

   • 第2列合法，放置皇后

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

   • 递归处理第2行

3. 处理第2行：

   • 所有列均冲突，回溯到第1行

4. 回溯到第1行：

   • 撤销第1行第2列的皇后，选择第3列

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

   • 递归处理第2行

5. 处理第2行：

   • 第1列合法，放置皇后

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

   • 递归处理第3行

6. 处理第3行：

   • 所有列均冲突，回溯到第2行

7. 最终找到解：

   .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);
    }
}

• 优势：位运算将冲突检测时间从O(n)降至O(1)
• 适用场景：n较大时性能提升明显

八、总结：回溯算法在约束满足问题中的应用

本算法通过回溯法系统枚举所有可能的皇后放置方案，核心在于：

1. 回溯框架：逐行处理，选择合法位置，递归下一行，回溯撤销选择
2. 冲突检测：高效检查列、左上对角线、右上对角线冲突
3. 解的收集：找到合法解时进行深度复制并存储

理解这种解法的关键是把握回溯过程中状态的变化路径，以及如何通过冲突检测剪枝无效路径。N皇后问题是回溯算法在约束满足问题中的典型应用，这种思路可扩展到数独、八数码等其他约束满足问题。