八皇后问题
2016-05-06 16:32
267 查看
八皇后问题，是一个古老而著名的问题。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。
思路
对于八皇后的求解可采用回溯算法，从上至下依次在每一行放置皇后，进行搜索，若在某一行的任意一列放置皇后均不能满足要求，则不再向下搜索，而进行回溯，回溯至有其他列可放置皇后的一行，再向下搜索，直到搜索至最后一行，找到可行解，输出。
可以使用递归函数实现上述回溯算法。
然而网上给出的代码，太过于粗糙，我用自己的大白话给大家解释一下。
首先呢，该选取什么样是数据结构？
最直接的方式是选用二维数组，用一个二维数组表示一张棋盘，简单而直观，下面看一下二维数组递归求解的代码，我会给出详细飞注解。
。
1. #include <stdlib.h>
2. #include <stdio.h>
3.
4. int m[8][8] = {0};//表示棋盘，初始为0，表示未放置皇后，1表示该位置放置了一个皇后
5. int num = 0;//解数目
6.
7. //对于棋盘前row-1行已放置好皇后
8. //检查在第row行、第column列放置一枚皇后是否可行
//直观上，我们该怎样检查，在某一个位置放置一个旗子是否正确？
//由于我们是默认的递归方式，已经确保了每一行中只能放置一个旗子（只能有一个1，不是吗？仔细想想）
//那在仔细想想，我们其他的检查条件是什么？，是不是，检查每一列，斜向上（两种方式）是否只有一个1？
//好，看一下代码中如何体现这种思想？
9. bool check(int row,int column)
10. {
11. if(row==1) return true;
12. int i,j;
13. //纵向只能有一枚皇后
14. for(i=0;i<=row-2;i++)
15. {
16. if(m[i][column-1]==1) return false;
17. }
18. //左上至右下只能有一枚皇后
//row-column是什么意思？右斜向下，row，和column之间有什么关系？发现规律了吗？
19. i = row-2;
20. j = i-(row-column);
21. while(i>=0&&j>=0)
22. {
23. if(m[i][j]==1) return false;
24. i--;
25. j--;
26. }
27. //右上至左下只能有一枚皇后
//右上至左下，他们的row和column之间有什么规律？发现规律了吗
28. i = row-2;
29. j = row+column-i-2;
30. while(i>=0&&j<=7)
31. {
32. if(m[i][j]==1) return false;
33. i--;
34. j++;
35. }
36. return true;
37. }
38.
39. //当已放置8枚皇后，为可行解时，输出棋盘
//两行for循环，解决问题
40. void output()
41. {
42. int i,j;
43. num++;
44. printf("answer %d:\n",num);
45. for(i=0;i<8;i++)
46. {
47. for(j=0;j<8;j++) printf("%d ",m[i][j]);
48. printf("\n");
49. }
50. }
51.
52. //采用递归函数实现八皇后回溯算法
53. //该函数求解当棋盘前row-1行已放置好皇后，在第row行放置皇后
54. void solve(int row)
55. {
56. int j;
57. //考虑在第row行的各列放置皇后
58. for (j=0;j<8;j++)
59. {
60. //在其中一列放置皇后
61. m[row-1][j] = 1;
62. //检查在该列放置皇后是否可行
63. if (check(row,j+1)==true)
64. {
65. //若该列可放置皇后，且该列为最后一列，则找到一可行解，输出
66. if(row==8) output();
67. //若该列可放置皇后，则向下一行，继续搜索、求解
68. else solve(row+1);
69. }
70. //取出该列的皇后，进行回溯，在其他列放置皇后
//这一行是回溯，仔细想想
71. m[row-1][j] = 0;
72. }
73. }
74.
75. //主函数
76. int main()
77. {
78. //求解八皇后问题
79. solve(1);
80. return 0;
81. }
代码看到这里，相信大部分人都已经看明白了。
然而，网上还有更简单的版本，能不能用一个以为数组表示棋盘呢？答案是肯定的
来，那看一下，更简洁的版本
a）定义全局堆栈和打印函数
[cpp] view
plain copy
static int gEightQueen[8] = {0};
//这个数组是什么意思？加入一个棋盘中，每一个棋子的位置可以用row和column表示
//row可以用递归的深度表示，column自然可以用一个数组表示，column=gEightQueen[row],
//在下面代码中，row=index;
static int gCount = 0;
//gCount表示找到个数。
void print()
{
int outer;
int inner;
for(outer = 0; outer <8; outer ++){
for(inner = 0; inner < gEightQueen[outer]; inner ++)
printf("* ");
printf("# ");
for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
printf("* ");
printf("\n");
}
printf("=====================================\n");
}
b）添加位置合法性的函数判断
[cpp] view
plain copy
int check_pos_valid(int loop, int value)
{
int index;
int data;
for(index = 0; index < loop; index ++){
data = gEightQueen[index];
//有了上面的铺垫，if的判断条件，是什么意思呢？检查每一列是否只有一个1，不是吗？
if(value == data)
return 0;
//是不是和二维数组判断条件，有些相似？
if((index + data) == (loop + value))
return 0;
//这个相信都能看懂
if((index - data) == (loop - value))
return 0;
}
return 1;
}
c）
八皇后遍历
[cpp] view
plain copy
void eight_queen(int index)
{
int loop;
for(loop = 0; loop < 8; loop++){
if(check_pos_valid(index, loop)){
gEightQueen[index] = loop;
if(7 == index){
gCount ++, print();
gEightQueen[index] = 0;
return;
}
eight_queen(index + 1);
gEightQueen[index] = 0;
}
}
}
总结：
（1）迭代递归是编程的难点，需要自己好好实践，看别人写一百遍，不如自己写一遍
（2）递归的时候务必注意函数return的出口
（3）递归函数中语句的顺序不要随意更换
（4）递归函数中注意数据的保存和恢复
（5）递归函数也要验证，可以用程序验证法，也可以用其他函数的结果来验证
ps:
下面是完整的代码，大家可以直接保存成queue.cpp，直接编译运行即可。可以打印出所有92种情况，
[cpp] view
plain copy
#include <iostream>
using namespace std;
static int gEightQueen[8] = {0};
static int gCount = 0;
void print()
{
int outer;
int inner;
for(outer = 0; outer <8; outer ++){
for(inner = 0; inner < gEightQueen[outer]; inner ++)
printf("* ");
printf("# ");
for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
printf("* ");
printf("\n");
}
printf("=====================================\n");
}
int check_pos_valid(int loop, int value)
{
int index;
int data;
for(index = 0; index < loop; index ++){
data = gEightQueen[index];
if(value == data)
return 0;
if((index + data) == (loop + value))
return 0;
if((index - data) == (loop - value))
return 0;
}
return 1;
}
void eight_queen(int index)
{
int loop;
for(loop = 0; loop < 8; loop++){
if(check_pos_valid(index, loop)){
gEightQueen[index] = loop;
if(7 == index){
gCount ++, print();
gEightQueen[index] = 0;
return;
}
eight_queen(index + 1);
gEightQueen[index] = 0;
}
}
}
int main(int argc, char* argv[])
{
eight_queen(0);
printf("total = %d\n", gCount);
return 1;
}
思路
对于八皇后的求解可采用回溯算法，从上至下依次在每一行放置皇后，进行搜索，若在某一行的任意一列放置皇后均不能满足要求，则不再向下搜索，而进行回溯，回溯至有其他列可放置皇后的一行，再向下搜索，直到搜索至最后一行，找到可行解，输出。
可以使用递归函数实现上述回溯算法。
然而网上给出的代码，太过于粗糙，我用自己的大白话给大家解释一下。
首先呢，该选取什么样是数据结构？
最直接的方式是选用二维数组，用一个二维数组表示一张棋盘，简单而直观，下面看一下二维数组递归求解的代码，我会给出详细飞注解。
。
1. #include <stdlib.h>
2. #include <stdio.h>
3.
4. int m[8][8] = {0};//表示棋盘，初始为0，表示未放置皇后，1表示该位置放置了一个皇后
5. int num = 0;//解数目
6.
7. //对于棋盘前row-1行已放置好皇后
8. //检查在第row行、第column列放置一枚皇后是否可行
//直观上，我们该怎样检查，在某一个位置放置一个旗子是否正确？
//由于我们是默认的递归方式，已经确保了每一行中只能放置一个旗子（只能有一个1，不是吗？仔细想想）
//那在仔细想想，我们其他的检查条件是什么？，是不是，检查每一列，斜向上（两种方式）是否只有一个1？
//好，看一下代码中如何体现这种思想？
9. bool check(int row,int column)
10. {
11. if(row==1) return true;
12. int i,j;
13. //纵向只能有一枚皇后
14. for(i=0;i<=row-2;i++)
15. {
16. if(m[i][column-1]==1) return false;
17. }
18. //左上至右下只能有一枚皇后
//row-column是什么意思？右斜向下，row，和column之间有什么关系？发现规律了吗？
19. i = row-2;
20. j = i-(row-column);
21. while(i>=0&&j>=0)
22. {
23. if(m[i][j]==1) return false;
24. i--;
25. j--;
26. }
27. //右上至左下只能有一枚皇后
//右上至左下，他们的row和column之间有什么规律？发现规律了吗
28. i = row-2;
29. j = row+column-i-2;
30. while(i>=0&&j<=7)
31. {
32. if(m[i][j]==1) return false;
33. i--;
34. j++;
35. }
36. return true;
37. }
38.
39. //当已放置8枚皇后，为可行解时，输出棋盘
//两行for循环，解决问题
40. void output()
41. {
42. int i,j;
43. num++;
44. printf("answer %d:\n",num);
45. for(i=0;i<8;i++)
46. {
47. for(j=0;j<8;j++) printf("%d ",m[i][j]);
48. printf("\n");
49. }
50. }
51.
52. //采用递归函数实现八皇后回溯算法
53. //该函数求解当棋盘前row-1行已放置好皇后，在第row行放置皇后
54. void solve(int row)
55. {
56. int j;
57. //考虑在第row行的各列放置皇后
58. for (j=0;j<8;j++)
59. {
60. //在其中一列放置皇后
61. m[row-1][j] = 1;
62. //检查在该列放置皇后是否可行
63. if (check(row,j+1)==true)
64. {
65. //若该列可放置皇后，且该列为最后一列，则找到一可行解，输出
66. if(row==8) output();
67. //若该列可放置皇后，则向下一行，继续搜索、求解
68. else solve(row+1);
69. }
70. //取出该列的皇后，进行回溯，在其他列放置皇后
//这一行是回溯，仔细想想
71. m[row-1][j] = 0;
72. }
73. }
74.
75. //主函数
76. int main()
77. {
78. //求解八皇后问题
79. solve(1);
80. return 0;
81. }
代码看到这里，相信大部分人都已经看明白了。
然而，网上还有更简单的版本，能不能用一个以为数组表示棋盘呢？答案是肯定的
来，那看一下，更简洁的版本
a）定义全局堆栈和打印函数
[cpp] view
plain copy
static int gEightQueen[8] = {0};
//这个数组是什么意思？加入一个棋盘中，每一个棋子的位置可以用row和column表示
//row可以用递归的深度表示，column自然可以用一个数组表示，column=gEightQueen[row],
//在下面代码中，row=index;
static int gCount = 0;
//gCount表示找到个数。
void print()
{
int outer;
int inner;
for(outer = 0; outer <8; outer ++){
for(inner = 0; inner < gEightQueen[outer]; inner ++)
printf("* ");
printf("# ");
for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
printf("* ");
printf("\n");
}
printf("=====================================\n");
}
b）添加位置合法性的函数判断
[cpp] view
plain copy
int check_pos_valid(int loop, int value)
{
int index;
int data;
for(index = 0; index < loop; index ++){
data = gEightQueen[index];
//有了上面的铺垫，if的判断条件，是什么意思呢？检查每一列是否只有一个1，不是吗？
if(value == data)
return 0;
//是不是和二维数组判断条件，有些相似？
if((index + data) == (loop + value))
return 0;
//这个相信都能看懂
if((index - data) == (loop - value))
return 0;
}
return 1;
}
c）
八皇后遍历
[cpp] view
plain copy
void eight_queen(int index)
{
int loop;
for(loop = 0; loop < 8; loop++){
if(check_pos_valid(index, loop)){
gEightQueen[index] = loop;
if(7 == index){
gCount ++, print();
gEightQueen[index] = 0;
return;
}
eight_queen(index + 1);
gEightQueen[index] = 0;
}
}
}
总结：
（1）迭代递归是编程的难点，需要自己好好实践，看别人写一百遍，不如自己写一遍
（2）递归的时候务必注意函数return的出口
（3）递归函数中语句的顺序不要随意更换
（4）递归函数中注意数据的保存和恢复
（5）递归函数也要验证，可以用程序验证法，也可以用其他函数的结果来验证
ps:
下面是完整的代码，大家可以直接保存成queue.cpp，直接编译运行即可。可以打印出所有92种情况，
[cpp] view
plain copy
#include <iostream>
using namespace std;
static int gEightQueen[8] = {0};
static int gCount = 0;
void print()
{
int outer;
int inner;
for(outer = 0; outer <8; outer ++){
for(inner = 0; inner < gEightQueen[outer]; inner ++)
printf("* ");
printf("# ");
for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
printf("* ");
printf("\n");
}
printf("=====================================\n");
}
int check_pos_valid(int loop, int value)
{
int index;
int data;
for(index = 0; index < loop; index ++){
data = gEightQueen[index];
if(value == data)
return 0;
if((index + data) == (loop + value))
return 0;
if((index - data) == (loop - value))
return 0;
}
return 1;
}
void eight_queen(int index)
{
int loop;
for(loop = 0; loop < 8; loop++){
if(check_pos_valid(index, loop)){
gEightQueen[index] = loop;
if(7 == index){
gCount ++, print();
gEightQueen[index] = 0;
return;
}
eight_queen(index + 1);
gEightQueen[index] = 0;
}
}
}
int main(int argc, char* argv[])
{
eight_queen(0);
printf("total = %d\n", gCount);
return 1;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- CSS默认可继承样式详解
- MUI 和 framework7区别之 UI组件的几点差异
- 前端上传组件Plupload
- iOS 8 之后的动态沙盒路径
- java enum详解
- saltstack 安装 apache
- saltstack 文件目录管理
- saltstack 远程命令
- ES5 数组方法reduce
- [转]自己写PHP扩展之创建一个类
- Ubuntu 16.04 LTS 正式发布：系统将持续更新5年
- oracle数据库创建表空间示例以及开启数据库闪回
- 第十、十一周项目-阅读程序，写出这些程序的运行结果(2)
- CSS3中的动画，animation、transition和transform属性的运用
- 天气插件
- Saltstack 安装及认证
- saltstack grains
- saltstack pillar
- Mysql常用命令
- explode_implode.php