递归--八皇后问题（Java）

递归--八皇后问题（Java）

博客说明

文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！

问题介绍

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法

问题思路

1. 第一个皇后先放第一行第一列
2. 第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
3. 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
5. 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

代码思路

创建一个一维数组代替原本的二维数组，只针对列和斜线的判断

采用循环来判断在第n个皇后的不同列（i）是否冲突

使用递归来判断不同的皇后的情况

代码

package question;

public class Queen {
    //定义最大的行
    int max = 8;
    //创建一维数组存储每行的列的位置
    int[] array = new int[max];
    //结果数
    static int count = 0;
    //检查是否冲突的次数
    static int judgecount = 0;

    public static void main(String[] args) {
        Queen queen = new Queen();
        queen.check(0);
        System.out.printf("一共有%d总解法", count);
        System.out.println();
        System.out.printf("一共有%d次判断冲突", judgecount);
    }

    //放置皇后
    private void check(int n) {
        if (n == max) {  //已经放置好
            //打印函数
            print();
            return;
        }

        //依次放置皇后的列数
        for (int i = 0; i < max; i++) {
            //把皇后放置到该行的第一列
            array[n] = i;
            //判断当前皇后在i列时是否冲突
            if (judge(n)) { //不冲突
                //接着放n+1个皇后（递归）
                check(n + 1);
            }
        }
    }
  
		//判断是否冲突
    private boolean judge(int n) {
        judgecount++;
        for (int i = 0; i < n; i++) {
            //由于n代表行，所以不会出现在同一行的情况，判断是否在同一列，判断是否在同一斜线上
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    //打印结果
    private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

结果

7 5 2 6 1 3 
7 2 6 3 1 4 
3 5 7 1 4 2 
4 7 1 3 5 2 
5 7 2 0 6 4 
6 0 2 7 5 3 
6 3 0 7 5 2 
0 6 3 7 2 4 
7 2 0 3 6 4 
2 5 7 4 0 3 
4 7 0 3 5 2 
5 0 2 4 6 3 
6 4 7 1 3 5 
1 7 0 6 3 5 
1 7 5 3 6 0 
6 0 3 1 7 5 
7 3 0 6 1 5 
1 4 7 0 6 3 
1 6 0 3 7 4 
1 6 4 0 7 3 
3 0 7 4 6 1 
3 1 7 4 6 0 
7 0 3 6 4 1 
7 0 4 6 1 3 
7 1 3 0 6 4 
1 7 4 0 3 5 
1 7 5 3 0 4 
3 6 0 5 1 4 
4 7 1 6 2 5 
4 7 5 2 6 1 
4 7 5 0 2 6 
6 2 5 7 0 4 
6 2 5 7 4 0 
6 4 0 7 5 2 
7 4 6 0 2 5 
7 5 0 2 4 6 
0 4 1 7 2 6 
7 1 6 0 2 4 
7 2 0 6 4 1 
0 7 4 1 5 2 
2 7 1 4 0 5 
4 1 5 0 2 7 
4 2 0 5 7 1 
0 2 5 1 6 4 
0 4 6 1 5 2 
4 2 0 6 1 5 
3 5 7 1 6 2 
7 3 1 6 2 5 
7 5 2 6 1 3 
3 5 7 2 0 6 
3 6 2 7 5 0 
5 0 6 3 7 2 
7 0 3 6 2 5 
0 5 7 1 3 6 
0 6 1 7 5 3 
7 3 6 0 5 1 
0 2 7 5 3 1 
0 3 1 7 5 2 
1 3 7 0 2 5 
1 5 2 0 3 7 
1 5 2 0 7 3 
3 0 2 7 5 1 
3 0 2 5 1 6 
3 0 6 1 5 2 
4 1 7 2 6 3 
6 0 2 4 7 3 
6 0 3 7 4 2 
0 6 4 7 1 3 
0 7 3 1 6 4 
0 7 4 1 3 6 
4 6 0 3 1 7 
4 7 0 3 1 6 
6 1 3 7 0 4 
6 1 7 4 0 3 
6 3 0 7 1 4 
0 4 7 1 6 2 
1 7 4 6 0 2 
6 0 2 4 1 7 
6 0 7 1 4 2 
1 3 0 6 4 2 
2 7 5 3 1 4 
3 0 7 4 2 5 
5 2 0 3 7 4 
0 5 7 4 1 3 
7 1 4 0 5 3 
1 4 7 0 2 5 
1 7 5 0 2 4 
2 0 5 7 1 3 
3 0 6 4 2 5 
4 2 0 6 3 5 
0 5 1 4 6 3 
0 2 5 1 6 4 
一共有92总解法
一共有15720次判断冲突

感谢

尚硅谷

万能的网络

以及勤劳的自己

关注公众号： 归子莫，获取更多的资料，还有更长的学习计划