N皇后问题回溯算法与Java实现详解

莫姐

1. N皇后问题概述

N皇后问题是计算机科学和数学领域的经典问题，要求在一个N×N的棋盘上放置N个皇后，使得它们互不攻击。这个问题最早由国际象棋玩家马克斯·贝瑟尔在1848年提出，后来成为算法学习中回溯法的典型案例。

提示：N皇后问题看似简单，但随着N的增大，解的数量会呈指数级增长。例如，当N=8时（标准八皇后问题），共有92种不同的解法。

2. 问题分析与解法思路

2.1 问题约束条件

N皇后问题的核心约束条件包括：

每行必须放置且只能放置一个皇后
每列必须放置且只能放置一个皇后
任意两个皇后不能位于同一对角线上

这些约束条件将问题转化为一个典型的约束满足问题(CSP)，我们需要找到所有满足这些约束条件的皇后放置方案。

2.2 基本解法思路

最直观的解法是使用回溯算法：

从棋盘的第一行开始，尝试在每一列放置皇后
检查当前位置是否满足约束条件
如果满足，递归处理下一行
如果不满足，回溯并尝试下一个位置
当所有行都成功放置皇后后，记录一个有效解

3. Java实现详解

3.1 基于集合的回溯实现

java复制class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> solutions = new ArrayList<>();
        int[] queens = new int[n]; // 记录每行皇后所在的列
        Set<Integer> columns = new HashSet<>(); // 已占用的列
        Set<Integer> diagonals1 = new HashSet<>(); // 主对角线(row-col)
        Set<Integer> diagonals2 = new HashSet<>(); // 副对角线(row+col)
        
        backtrack(solutions, queens, n, 0, columns, diagonals1, diagonals2);
        return solutions;
    }
    
    private void backtrack(List<List<String>> solutions, int[] queens, int n, 
                         int row, Set<Integer> columns, 
                         Set<Integer> diagonals1, Set<Integer> diagonals2) {
        if (row == n) {
            solutions.add(generateBoard(queens, n));
            return;
        }
        
        for (int col = 0; col < n; col++) {
            if (columns.contains(col)) continue;
            
            int diagonal1 = row - col;
            if (diagonals1.contains(diagonal1)) continue;
            
            int diagonal2 = row + col;
            if (diagonals2.contains(diagonal2)) continue;
            
            // 放置皇后
            queens[row] = col;
            columns.add(col);
            diagonals1.add(diagonal1);
            diagonals2.add(diagonal2);
            
            // 递归处理下一行
            backtrack(solutions, queens, n, row + 1, columns, diagonals1, diagonals2);
            
            // 回溯
            queens[row] = -1;
            columns.remove(col);
            diagonals1.remove(diagonal1);
            diagonals2.remove(diagonal2);
        }
    }
    
    private List<String> generateBoard(int[] queens, int n) {
        List<String> board = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            char[] row = new char[n];
            Arrays.fill(row, '.');
            row[queens[i]] = 'Q';
            board.add(new String(row));
        }
        return board;
    }
}

3.2 基于位运算的优化实现

java复制class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> solutions = new ArrayList<>();
        int[] queens = new int[n];
        solve(solutions, queens, n, 0, 0, 0, 0);
        return solutions;
    }
    
    private void solve(List<List<String>> solutions, int[] queens, int n, 
                      int row, int columns, int diagonals1, int diagonals2) {
        if (row == n) {
            solutions.add(generateBoard(queens, n));
            return;
        }
        
        int availablePositions = ((1 << n) - 1) & (~(columns | diagonals1 | diagonals2));
        
        while (availablePositions != 0) {
            int position = availablePositions & (-availablePositions);
            availablePositions = availablePositions & (availablePositions - 1);
            int column = Integer.bitCount(position - 1);
            
            queens[row] = column;
            solve(solutions, queens, n, row + 1, 
                 columns | position, 
                 (diagonals1 | position) << 1, 
                 (diagonals2 | position) >> 1);
        }
    }
    
    private List<String> generateBoard(int[] queens, int n) {
        List<String> board = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            char[] row = new char[n];
            Arrays.fill(row, '.');
            row[queens[i]] = 'Q';
            board.add(new String(row));
        }
        return board;
    }
}