[Java数据结构][8]八皇后问题的判定条件分析

[Java数据结构][8]八皇后问题的判定条件分析

由于在博客中已经可以看到很多八皇后问题相关的java代码，例如

public class Queen8 {
    //定义一个max表示共有多少皇后
    int max = 8;
    int[] array = new int[max];
    static int count = 0;

    public static void main(String[] args) {
        Queen8 queen8 = new Queen8();
        queen8.check(0);
        System.out.printf("一共有%d种解法",count);

    }

    /**
     * 放置第n个皇后
     */
    private void check(int n) {
        if (n == max) { //8个皇后已经放好
            print();
            System.out.println("====================================================");
            count++;
            return;
        }
        //依次放入皇后并判断是否冲突
        for (int i = 0; i < max; i++) {
            //先把当前的皇后n，放到该行的第一列
            array[n] = i;
            //判断当放置第n个皇后到第i列时，是否冲突
            if(judge(n)){
                //接着放n+1个皇后，开始递归
                check(n+1);
            }
            //如果冲突，回到array[n] = i;
        }
    }

    /**
     * 查看当我们放置第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
     *
     * @param n
     * @return
     */
    private boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //array[i] == array[n]判断第n个皇后是否和前n-1个皇后在同一列，八个需均不相等
            // Math.abs(n-i) == Math.abs(array[n] = array[i])判断是否和在同一斜线
            //没必要判断同一行，因为n每次都在递增
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i]))
                return false;
        }
        return true;
    }

    //写一个方法，可以将皇后摆出的位置输出
    private void print() {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

输出结果为

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种解法
Process finished with exit code 0

我们看judge方法中的判断条件

    private boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //array[i] == array[n]判断第n个皇后是否和前n-1个皇后在同一列，八个需均不相等
            // Math.abs(n-i) == Math.abs(array[n] = array[i])判断是否和在同一斜线
            //没必要判断同一行，因为n每次都在递增
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i]))
                return false;
        }
        return true;
    }

1. 首先，由于我们是逐行判定，没有必要做行相等的判定
2. 列判定，在我们的array一个结果有8个数，且一定两两不相同，所以，array[i] == array[n]，这样的判断即可
3. 斜线判定是比较难理解的，我们可以先从头搭建，如果是我们自己写，如何表示两个皇后在同一个斜线上，如果做图的话
   
   相信这样，就比较好理解下面这个判定条件了。

 Math.abs(n - i) == Math.abs(array[n] - array[i]