噩梦的开演-------八皇后！

一、八皇后问题

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

二、问题分析

整体思路：

创建一个全局变量的二维数组chess;

并初始化全为0

一行一行开始放皇后；

若存在相互攻击，则皇后向右移一列

若不存在攻击，进行下一行皇后的放置（这里要用到递归）

要点：

（1）国际象棋的格数

国际像是是8*8，因此，如果放置八个皇后，那么每一行都有一个

（2）问题具体化

利用二维数组，用1来代表皇后，其他为0

（3）皇后的放置方法

利用循环，判断位置是否可以放置皇后，若可以，则放置（将其置1）

三、代码实现

代码块：

[cpp] view plain copy

1. #include<stdio.h>  
2. #include<windows.h>  
3. #define N 8 //可以根据N来修改棋盘的格数   
4. int count = 0;//设置一个计数器   
5. int chess[N][N] = {0};//用于存放棋盘的二维数组   
6.   
7. void print()//打印函数   
8. {     
9.     int i = 0;  
10.     int j = 0;  
11.     printf("*****************************************\n");  
12.     for(i = 0; i<N ;i++)  
13.     {  
14.         for(j = 0; j<N ; j++)  
15.         {  
16.             printf("%d ",chess[i][j]);  
17.         }  
18.         printf("\n");  
19.     }  
20.     printf("*****************************************\n");  
21. }  
22.   
23. //判断是否会互吃   
24. //关键条件  
25. //返回1 表示存在互吃  
26. //返回0 表示正常   
27. int check(int i, int j)//i = 7,j = 4   
28. {     
29.     if(i == 0)  
30.         return 0;//表示正常  
31.     
32.     int k = 0;  
33.     for(k = 0; k<i ; k++)  
34.     {  
35.         if(chess[k][j] == 1)//(0,4)(1,4)...  
36.             return 1;  
37.     }  
38.     for( int s = 0,k = j+1; k<N ;k++)  
39.     {     
40.                         //(7,4)(6,5),(5,6),(4,7)  
41.         if(chess[i-s-1][k] == 1)//(0,11),(1,10),(2,9),(3,8),(4,7)  
42.             return 1;  
43.         s++;  
44.     }  
45.     for(k = 0; k<j ;k++)  
46.     {  
47.         if(chess[i-k-1][j-k-1] == 1)//(6,3)(5,2)(4,1)(3,0)  
48.             return 1;     
49.     }  
50.     for(k = 0; k<N ; k++)  
51.     {  
52.         if(chess[k][j]==1)  
53.             return 1;  
54.     }  
55.     return 0;  
56. }  
57. //判断棋盘上是否有一行存在没有皇后的情况   
58. //返回0 ，表示棋盘正常（每一行都有皇后）  
59. //返回1 ，表示棋盘有错   
60. int check_all()  
61. {  
62.     int i = 0;  
63.     int j = 0;  
64.     int flag = 0;  
65.     for(i = 0; i<N ;i++)  
66.     {     
67.         flag = 0;  
68.         for(j = 0; j<N ; j++)  
69.         {  
70.             if(chess[i][j]==1)  
71.             {  
72.                 flag = 1;  
73.                 break;  
74.             }  
75.         }  
76.         if(flag == 0)  
77.             return 1;//有错   
78.     }  
79.     return 0;  
80. }  
81. //检查某一行是否存在皇后  
82. //返回0 表示存在  
83. //返回1 表示没皇后   
84. int check_line(int line)  
85. {     
86.     if(line==0)  
87.         return 0;  
88.     int k = 0;  
89.     int s = 0;  
90.     int flag = 1;  
91.     for(s = 0; s<line-1 ; s++)  
92.     {     
93.         flag = 1;  
94.         for(k = 0; k<N ;k++)  
95.         {  
96.             if(chess[s][k]==1)  
97.                 flag = 0;  
98.         }  
99.         if(flag==1)  
100.             return 1;  
101.     }  
102.     return 0;  
103. }  
104. //递归的主要算法   
105. void queen(int i,int j)  
106. {         
107.     //符合，置一，进入下一行  
108.     if(check_line(i)==1)//若该行有皇后，返回   
109.         return ;  
110.     if((i==(N-1)))//若此时是最后一行   
111.     {         
112.         if(check(i,j)==0)//当最后一行的皇后可以放下（表示可以成功放置）     
113.         {  
114.             chess[i][j] = 1;//将该位置1，表示皇后   
115.             print();//打印   
116.             count++;//计数器+1   
117.         }  
118.     }         
119.     if(check(i,j)==0)//当可以放皇后时   
120.     {     
121.         chess[i][j] = 1;//放入   
122.         //print();  
123.         //Sleep(1000);  
124.         queen(i+1,0);//进行下一行的皇后放置   
125.     }  
126.     if(j==N)//如果j等于列数，表明越界，返回   
127.         return ;  
128.           
129.     chess[i][j] = 0;//将该位置0   
130.     //print();  
131.     //Sleep(500);  
132.     //不符合，置零，右诺  
133.         queen(i,j+1);//将该行皇后右移一位   
134. }  
135. int main(void)  
136. {     
137.     queen(0,0);  
138.     printf("\ncount = %d\n",count);  
139.     return 0;  
140. }  

运行结果：

转自：http://blog.csdn.net/qq_31828515/article/details/51868515