八皇后

Posted 2020-08-09

八皇后问题是一个古来而著名的问题，该问题是19世纪著名的数学家高斯同学提出来的。在8*8的国际象棋 上摆放八个皇后，使其不能互相的攻击，也就是说，任意的两个皇后不能放在同一行或则是同一个列或者是同一个对角线上，问有多少个摆放的方法 。

下面给出Java代码，

Java代码  

1. package endual;  
2.   
3. public class Queen {  
4.   
5.     private final int size = 8;           // 棋盘的大小  
6.     private int[] location ;              //皇后在棋盘上的每一行的列的位子  
7.     private int[] colsOccupied ;          //皇后在棋盘上占据的列  
8.     private int[] cross1Occuptied ;       //皇后在棋盘上占据的正对角线  
9.     private int[] cross2Occuptied ;       //皇后在棋盘上占据的是反对角线  
10.     private static int count ;       //解决的方法的个数  
11.       
12.       
13.       
14.     private static final int STATUS_OCCUPIED = 1 ; //占据的状态  
15.     private static final int STATUS_OCCUPY_CANCELED = 0 ; //没有占据的状态  
16.       
17.     public Queen() {  
18.   
19.         this.location = new int[this.size];  
20.         this.colsOccupied = new int[this.size];  
21.         this.cross1Occuptied = new int[2*this.size];  
22.         this.cross2Occuptied = new int[2*this.size];  
23.     }  
24.       
25.     public void printLocation() {  
26.           
27.         System.out.println("以下是皇后在棋盘上的第" +count+"种方式的摆放");  
28.         for (int i=0; i <this.size; i++) {  
29.               
30.             System.out.println("行：" + i + " 列：" + this.location[i]) ;  
31.         }  
32.     } //end 打印  
33.       
34.     /*判断位子（i,j）是否被占领了*/  
35.     private boolean isOccupied(int i, int j) {  
36.       
37.         if(this.colsOccupied[j] == 1) {  
38.             return true ;  
39.         }  
40.           
41.         if(this.cross1Occuptied[i-j+this.size-1] == 1) {  
42.           return true ;  
43.         }  
44.           
45.         if (this.cross2Occuptied[i+j] == 1) {  
46.             return true ;  
47.         }  
48.           
49.         return false ;  
50.     }  
51.       
52.     /** 
53.      * 如果flag为1，表示占领位子（i,j）; 
54.      * 如果flag为0，表示取消占领位子（i,j) ; 
55.      */  
56.       
57.     private void setStatus(int i, int j, int flag){  
58.           
59.         this.colsOccupied[j] = flag ; //宣布占领或者是取消占领第j列  
60.         this.cross1Occuptied[i-j+this.size-1] = flag ; //宣布占领或者取消占领正对角线  
61.         this.cross2Occuptied[i+j] = flag ;    // 宣布占领或取消占领反对角  
62.           
63.   
64.     }  
65.       
66.     /**第一行开始摆放皇后**/  
67.     public void place(int i) {  
68.           
69.         for (int j=0; j < this.size; j++) { //在第i行尝试把皇后放在每一列  
70.               
71.             if (!this.isOccupied(i, j)) { //判断该位子是不是已经被占领了的  
72.                   
73.                 this.location[i] = j ; //摆放皇后，在第i行把皇后放在第j列  
74.                 this.setStatus(i, j, this.STATUS_OCCUPIED) ; //已经被占领了的  
75.                   
76.                 if (i < this.size-1) {  
77.                     this.place(i+1) ;  
78.                       
79.                 }else {  
80.                     this.count++ ;  
81.                     this.printLocation() ;  
82.                 }  
83.                 //回溯法  
84.                 this.setStatus(i, j, STATUS_OCCUPY_CANCELED) ;  
85.                   
86.             }  
87.   
88.         }  
89.   
90.     }  
91.   
92.     public void start() {  
93.           
94.         this.place(0) ;  
95.     }  
96.       
97. }