java递归求八皇后问题解法

八皇后问题

八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。

网上有很多八皇后的小游戏,不清楚规则的可以点击这里体验一把。

 

递归理解

由于我们使用经典的递归回溯算法,所以要先理解递归的调用过程,在使用递归前我们先看下普通方法的调用过程在JVM中如何体现。首先我们来看下jvm中五个重要的空间,如下图所示

java递归求八皇后问题解法_第1张图片

这里我们主要关注栈区,当调用某个方法时会在栈区为每个线程分配独立的栈空间,而每个方法都会以栈帧的形式压入栈中,即每个方法从进入到退出都对应着一个栈帧的压栈和出栈。如下图所示

java递归求八皇后问题解法_第2张图片

 

在每个栈帧中都会有方法独立的局部变量表,操作数栈,动态连接,返回地址等信息。如下图所示

java递归求八皇后问题解法_第3张图片

 

理解了jvm程序栈的结构后,下面我们以图解的方式先讲解一下普通方法(理解普通方法调用过程后,再讲解递归的调用过程)的调用过程。

假设程序main方法首先调用了method1,在method1中调用了method2,在method2中调用method3。代码如下

 1 public static void main(String []args){
 2         method1();
 3     }
 4     
 5     private static void method1(){
 6         System.out.println("method1调用开始");
 7         method2();
 8         System.out.println("method1调用结束");
 9     }
10 
11     private static void method2(){
12         System.out.println("method2调用开始");
13         method3();
14         System.out.println("method2调用结束");
15     }
16     private static void method3(){
17         System.out.println("method3调用开始");
18         System.out.println("method3调用结束");
19     }

  当执行main方法时,会执行以下步骤

  1)首先将main方法压入栈中,在main方法中调用method1,方法mehod1会压入栈中,并执行打印“method1调用开始”

  2)执行到第7行时,将method2压入栈中,执行method2方法的代码打印出“method2调用开始”

  3)执行到第13行时调用method3方法,将method3方法压入栈中,执行method3方法打印“method3调用开始”,方法压入栈中的过程图解,如下图所示

 

 java递归求八皇后问题解法_第4张图片 

  当执行到图4中的method3方法打印出“method3调用开始”后会执行以下步骤

  1)method3执行打印“method3调用结束”后method3方法体已全部执行完毕,method3方法会出栈,并根据栈帧中程序计数器记录的调用者调用本方法的所在行返回。即返回到method2的13行

  2)执行method2第14行,打印出“method2调用结束”。method2方法体执行完毕,method2方法出栈,返回到method1的第7行

  3)执行method1第8行,打印出method1调用结束。method1方法出栈,返回到main方法中第2行,main方法执行完毕,main方法出栈,整个程序运行结束

  对应图解如下

java递归求八皇后问题解法_第5张图片

 

  根据上面的流程可知程序的运行结果为:

  method1调用开始

  method2调用开始

  method3调用开始

  method3调用结束

  method2调用结束

  method1调用结束

 

 理解了普通方法的调用过程后,下面我们来讲解递归方法的调用过程,我们都知道递归调用就是方法调用自己,当然我们也可以套用上面普通方法的流程,主观认为它是调用别的方法。

 下面以一个求n的阶乘的递归方法为例讲解调用过程,代码如下

 1 public static void main(String []args){
 2         System.out.println(fn(5));
 3     }
 4 
 5     private static int fn(int n){
 6         if(n == 1){
 7             return 1;
 8         }
 9         return fn(n-1)*n;
10     }

 下面还以图解的方式讲解递归的执行过程,为了好区分每次递归的过程,我们以传入的参数标示fn方法,如n=5时,我们假定调用fn5方法。调用过程如下图所示

 

   java递归求八皇后问题解法_第6张图片

  方法的调用扔以压栈的方式进行,调用fn(5)时,fn5压栈,而求fn(5)需要先调用fn(4),从而fn4压栈,依此类推,直到fn(1)方法压栈,此时if(n==1)条件成立,fn(1)方法返回。如下图 

java递归求八皇后问题解法_第7张图片java递归求八皇后问题解法_第8张图片java递归求八皇后问题解法_第9张图片java递归求八皇后问题解法_第10张图片

        图10                    图11               图12                  图13

 java递归求八皇后问题解法_第11张图片

        图14

  执行到图14后,递归的执行过程结束,并将结果5*4*3*2*1的结果返回给main方法并输出,结果为120。

  以上就是递归的执行过程分析,其实跟普通方法的调用过程一样,只不过递归调用的方法是自己而已。

  好了,终于到了本文的重点了(铺垫做的太多),递归回溯法求八皇后解法问题

八皇后问题解法

  问题分析

  1)用代码求解八皇后问题的前提,我们要先构造出来一个8*8的二维数组,但由于八皇后问题的条件限制----任意两个皇后不能同行,所以我们可使用一个8位一维数组表示棋盘,一维数组的第n个元素即代表第n-1(从第0行开始)行,第n个元素的值即代表第n行的列值,如:0 4 7 5 2 6 1 3 ,其中0表示第0行第0列,4表示第2行第5列,7表示第3行第8列,以此类推。

  2)我们在求解的过程中,每添加一个皇后,行数加1,所以不会出现任意两个皇后处在同一行的情况,所以我们只需判断任意两个皇后不在同一列,也不在同一斜线上即可。

  3)从第0行第0列开始放第一个皇后,依此循环8个皇后,并在下一行判断,只要不跟前面所有皇后在同一列或同一斜线上即可放置皇后。

  代码实现

 1 /**
 2  * 递归法解决八皇后问题
 3  */
 4 public class BaHuangHou {
 5     private final static int max = 8;
 6     private static int array[] = new int[max];
 7     private static int count = 0;
 8     public static void main(String []args){
 9         //定义一个一位数组表示八皇后的棋盘(第n个代表第n行,值代表第n行的第m列)
10 
11         check(0);
12         System.out.printf("总共有%d种解法\n",count);
13     }
14 
15     /**
16      * 放置第n个皇后
17      * @param n
18      * @return
19      */
20     private static void check(int n){
21         if(n == max){
22             print(array);
23             return;
24         }
25         for(int i=0; i){
26             array[n] = i;
27             if(judge(n)){
28                 check(n+1);
29             }
30         }
31     }
32     /**
33      * 判断第n个皇后是否与之前的冲突
34      * @param n
35      * @return
36      */
37     private static boolean judge(int n){
38         for(int i=0; i){
39             if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i])){
40                 return false;
41             }
42         }
43         return true;
44     }
45 
46     /**
47      * 打印数组值
48      * @param array
49      */
50     public static void print(int array[]){
51         for (int i = 0; i ) {
52             System.out.print(array[i]+" ");
53         }
54         count ++ ;
55         System.out.println();
56 
57     }
58 }

  代码分析

  首先我们定义了一个8个元素的一维数组 array ,用来表示一个8*8的棋盘。

  1)先来看下判断皇后是否与前面冲突(即在同一列或同一斜线)的judge方法:

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

    第一个条件array[i] == array[n],因一维数组的值即代表所在行的所在列值,所以如果值相同,则代表在同一列。

    第二个条件Math.abs(n-i) == Math.abs(array[n] - array[i]),n-i表示两个皇后相差几行,array[n]-array[i]表示相差几列,如果相差行等于相差,则这两个皇后能构成一个正方形,即在同一斜线上

  2)在来看执行判断过程的check方法:

 1 private static void check(int n){
 2         if(n == max){
 3             print(array);
 4             return;
 5         }
 6         for(int i=0; i){
 7             array[n] = i;
 8             if(judge(n)){
 9                 check(n+1);
10             }
11         }
12     }

  第2行的if()条件判断,用于表示一次求解过程的结束。当n==max即n=8时,即表示前面已经放置了8个皇后(n从0开始)。

  第6行的for循环,表示从第0行的第0列开始放第一个皇后,一直到第0行的第7列遍历出所有第0行的皇后摆放方法。同理,执行到n=1时,表示放置第二个皇后,即第2行的摆放方法,只要第二行不跟第一行冲突,就在第三行放置第3个皇后,以此类推直到放置第7行的第八个皇后。如果在某行遍历完所在行的所有列,均与前面的皇后冲突,说明前面的摆放不能求解出一个八皇后解法,此时该行的循环执行结束,该行所在的方法出栈,回溯到前面一行的方法执行。前面一行继续执行for循环的i++,当i++后即该行皇后向后一个位置移动,如果不跟前面的所有皇后冲突,则再进入下一行的下一个皇后从第0列开始摆放,依此类推。

  当得到一个正确解法后,n=8所在方法出栈(参考前面讲解的递归方法入栈出栈),执行n=7(第8个皇后)所在方法的for循环,继续执行i++,查看最后一行的皇后后面列是否还有正确解法,如果有则输出,如果没有则该行所在方法出栈,进而执行n=6(第7个皇后)所在方法的for循环,继续执行i++。依此类推

  用文字描述稍微有点抽象,不过如果理解了我们前面讲解的递归方法的执行过程,理解起来还是比较容易的。这里使用了for循环求解八皇后的所有解法,所以相对会难以理解。

 图解的方式理解八皇后解法(虚线圆表示不能摆放,用实线圆形表示可以摆放

  在main方法中调用check(0)后,n=0的check方法入栈,并执行for循环的i=0,array[0]=0,即第一个皇后摆放在第0行第0列,此时程序栈和棋盘情况如下图所示  

  java递归求八皇后问题解法_第12张图片

 

  由于这时是第一个皇后,所以肯定没有冲突,但要记住n=0时的check方法的for循环只进行到i=0,便调用check(1),调用下一个皇后的摆放判断,此时程序栈和棋盘情况如下图所示

 

  java递归求八皇后问题解法_第13张图片

 

  当n=1的check方法入栈后,执行for循环方法,由于i=0和i=1均会与第一个皇后冲突,所以这两个位置不能摆放,此时n=1的check方法的for循环执行到i=2。第二个皇后摆放后,会调用check(2),则n=2的check方法入栈,此时程序栈和棋盘情况如下图所示

  java递归求八皇后问题解法_第14张图片

 

  第n=2的check方法入栈后,执行for循环方法,在i<4之前的所有位置均会与前面两个皇后冲突,所以只能放在i=4的位置。此时n=2的check方法的for循环执行到i=4。调用check(3),则n=3的check方法入栈,此时程序栈和期盼情况如下图所示

  java递归求八皇后问题解法_第15张图片

 

  n=3的所在行摆放皇后之后,调用check(4)的方法,此时n=2的check方法的for循环执行到i=4。

  依此类推,直到执行到n=5时,for循环执行完所有遍历,发现均与前面的皇后冲突,如下图所示

  java递归求八皇后问题解法_第16张图片

 

  当n=5的for循环执行完后,check(5)方法出栈,回溯到check(4)的方法继续执行for循环,前面我们知道check(4)的for循环i执行到i=3,所以从i=3继续执行i++,如下图所示

  java递归求八皇后问题解法_第17张图片

 

  可以看出n=4的check方法执行到i=7时,才能满足不与前面的皇后冲突,这时会继续调用check(5)方法,即n=5的check方法再次入栈,如下图所示

  java递归求八皇后问题解法_第18张图片

 

  可以看出n=5时,所在行的所有列均无法摆放皇后,所示n=5的check方法再次出栈,而n=4的check方法的for循环也执行到i=7,所以check(4)方法也会出栈,进而执行n=3的for循环,而我们之前记录可以看到n=3的for循环执行到i=1,所以继续执行i++,并依此判断是否与前面的皇后冲突。

  从上面的过程我们可以看到,当栈顶方法所在行的所有列均不能摆放皇后时,会回溯到前面的行执行。

  下面我们在用一个摆放成功的案例来讲解回溯过程,例如,0 4 7 5 2 6 1 3  即(0,0) (1,4) (2,7) (3,5) (4,2) (5,6) (7,1) (8,3)的摆法,此时程序栈和棋盘如下图所示

  java递归求八皇后问题解法_第19张图片

 

  可以看到,n=7时第八个皇后摆放成功,会调用check(8),进而满足if(n==8)条件,所以check(8)方法出栈,继续执行n=7的check方法,而此时n=7的for循环i=3,继续执行i++,看n=7的所在行的后面的列是否还有能摆放成功的。如果没有则n=7的check方法执行完毕,回溯到n=6的方法,依此类推,知道所有的八皇后解法全部求出。

 

总结

  好了,到这里不知道大家是否理解了使用递归回溯法求八皇后解法的问题?如有疑问的地方,可以在留言区评论提问。

 

你可能感兴趣的:(java递归求八皇后问题解法)