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种摆放方法

需要注意的是：

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