Java使用递归和回溯算法解决八皇后问题

概述

八皇后问题:有一个8 * 8的国际象棋棋盘,有8个皇后棋子,需要将8个皇后放置在棋盘上,并满足不出现两个皇后出现在同一行、同一列、同一斜线上,有多少种摆放方式。

解决思路:与Java使用递归和回溯算法走出迷宫同样的解题思路,就是不断的通过递归来一步步的试错,当出现无法进行的情况时,发生回溯操作,直到满足条件。

demo实现

package com.leolee.dataStructure.recursion;

/**
 * @ClassName EightQueenProblem
 * @Description: 八皇后问题:8*8的国际象棋棋盘上摆放8个皇后棋子,每个皇后不与其他皇后在同一个列,同一个行,同一条斜线,否则就是互相攻击的状态,有多少种摆放的方式
 * @Author LeoLee
 * @Date 2020/9/21
 * @Version V1.0
 **/
public class EightQueenProblem {

    int max = 8;

    //定义皇后摆放结果 数组的元素脚标为行,每个元素的值代表列
    int[] array = new int[max];

    int count = 0;//多少种摆放方法


    /*
     * 功能描述: <br> 打印皇后在棋盘上的位置
     * 〈〉
     * @Param: []
     * @Return: void
     * @Author: LeoLee
     * @Date: 2020/9/21 20:53
     */
    public void showQueens () {

        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    /*
     * 功能描述: <br> 检查第n个皇后和之前的皇后的位置是否互相攻击
     * 〈〉
     * @Param: [n 第几个皇后的下脚标]
     * @Return: boolean
     * @Author: LeoLee
     * @Date: 2020/9/21 20:53
     */
    private boolean judgeQueen (int n) {

        for (int i = 0; i < n; i++) {
            //1. array[i] == array[n]表示第个n皇后与第n-1个皇后处于同一列上
            //2. Math.abs(n - i) == Math.abs(array[n] - array[i]) Math.abs()为求绝对值,这个表达式的意思是判断第n个皇后和前面的皇后处于同一斜线上
            //3. 没有判断是否处于同一行,n每次都在递增
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    /*
     * 功能描述: <br> 放置第n个皇后
     * 〈〉
     * @Param: [n 第几个皇后的下脚标]
     * @Return: void
     * @Author: LeoLee
     * @Date: 2020/9/21 21:38
     */
    private void check (int n) {

        if (n == max) {//n = 8,代表已经放置了8个皇后了
            showQueens();
            return;
        }
        //依次放入皇后,并判断是否和规则冲突
        for (int i = 0; i < max; i++) {
            //放置第n个皇后到第n+1行,第i+1列
            array[n] = i;
            //判断放置是否冲突
            if (judgeQueen(n)) {
                //不冲突,就接着放置第n+1个皇后,开始递归
                check(n + 1);
            } else {
                //如果冲突,不做任何处理,即进入下一个循环,这时候n不变,i++,相当于继续判断在第n行的下一列是否冲突
            }
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {

        EightQueenProblem eightQueenProblem = new EightQueenProblem();
        eightQueenProblem.check(0);
        System.out.printf("共有%d种摆放方法\n", eightQueenProblem.getCount());
    }
}

控制台输出:

0 4 7 5 2 6 1 3 
0 5 7 2 6 3 1 4 
0 6 3 5 7 1 4 2 
0 6 4 7 1 3 5 2 
1 3 5 7 2 0 6 4 
1 4 6 0 2 7 5 3 
1 4 6 3 0 7 5 2 
1 5 0 6 3 7 2 4 
1 5 7 2 0 3 6 4 
1 6 2 5 7 4 0 3 
1 6 4 7 0 3 5 2 
1 7 5 0 2 4 6 3 
2 0 6 4 7 1 3 5 
2 4 1 7 0 6 3 5 
2 4 1 7 5 3 6 0 
2 4 6 0 3 1 7 5 
2 4 7 3 0 6 1 5 
2 5 1 4 7 0 6 3 
2 5 1 6 0 3 7 4 
2 5 1 6 4 0 7 3 
2 5 3 0 7 4 6 1 
2 5 3 1 7 4 6 0 
2 5 7 0 3 6 4 1 
2 5 7 0 4 6 1 3 
2 5 7 1 3 0 6 4 
2 6 1 7 4 0 3 5 
2 6 1 7 5 3 0 4 
2 7 3 6 0 5 1 4 
3 0 4 7 1 6 2 5 
3 0 4 7 5 2 6 1 
3 1 4 7 5 0 2 6 
3 1 6 2 5 7 0 4 
3 1 6 2 5 7 4 0 
3 1 6 4 0 7 5 2 
3 1 7 4 6 0 2 5 
3 1 7 5 0 2 4 6 
3 5 0 4 1 7 2 6 
3 5 7 1 6 0 2 4 
3 5 7 2 0 6 4 1 
3 6 0 7 4 1 5 2 
3 6 2 7 1 4 0 5 
3 6 4 1 5 0 2 7 
3 6 4 2 0 5 7 1 
3 7 0 2 5 1 6 4 
3 7 0 4 6 1 5 2 
3 7 4 2 0 6 1 5 
4 0 3 5 7 1 6 2 
4 0 7 3 1 6 2 5 
4 0 7 5 2 6 1 3 
4 1 3 5 7 2 0 6 
4 1 3 6 2 7 5 0 
4 1 5 0 6 3 7 2 
4 1 7 0 3 6 2 5 
4 2 0 5 7 1 3 6 
4 2 0 6 1 7 5 3 
4 2 7 3 6 0 5 1 
4 6 0 2 7 5 3 1 
4 6 0 3 1 7 5 2 
4 6 1 3 7 0 2 5 
4 6 1 5 2 0 3 7 
4 6 1 5 2 0 7 3 
4 6 3 0 2 7 5 1 
4 7 3 0 2 5 1 6 
4 7 3 0 6 1 5 2 
5 0 4 1 7 2 6 3 
5 1 6 0 2 4 7 3 
5 1 6 0 3 7 4 2 
5 2 0 6 4 7 1 3 
5 2 0 7 3 1 6 4 
5 2 0 7 4 1 3 6 
5 2 4 6 0 3 1 7 
5 2 4 7 0 3 1 6 
5 2 6 1 3 7 0 4 
5 2 6 1 7 4 0 3 
5 2 6 3 0 7 1 4 
5 3 0 4 7 1 6 2 
5 3 1 7 4 6 0 2 
5 3 6 0 2 4 1 7 
5 3 6 0 7 1 4 2 
5 7 1 3 0 6 4 2 
6 0 2 7 5 3 1 4 
6 1 3 0 7 4 2 5 
6 1 5 2 0 3 7 4 
6 2 0 5 7 4 1 3 
6 2 7 1 4 0 5 3 
6 3 1 4 7 0 2 5 
6 3 1 7 5 0 2 4 
6 4 2 0 5 7 1 3 
7 1 3 0 6 4 2 5 
7 1 4 2 0 6 3 5 
7 2 0 5 1 4 6 3 
7 3 0 2 5 1 6 4 
共有92种摆放方法

需要注意的是:

这里并没有使用二维数组来模拟棋盘,而是使用了一维数组,数组的下角标代表棋子的行,该下角标对应的值代表棋子的列,以此来确定棋子在棋盘上的位置

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
八皇后问题是指在一个8x8的棋盘上放置8个皇后,使得每个皇后都不会同时攻击到其他皇后。其中,攻击包括在同一行、同一列或同一对角线上。这是一个经典的回溯算法问题,可以使用二维数组来实现。 首先,我们创建一个8x8的二维数组来表示棋盘,用数字1表示皇后的位置,数字0表示空格。然后,从第一行开始,逐行放置皇后,直到所有皇后都放置完毕或无放置。如果当前行不能放置皇后,则回溯到上一行,重新尝试放置皇后。 以下是Java代码实现: ```java public class EightQueens { private static final int SIZE = 8; private int[][] board = new int[SIZE][SIZE]; // 检查当前位置是否可以放置皇后 private boolean isSafe(int row, int col) { int i, j; // 检查列 for (i = 0; i < row; i++) { if (board[i][col] == 1) { return false; } } // 检查左上角对角线 for (i = row, j = col; i >= 0 && j >= 0; i--, j--) { if (board[i][j] == 1) { return false; } } // 检查右上角对角线 for (i = row, j = col; i >= 0 && j < SIZE; i--, j++) { if (board[i][j] == 1) { return false; } } return true; } // 递归放置皇后 private boolean solve(int row) { if (row == SIZE) { return true; // 所有皇后都已放置 } for (int col = 0; col < SIZE; col++) { if (isSafe(row, col)) { board[row][col] = 1; // 放置皇后 // 递归放置下一行的皇后 if (solve(row + 1)) { return true; } board[row][col] = 0; // 回溯 } } return false; // 无放置皇后 } // 打印棋盘 private void printBoard() { for (int i = 0; i < SIZE; i++) { for (int j = 0; j < SIZE; j++) { System.out.print(board[i][j] + " "); } System.out.println(); } } public static void main(String[] args) { EightQueens eq = new EightQueens(); if (eq.solve(0)) { eq.printBoard(); } else { System.out.println("无"); } } } ``` 在以上代码中,`isSafe()`函数用来检查当前位置是否可以放置皇后,`solve()`函数用来递归放置皇后,`printBoard()`函数用来打印棋盘。在`main()`函数中,我们创建`EightQueens`对象并调用`solve()`函数来解决八皇后问题,如果有,则调用`printBoard()`函数打印结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值