八皇后问题的最佳解决方案 123

八皇后问题的最佳解决方案

（陕西师范大学计算机科学学院10级计科一班，西安，710062）

摘要：回溯法实际是一个类似枚举的搜索尝试方法，它的主题思想是在搜索尝试中找问题的解，当不满足求解条件就”回溯”(返回)，尝试别的路径。回溯算法是尝试搜索算法中最为基本的一种算法,其采用了一种“走不通就掉头”的思想，作为其控制结构。本文主要描述递归回溯与非递归回溯，并用这两个算法解决经典的“八皇后”问题,找出该问题的最佳解决方案。

关键词：回溯法；递归；非递归；深度优先搜索；约束条件；枚举

Eight queen problem the best solution

Zhao Ya-wen ,Zhao-Shanshan ,Zhong mei ,Duan Xi-juan

（School of Computer Science ,Shanxi Normal University ,Xi’an ,710062）

Abstract:Backtracking is actually a similar enumerated search try method ,It is the theme in the search to find

the solution of problems.,When not solving condition is "back" (return), Try the other path. Backtracking algorithm is trying to search algorithm is the most basic an algorithm, The use of a "walk impassability will turn" thought, As its control structure. This paper mainly describe recursive back and the recursive back, And the two algorithms to solve the classic "eight queen", To find the best solution to the problem.

Keywords:Backtracking; Recursive; The recursive; Depth first search; Constraint conditions; enumeration.

1引言

在用回溯算法解决问题中每向前走一步都有很多路需要选择，但当没有决策的信息或决策的信息不充分时，只好尝试某一路线向下走，到一定程度后得知此路不通时，再回溯到上一步尝试其他路线；当然再尝试成功时，则问题得解算法结束。

回溯法属于图的搜索算法中的深度优先搜索，通常深度优先搜索法不全保留结点，扩展完的结点从数据存储结构栈中弹出删去，这样，一般在数据栈中存储的结点数就是解空间树的深度，因此它占用空间最少。

回溯法在算法思想上是相同的，用深度优先搜索，但是算法分析课程上，我们要考虑算法的时间、空间复杂度，以及它的实用性，即能较好地解决问题。所以，回溯法也是一样的，在满足约束条件和不满足约束条件进行回溯是不一样的，这就是我们要概述的递归回溯算法和非递归回溯算法，

2问题概述

八皇后问题：要在8*8的国际象棋棋盘中放八个皇后，使任意两个皇后都不能互相吃掉。规则：皇后能吃掉同一行、同一列、同一对角线的任意棋子。

如图2-1为一种方案，求所有的解。

图2-1

3求解八皇后问题的常用算法

贪心算法是一种改进了的分级处理算法，在这里，八皇后的贪心选择的依据就是把下一个皇后放在数字最小的格子里，同样可以采用，适用范围广，直观的蛮力算法，当然最经典的解决八皇后问题的算法是回溯法，这里我们主要介绍加约束条件的枚举算法，非递归回溯算法，递归回溯算法。逐一设计算法，三者进行比较，进行算法的时间、空间复杂度评价，找出最优算法，推而广之，寻找出用以解决n皇后的问题的算法。

3.1 模型建立

设八个皇后为xi,她们分别在第i行(i=1,2,3,4……,8),这样问题的解空间, xi就是一个皇后所在列的序号，为n元一维向量(x1,x2,x3,x4,x5,x6,x7,x8),搜索空间是1≤xi≤8（i=1，2，3，4……，8），共88(每个xi均有8种位置)个状态。约束条件是八个皇后：（1,x1）,(2,x2) ,(3,x3),(4,x4) ,(5,x5), (6,x6) , (7,x7), (8,x8)使得(i,xi)不在同一行、同一列和同一对角线上。如图3-1为一种解。

图3-1 八皇后问题的一种解

虽然问题共有88个状态，但算法不会真正地搜索这么多的状态，因为前面已经说明，回溯法采用的是“走不通就掉头”的策略，而形如(1,1,x3,x4, x5,x6,x7,x8)的状态共有86个，由于1，2号皇后在同一列不满足约束条件，回溯后这86个状态是不会搜索的。如图3-2，便是一种不可搜索的情况。

图3-2

3.2 算法设计1--加约束条件的枚举算法

最简单的算法就是通过八重循环模拟搜索空间中的88个状态，按深度优先思想，把第1个皇后放在第1列，然后开始搜索第2到第8个皇后的合理位置，每个皇后只能在同一行的8个位置存放，每前进一步检查是否满足约束条件,不满足时，检查下一个位置，若满足约束条件，开始下一个皇后的合理位置检查，直到找出8个皇后的所有合理位置（即问题的全部解）。

3.2.1约束条件有三个。

（1）不在同一列的表达式为：xi≠xj；

（2）不在同一主对角线上的表达式为：xi-i xj-j；

(3)不在同一负对角线上的表达式为：xi+i≠xj+j.

3.2.2 算法1如下

Main1（）

{int a[9]; //初始化定义数组

for (x1=1; x1<=8; x1++) //从第一列开始搜索

for (x2=1; x2<=8; x2++)

{if （check(x2,2)=0 ）continue; //如果约束条件满足，则执行下一个for

语句，否则当前皇后位置向右移动一位继续检查约束条件for (x3=1;x3<=8;x3++)

{if（check(x3,3)=0）continue; //同上

for (x4=1;x4<=8; x4++)

{if （check(x4,4)=0）continue; //同上

for (x5=1; x5<=8; x5++)

{if （check(x5,5)=0）continue; //同上

for (x6=1; x6<=8; x6++)

{if （check(x6,6)=0）continue;// 同上

for(x7=1; x7<=8; x7++)

{if （check(x7,7)=0）continue; //同上

for(x8=1; x8<=8; x8++) //同上

{if （check(x8,8)=0）continue; //同上

else //找到了一组解

for(i=1;i<=8;i++) //输出一组满足约束的解

print(xi);

}

}

}

} }} } }

check(int xi, int n) //该函数是用来判断是否满足约束

{ int i;

for(i=1;i<=n-1;i++)//这里只需要判断前n-1个

if ( abs( xi- xn)=abs(i-n)) or (xi= xn)//判断是否同一列或者

同一对角线

return(0);

return(1); }

3.2.3算法分析1

表面看算法时间复杂性为8的8次方，而实际上算法在执行中不断运行continue语句回溯，所以时间复杂性远远低于8的8次方。若将算法中循环嵌套间的检查是否满足约束条件的语句: “if (check(xi,i)=0) continue;

i=2,3,4,5,6,7“

都去掉，只保留最后一个检查语句：

“if (check(xi,8)=0) continue;”

那么，相应地check（）函数修改成：check*(xi,n)

{ int i,j;

for(i=1;i<=n;i++)

for(j=i+1;j<=n;j++)

if(abs(xi-xj)=abs(i-j))or(xi=xj)

return(0);

return(1);

}

则算法退化成完全的盲目搜索，复杂性就是8的8次方了。

3.3 算法设计2—非递归回溯算法

算法1的枚举算法可读性很好，但它只能解决八皇后问题，而不能解决任意的n皇后问题。因此不是通用的回溯算法。下面的非递归算法可以说是通用的n皇后问题算法模型。

3.3.1算法2设计

t a[20],n;

Main2（）

{ input(n); bckdate（n）;} //初始化，输入皇后数目

backdate (int n) //该函数是用来寻找满足约束的全部解

{ int k;

a[1]=0; k=1; //k用来表示第k个皇后

while( k>0 )

{a[k]=a[k]+1;

while ((a[k]<=n) and (check(k)=0)) //搜索第k个皇后位置

a[k]=a[k]+1;

if（a[k]<=n）

if(k=n ) output(n); //找到一组解/

else {k=k+1; //继续为第k+1个皇后找到位置/

a[k]=0;} //注意下一个皇后一定要从头开始搜索/

else k=k-1; //回溯

}

}

check(int k)//检查皇后是否满足约束

{ int i;

for(i=1;i<=k-1;i++)

if (abs(a[i]-a[k])=abs(i-k)) or (a[i]=a[k])

return(0);

return(1);

}

output( ) //输出满足该约束下的一组皇后位置

{ int i;

for(i=1;i<=n;i++)

print(a[i]);

}

3.3.2 算法分析

该算法与枚举法比较，此算法也是对n个数组分别从1到n尝试,因此其时间复杂度为O(nn)。空间复杂度为S(n2).

3.4 算法设计3——递归算法

对于回溯算法，更方便地是用递归控制方式实现，这种方式也可以解决任意的n皇后问题，算法的思想同样用深度优先搜索，在不满足约束条件时及时回溯。

与上面两个算法不同，都是用check（）函数来检查当前状态是否满足约束条件，由于递归调用、回溯的整个过程是非线性的，用check（）函数来检查当前状态是否满足约束条件是不充分的，而用check （）函数（在算法1中说明）来检查当前状态是否满足约束条件又有太多冗余。

这里，我们“利用数组记录状态信息”的技巧，用三个数组c,b,d分别记录棋盘上的n个列、2n-1个主对角线和2n-1个负对角线的占用情况。

3.4.1 算法3设计如下

int a[20],b[20],c[40],d[40];

int n,t,i,j,k; //t记录解的个数，i控制行，j控制列

main( )

{ int i,

input(n); //输入皇后的个数

for(i=1;i<=n;i++)

{ b[i]=0;//记录棋盘n个列

c[i+1]=0; c[n+i]=0;//记录棋盘负对角线

d[i]=0; d[n+i-1]=0;//记录棋盘主对角线

}

try（1）;

}

try(int i)

{ int j; for(j=1;j<=n;j++) //j表示列号，第i个皇后有n种可能位置

if (b[j]=0) and (c[i+j]=0) and (d[i-j+n]=0)//判断位置是否冲突

{a[i]=j; //第i行第j列可以摆放编号为i的皇后

b[j]=1; //占领第j列

c[i+j]=1; d[i-j+n]=1; //占领两个对角线

if (i

try(i+1); //n个皇后没有摆完，

递归摆放下一皇后

else

output( ); //完成任务，打印结果

b[j]=0; c[i+j]=0; d[i-j+n]=0; //回溯，清理现场，从低向上回溯} }

output( )

{ t=t+1;//这里的t只是用来统计满足条件的解

的个数

print(t,' ');

for( k=1;k<=n;k++)

print(a[k],' ');

print(“换行符”);

}

3.4.2 算法说明

递归算法的回溯是由函数调用结束自动完成的，也不需要指出回溯点，（类似算法2中的k=k-1）,但需要“清理现场”——将当前点占用的位置释放，也就是算法try( )中的后三个赋值语句。

4 结果展示

5 结束语

本文给出了求解八皇后的三种算法：枚举算法、递归回溯算法和非递归回溯算法，分析了其执行时间复杂度，并得到了运行结果，得到了从枚举解答八皇后问题到递归回溯解答N皇后问题的最佳解决方案。选择递归回溯法解决八皇后乃至N皇后问题更好，更具实用性。

参考文献

[1]严蔚敏,吴伟民.数据结构.北京:清华大学出版社, 2009:173-178.

[2]吕国英.算法设计与分析[M].北京:清华大学出版,2009:154-165.

[3]殷人昆，数据结构，清华大学计算机系类教材2006,11