Java实战 - 实现八皇后的回溯算法

作者：逍遥Sean
简介：一个主修Java的Web网站\游戏服务器后端开发者
主页：https://blog.csdn.net/Ureliable
觉得博主文章不错的话，可以三连支持一下~ 如有疑问和建议，请私信或评论留言！

前言
当涉及经典的回溯算法问题时，八皇后问题是一个典型的例子。在这篇博文中，我们将详细讨论如何使用Java实现八皇后问题的解决方案。八皇后问题是一个著名的排列问题，要求在8×8的棋盘上放置8个皇后，使得彼此之间不能互相攻击，即任意两个皇后都不在同一行、同一列或者同一条对角线上。

算法原理

八皇后问题可以通过回溯算法有效地解决。回溯算法是一种通过不断试探和回溯来寻找解的方法，在搜索过程中，如果发现当前的路径不能达到目标，就回溯到上一步进行尝试。

步骤概述：

1. 初始化棋盘：使用一个二维数组 board 表示棋盘，其中 board[i][j] 的值为1表示第 i 行第 j 列有一个皇后，为0表示没有皇后。

2. 递归回溯函数：编写一个递归函数 solve，通过尝试在每一行放置皇后来解决问题。如果当前行的皇后放置成功，则递归处理下一行；如果不能放置，则回溯到上一行尝试其他位置。

3. 判断有效性：在放置皇后时，需要检查当前位置是否与已放置的皇后位置冲突，即同一列、同一对角线上是否已经有皇后。

4. 输出解：当所有皇后都成功放置时，将当前的棋盘状态加入结果集。

Java 实现

下面是八皇后问题的具体实现代码：

public class EightQueensProblem {

    private static final int N = 8; // 棋盘大小为8×8
    private static int[][] board = new int[N][N]; // 棋盘

    // 存储所有解的列表
    private static List<int[][]> solutions = new ArrayList<>();

    // 主求解函数
    public static List<int[][]> solveNQueens() {
        solve(0);
        return solutions;
    }

    // 回溯递归函数
    private static void solve(int row) {
        if (row == N) {
            // 找到一个解，将当前棋盘状态加入解集
            int[][] copy = new int[N][N];
            for (int i = 0; i < N; i++) {
                System.arraycopy(board[i], 0, copy[i], 0, N);
            }
            solutions.add(copy);
            return;
        }

        for (int col = 0; col < N; col++) {
            if (isValid(row, col)) {
                // 放置皇后
                board[row][col] = 1;
                // 递归处理下一行
                solve(row + 1);
                // 回溯，撤销当前放置的皇后
                board[row][col] = 0;
            }
        }
    }

    // 判断在第row行，第col列放置皇后是否合法
    private static boolean isValid(int row, int col) {
        // 检查同一列是否有皇后冲突
        for (int i = 0; i < row; i++) {
            if (board[i][col] == 1) {
                return false;
            }
        }

        // 检查左上至右下对角线是否有皇后冲突
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 1) {
                return false;
            }
        }

        // 检查右上至左下对角线是否有皇后冲突
        for (int i = row - 1, j = col + 1; i >= 0 && j < N; i--, j++) {
            if (board[i][j] == 1) {
                return false;
            }
        }

        return true;
    }

    // 打印棋盘
    private static void printBoard(int[][] board) {
        for (int[] row : board) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List<int[][]> solutions = solveNQueens();
        for (int[][] solution : solutions) {
            System.out.println("Solution:");
            printBoard(solution);
        }
    }
}

解释和运行示例：

• solveNQueens 方法：这是主函数，通过调用 solve 函数来解决八皇后问题，并返回所有解的列表。

• solve 方法：递归函数，尝试在当前行放置皇后，并递归处理下一行。如果找到解，则将当前棋盘状态复制并加入解集；否则进行回溯。

• isValid 方法：判断在当前位置放置皇后是否合法，即检查同一列和两条对角线上是否有冲突。

• printBoard 方法：用于打印棋盘状态，方便查看每个解的具体布局。

在 main 方法中，我们调用 solveNQueens 方法获取所有解，并逐个打印每个解的棋盘状态。

结论

通过这篇博文，我们详细讨论了如何使用Java实现八皇后问题的回溯算法解决方案。这个问题不仅是经典的算法练习题目，还能帮助理解回溯算法的应用和原理。希望本文能够帮助读者更好地理解和应用回溯算法解决类似的组合问题。