从一个策略游戏谈搜索算法优化

从一个策略游戏谈搜索算法优化从一个策略游戏谈搜索算法优化

对于策略游戏性质的二人博弈问题，比如黑白棋，五子棋等，一般的解答方法就是搜索；但搜索算法的原理不同，其性能就大不一样。一般来说，如果我们对问题的本质把握的越深，算法的设计就会相对的复杂，但是效率会高很多。下面我们就通过一个二人游戏来谈这方面的体会。

一.问题的提出

问题：TwoFour[罗马尼亚奥林匹克,via Stroe,2002]

Bessie有一个新的两人游戏：TwoFour.她有N(3=N=30)

堆球,每堆有nballs(0=nballs=4)个.球的总数为2*N.

玩这个游戏时,游戏者轮流执行一个有效移动.一个有效移动由下列动作组成：

*第一,游戏者选择不同的两堆球.

*第二,把一个球从一堆拿到另一堆.她可以这样做的前提是运完球后第二堆

的球数(包括新放上的球)不大于第一堆剩下的球的数目.

当没有移动可做时,游戏结束.实际上,在游戏的末尾,每堆将包含恰好两个球.

游戏的胜者'拥有'多数球堆.平局是可能的.当某堆有两个球并且是由于

某游戏者最近对它的的一次移动(不管移走还是放入)使其变为两个球的,

我们就说她'拥有'这堆球.

看看这些例子：

*如果一个游戏者从有四个球的某球堆中移走一个球,

放到有一个球的某球堆中,那么它拥有了第二堆(有两个球).

*如果一个游戏者从有三个球的某球堆中移走一个球,

放到有零个球的某球堆中,那么它拥有了第一堆,现在这堆有两个球.

*如果一个游戏者从有三个球的某球堆中移走一个球,

放到有一个球的某球堆中,那么它拥有了这两堆(他们都有两个球).

拥有权能够变化.设想一个游戏者拥有两个球的一个球堆,如果另一个

游戏者选了一个有四个球的堆并把一个球移到此两个球的堆中,

那么这堆球谁也不属于了.

如果,在游戏的开头,存在有两个球的一些球堆,那么这些堆被平分给两个游戏者,剩余的堆则分给游戏者2.

游戏者1先移动.

你的程序必须判断,对一个初始的游戏状态,谁将获胜或者会否出现平局. 你的程序将处理G(1=G=1000)个游戏状态.

该问题要求使用不超过1.00 MB的内存.

问题名：twofour

输入格式：

*行1：用空格隔开的两个整数：N和G.

*行2.G+1：每行包含空格隔开的N个整数用于描述该游戏.

第一个整数是堆1的球数,

第二个整数是堆2的球数,

.

行2描述了游戏1,行3描述了游戏2,

.

你的程序应该计算每个特定游戏的胜者.

输入样例(文件twofour.in)：

5 4

0 34 12 22 22 2

1 1

2 24 4

3 21 0

输出格式：

*行1.G：每个游戏的结果.

行1给出游戏1的结果,.

结果是一个整数：1代表第一个游戏者获胜,2代表第二个获胜, 以及0代表平局.

输出样例(文件twofour.out)：

1 2

1 1

二.问题的初步分析和第一种解答

从问题的描述来看，我们可以得到如下的一些基本信息：

1)player1总是先手的，问题也是求player1的胜负情况；player2在瓜分最初的'2'堆的时候具有优先权。

2)整个的游戏过程，就是把不均有分布的堆，逐步均匀化，直至所有的堆

都是'2'堆，由于2N个球，放置在N堆上，这是个必然。

3)'2'堆在游戏过程中会变化成'1'堆或者'3'堆；每堆的球数不超过4，允

许'0'堆。

4)如果两堆之间的球数目差1，就可以进行球的移动，这是我们在程序中

判断可行步的依据。

在上面的基本信息的基础上，我们就要决定用什么搜索算法，用广度优先

搜索还是深度优先搜索呢?

如果用广度优先搜索的话，一般的方法是从根节点出发，平行的推进所有

从根节点衍生出来的子节点，每个节点都要保存当前棋局的状态,同时还要记住父节点的索引；子节点需要父节点的信息来进行衍生，而父节点需要子节点的

结果来决定本节点的结果。一般我们用一个队列来实现这个过程；由于所有的

节点都需要保存，一些废节点也被保存了，而对于奇偶深度的节点的处理还不

一样(奇偶深度，对应player1还是player2)，下面会具体讲到，节点所要保

存和处理的信息都比较复杂，另外针对这个问题的广度优先搜索的剪枝工作也

是个问题，因为广搜的处理方式是先把子节点全部入队列，然后从队头逐个再

扩展，一些无用的节点就占用了宝贵的队列空间。比如player1的任何一步移动，只要能胜利，其它方式的移动都不需要考虑了；然而对于走法的判断是在

所有子节点入队之后，所以其他废节点就占用了多余的空间。综合上面的讨论，我认为本问题不太适合使用基于广度优先搜索的算法。

下面考虑深度优先搜索。深度优先搜索有一个好处就是占用的空间少。先

讲讲我们的思路，请大家注意对于player1和player2的处理的不同。

1)我们对所有棋局的考虑都以player1为中心，不论当前棋局是由

player1的移动还是player2的移动造成的.

2)如果相对与当前棋局，对于player1的所有移动中，有一种能导致

player1胜利，则当前节点就能导致player1胜利，也就是不需要再扩展了,直

接返回结果到上层父节点；如果对于player1的所有移动，全都导致player1

失败，才能说本节点导致player1失败；如果没有走法能胜利，但有一种走法

能使得player1和局，那么player1会选择和局。

3)同样的道理，如果相对与当前棋局，对于player2的所有移动中，有一

种能导致player2胜利，则当前节点就能导致player1失败，也就是不需要再

扩展了，直接返回结果到上层父节点；如果对于player2的所有移动，全都导

致player2失败，才能说本节点导致player1胜利；如果没有走法能使得

player2胜利，但有一种走法能使得player2和局，那么player2会选择和局，也就是导致player1和局。

4)由于player1先手，从初始棋局出发，逐个扩展出子节点，并递规的调

用自身来扩展子节点，直到无法再深度扩展为止。

下面来看我们的第一个版本的解答。

#define QMAX 30 typedef struct{

int qn；//球的个数

int owner；//所有者，0：没有所有者,1：属于player1,-1：属于

player2

}sq_str；

//上面的数据结构用来描述'堆'的属性。

sq_str a[QMAX]；//用来描述棋局状态

int n；//记录堆的个数，全局变量

int depthmax=-1；//用来记录最深的递规深度，以便了解堆栈内存的使用

使用下面的代码得到输入，当然后面我们会讨论随机生成棋局的方式，初始的棋局在这里就准备好

void test1()

{

int i,j；

int G,c；

scanf("%d%d",&n,&G)；

for(i=0；i G；i++)

{

c=0；

for(j=0；j n；j++)

{

scanf("%d",&a[j].qn)；

if(a[j].qn==2)

{

if((c&1)==0)a[j].owner=-1；//由player2所有

else a[j].owner=1；//由player1所有

c++；

}

else a[j].owner=0；//无人所有

}

depthmax=-1；

c=qiuv0(0)；

printf("result：%d.depthmax=%d.\n",c,depthmax)；

}

}

//求解棋局的函数，胜负是指player1的胜负。depth表示当前迭代的深度，同时也表示当前执子的玩家，depth为偶数，表示player1执子，depth为奇数，表示player2执子。

//返回1：胜利，-1：失败,0：和局

int qiuv0(int depth)

{

int i,j,k=0,s,tx=0；

int ret0；

int fu=0；//会导致player1失败的节点的个数

int shen=0；//会导致player1胜利的节点的个数

sq_str savei,savej；

if(depth depthmax)depthmax=depth；

for(i=0；i n；i++)

{

for(j=0；j n；j++)

{

if(a[i].qn-a[j].qn 1)//判断可行移动步的标准，从第i堆到第j堆{

k++；//记录子节点的个数

//保留被修改的堆，方便以后恢复

savei=a[i]；

savej=a[j]；

a[i].qn--；

a[j].qn++；

if(a[i].owner)a[i].owner=0；

if(a[j].owner)a[j].owner=0；

if(a[i].qn==2)

{

if((depth&1)==0)a[i].owner=1；

else a[i].owner=-1；

}

if(a[j].qn==2)

{

if((depth&1)==0)a[j].owner=1；

else a[j].owner=-1；

}

ret0=qiu(depth+1)；//递规调用

//恢复被修改的棋局

a[i]=savei；

a[j]=savej；

//请大家注意下面的不同处理，所有的胜负都是对于player1来说的if((depth&1)==0)//player1的局势

{

if(ret0==1)return 1；

else if(ret0==-1)fu++；

}

else//player2的局势

{

if(ret0==-1)return-1；

else if(ret0==1)shen++；

}

}

}

}

if(k==0)//如果没有子节点可以扩展，那么这是个终局{

for(i=0；i n；i++)

k+=a[i].owner；

if(k==0)return 0；

if(k 0)return 1；

if(k 0)return-1；

}

else//否则是扩展了子节点的

{

if((depth&1)==0)

{

if(fu==k)return-1；//所有的走法都导致输

else return 0；//至少有一种走发可以保证平局

}

else

{

if(shen==k)return 1；//player2所有的走法都导致player1胜利

else return 0；//player2会选择平局

}

}

}

三.初步的优化和剪枝

好了程序很简单，应该很容易理解，但是效率也很低！下面我们来逐步分析优化，看看问题在哪里。

首先我们发现，同层扩展出的各棋局的状态只和各堆的状态有关，而和各堆的排列没有关系，所以在同一层我们就可以进行剪枝，把那些本质上是一样的子节点剪掉。

考虑所有的走法一共有8种：4-2(-1,1),4-1,4-0,3-1,3-0,2(-1,1)-0,括号里的数表示'2'堆的归属情况。新的程序如下：

int qiuv1(int depth)

{

int i,j,k=0,s,tx=0；

int ret0；

int fu=0；

int shen=0；

sq_str savei,savej；

sq_str tt[8][2]；//一共有8种不同的移动方式

int re[8]；//8种移动方式带来的结果

int ti=0；

if(depth depthmax)depthmax=depth；

for(i=0；i n；i++)

{

for(j=0；j n；j++)

{

if(a[i].qn-a[j].qn 1)

{

k++；

for(s=0；s ti；s++)

{

if((a[i].owner==tt[s][0].owner)&&(a[i].qn==tt[s][0].qn)&&(a[j].ow ner==tt[s][1].owner)&&(a[j].qn==tt[s][1].qn))

break；

}

if(s！=ti)

{

ret0=re[s]；

if((depth&1)==0)//player1的局势

{

if(ret0==1)return 1；else if(ret0==-1)fu++；}

else//player2的局势

{

if(ret0==-1)return-1；else if(ret0==1)shen++；}

continue；

}

else

{

tt[ti][0]=a[i]；

tt[ti][1]=a[j]；

}

savei=a[i]；

savej=a[j]；

a[i].qn--；

a[j].qn++；

if(a[i].owner)a[i].owner=0；

if(a[j].owner)a[j].owner=0；

if(a[i].qn==2)

{

if((depth&1)==0)a[i].owner=1；else a[i].owner=-1；

}

if(a[j].qn==2)

{

if((depth&1)==0)a[j].owner=1；else a[j].owner=-1；

}

ret0=qiu(depth+1)；

re[ti]=ret0；

ti++；

a[i]=savei；

a[j]=savej；

if((depth&1)==0)//player1的局势

if(ret0==1)return 1；else if(ret0==-1)fu++；}

else//player2的局势

{

if(ret0==-1)return-1；else if(ret0==1)shen++；}

}

}

}

if(k==0)

{

for(i=0；i n；i++)

k+=a[i].owner；

if(k==0)return 0；

if(k 0)return 1；

if(k 0)return-1；

else

{

if((depth&1)==0)

{

if(fu==k)return-1；//所有的走法都导致输

else return 0；//至少有一种走发可以保证平局

}

else

{

if(shen==k)return 1；//player2所有的走法都导致player1胜利

else return 0；//player2会选择平局

}

}

}

四、进一步的优化和剪枝

经过上面的优化，程序的性能有所提升，但是还不够快，问题出在哪里呢?我们知道深度优先搜索的一大缺点就是对已有的计算结果没有继承，造成了大量的计算浪费；qiuv1已经做了一点工作，但还不够；我们需要记录所有的已经访问过的棋局和相应的结果，方便在后续的搜索中进行剪枝。这就需要对以往结果的记录。

定义如下数据结构：

#define STAMAX 11000 unsigned char x_sta[STAMAX][8]；//player1的2就在[2]，player2的2在[5],局势的结果放在[7],depth的奇偶性放在[6]里

int x_inx=0；//x_sta中的下一个空位置

我们知道棋局只和堆本身有关，而和堆的排列顺序无关，进一步，两个相同的堆也是无区别的，这样我们只需要记录一个棋局中'0'堆的个数，'1'堆的个数,'2(1)'堆的个数，'2(-1)'堆的个数,'3'堆的个数，'4'堆的个数，以及当前棋局对应的执子方，这种棋局的结果。由于最多也就30堆，所以1个字节足以存放相关的信息。算算上面的空间才不到90KB，离1MB尚远。

还有一个问题，那就是棋局的对偶性，棋局A的对偶棋局，就是把depth 的奇偶性取反，把相应的'2'堆的归属性取反，相应的棋局结果自然取反。这个很容易理解，相当与player2和player1交换位置，下对方的棋。这样我们每求得一个棋局，实际上是得到了两个棋局的结果。

好了还是看看新程序吧.

int qiuv2(int depth)

{

int i,j,k=0,s,tx=0；

int ret0；

int fu=0；

int shen=0；

int old_xinx；

unsigned char x[7]；

sq_str savei,savej；

if(depth depthmax)depthmax=depth；for(i=0；i n；i++)

{

for(j=0；j n；j++)

{

if(a[i].qn-a[j].qn 1)

{

k++；

memset(x,0,7)；

savei=a[i]；

savej=a[j]；

a[i].qn--；

a[j].qn++；

if(a[i].owner)a[i].owner=0；

if(a[j].owner)a[j].owner=0；

if(a[i].qn==2)

{

if((depth&1)==0)a[i].owner=1；else a[i].owner=-1；

if(a[j].qn==2)

{

if((depth&1)==0)a[j].owner=1；else a[j].owner=-1；

}

for(s=0；s n；s++)

{

if(a[s].qn！=2)

x[a[s].qn]++；

else

{

if(a[s].owner==1)x[2]++；

else x[5]++；

}

}

x[6]=depth&1；

//开始搜索以前保存的结果

for(s=0；s x_inx；s++)

if(memcmp(x,x_sta[s],7)==0)break；}

if(s！=x_inx)//找到了！

{

a[i]=savei；

a[j]=savej；

ret0=(char)x_sta[s][7]；

if((depth&1)==0)//player1的局势{

if(ret0==1)return 1；

else if(ret0==-1)fu++；

}

else//player2的局势

{

if(ret0==-1)return-1；

else if(ret0==1)shen++；

}

continue；