导航:首页 > 源码编译 > 象棋开源算法

象棋开源算法

发布时间:2022-07-01 06:01:00

㈠ pascal 中国象棋 Alpha-Beta算法源程序及解释

Alpha值代表的是发起走棋一方(期望极大值)做能接受的最小值,搜索极大值一方必须要找到一个比Alpha值更大的,否则这步棋就没有任何意义
Beta值代表的是对手(期望极小值)所能接受的最坏值,搜索极小值的一方必须找到一个比Beta值更小的一步棋,否则也是没意义的(因为有更好的一步棋已经生成了)

先看函数调用方式
int AlphaBeta(int depth, int alpha, int beta);

AlphaBeta(5, -INFINITE INFINITE);
这是发起走棋一方(搜索极大值的一方)调用的,因此设定为alpha为
-INFINITE;

这里假设是采用负极大值算法的

int AlphaBeta(int depth, int alpha, int beta)
{
if(depth == 0 || IsGameOver()) return Evaluate(); //如果层数为0或者已达最终状态则返回本步棋的估值
for(each possible move)
{
MakeMove();

int val = -AlphaBeta(depth - 1, -beta, -alpha);
UnMakeMove();

if(val >= beta)
{
return val;
//注意,这里需要返回val,因为上一层应该知道具体搜索到的值,以配合各种Alpha-Beta算法的变种
}
if(val > alpha)
{
alpha = val;
...
//当然 这里还需要记录这步最佳的走法
}

}
return alpha;//返回最好的值
}

首先假设是负极大算法,
Alpha值是父节点(非root)能搜索到的最大值,任何比他小的值都没意义。
Beta值是你所能找到的最坏的一种情况,任何比它大的都没意义。
{
int val = -AlphaBeta(depth - 1, -beta, -alpha);
}
注意这个所谓的负极大的估值函数是估算本方的最优值,所以你的对手(子节点)估算出来的最优值如果大于你的-Beta
例如-beta == 3 子节点估值== 4,那么他实际上返回后(取负得-4)是小于你的Beta,所以它是有意义的。再看这个-alpha,
实际上是本层的beta是上一层节点(对手)的最大值的负值,如果任何本层节点取值,例如-alpha == 3,子节点估值为4,
4 >= 3,那么返回的是-4,-4< -3(alpha那个地方),所以无意义,因为在本层所有节点又都是越取越大(负极大),
所以本层也就没必要找了,直接剪枝了

㈡ 象棋软件如何开发的

先弄明白数据的结构:
MantisChessDef.h里的东西一定要先看一下, 否则会摸不到头脑的。
还有棋盘坐标:
象棋棋盘大小9x10,为了便于编程,规定棋盘每条边留有一个元素的边界。
这样棋盘大小(包括边界)变成11x12。棋盘x坐标轴向右,y轴向下。
黑棋永远在上方,在标准开局时左上角的黑车坐标是(1,1)。

局面用这三个变量表示:

static POINT g_pointChessman[32]; //棋子坐标
static int g_iChessmanMap[11][12]; //棋位状态
static int g_iSide; //轮到哪方走

智能部分有几个函数的前三个参数就是这个东西, 应该不难理解吧?

---------------------------------------------------------------------------------------
search函数:

先说明一下, 经常有朋友问我要原理, 但我公开源代码是给大家一个参考, 而不是什么教程,所以我不想说那些理论的东西。
基本原理是α-β搜索, 很多人工智能的教科书上都有讲到, 没看过的的赶快去找一本来啃一啃;
虽然这些书上的文字大多晦涩难懂,但毕竟讲得明明白白。
没有书的朋友请发挥一下主观能动性, 去找一找,不要来问我要, 因为我也没有。

我在这里只分析一下search函数:

弄懂α-β搜索后来看看这个博弈树, 看怎么编程实现它。

先规定一下, 我们用一个整数表示局面的好坏.
这个数越大说明局面对 "走棋方" 越有利,0表示双方实力相等。

1a( 1) ┬ 2a(-1) ┬ 3a(-1)
│ └ 3b( 1)
└ 2b(-5) ┬ 3c( 2)
├ 3d(-4)
└ 3e( 5)

分析一下这棵树,有这么个特点: 父结点的值 = -MAX(子结点的值)

我们还知道1、每个结点对应一个局面。2、底层的结点的值是"估"出来的。

于是我们可以写出伪代码了:

伪代码: 搜索一个结点下的分支, 得到这个结点的值。

参数: 局面,搜索深度

返回值:结点的值

int search(局面,int depth)
{
if(depth!=0)//不是底层结点
{

枚举出所有子结点(列出所有走法);

int count=子结点数;
int maxvalue= -∞;
for(int i=0;i<count;i++)//遍历所有结点
{
算出子结点局面;

maxvalue=max(maxvalue,search(子结点局面,depth-1));
}
return -maxvalue;
}
else //是底层结点
{
return 估计值;
}
}

这就是搜索算法的框架, 用到了递归。
MantisChess的智能部分函数都在MantisChessThink.cpp里, 其中search是搜索, 跟上面的这个search差不多,我把它出来注释一下:

int Search(int tmap[11][12],POINT tmanposition[32],int &tside,int man, POINT point,int upmax,int depth)
{

//前面的三个参数就是局面。
//man 和point 是走法,用来计算本结点的局面。 这里是把计算局面放在函数的开头,跟上面的伪代码不太一样。
//upmax: up - 上一层, max - 最大值, 这是α-β的剪枝用到的东西, 后面再讲。
//depth: 搜索深度

int ate,cur,maxvalue,curvalue,xs,ys;
int count;

//#####################这一段是计算本结点的局面#########################################
ate=32;
//移动棋子:
xs=tmanposition[man].x;ys=tmanposition[man].y; //原坐标
if (SideOfMan[tmap[point.x][point.y]]==!tside) //目标点有对方的棋子
{
ate=tmap[point.x][point.y]; //记录下被吃掉的棋子
if(ate==0 || ate==16)
{
return 9999;
}
tmanposition[ate].x=0; //目标点的棋子被吃掉
}

tmap[point.x][point.y]=man; //这两行是:
tmap[xs][ys]=32; //在map上的移动
tmanposition[man]=point;
tside=!tside;
//####################################################################################

depth--;

if(depth>0) //不是底层结点
{
int chessman[125];
POINT targetpoint[125];
if(EnumList(tmap,tmanposition,tside,chessman,targetpoint,count)) //枚举出所有子结点(列出所有走法)
{
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//这里是剪枝(不是α-β剪枝), 原理是在正式搜索之前先用较浅的搜索来得到误差较大的值
//然后根据这些值来对子结点排序, 只保留最好的S_WIDTH个结点进行正式搜索。
//显然,这个剪枝有一定的风险

if(depth>=2 && count>S_WIDTH+2)
{
int value[125];
cur=0;
maxvalue=-10000;
while(cur< count)
{
curvalue=Search(tmap,tmanposition,tside,chessman[cur],targetpoint[cur],-10000,depth-2);
value[cur]=curvalue;
if(curvalue>maxvalue)maxvalue=curvalue;
cur ++;
}
::Mantis_QuickSort(value,chessman,targetpoint,0,count-1); //排序
count=S_WIDTH;//剪枝
}
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

maxvalue=-10000;
cur=0;
while(cur< count)
{
curvalue=Search(tmap,tmanposition,tside,chessman[cur],targetpoint[cur],maxvalue,depth);
if(curvalue>maxvalue)maxvalue=curvalue;
if(curvalue>=-upmax)goto _ENDSUB; //α-β剪枝, 符合剪枝条件的就Cut掉。 这里用了goto语句了, 千万别学我。
cur ++;
}
}
else maxvalue=9800;
}
else //是底层结点
{
maxvalue=Value(tmap,tmanposition,tside); //估值
}

_ENDSUB:

//返回之前要恢复父结点的局面
//####################################################################################
tmanposition[man].x=xs; //这两行是:
tmanposition[man].y=ys; //在face上的恢复
tmap[xs][ys]=man; //在map上的恢复
if(ate!=32)
{
tmanposition[ate]=point;
tmap[point.x][point.y]=ate;
}
else tmap[point.x][point.y]=32;

tside=!tside;
//####################################################################################

return -maxvalue;
}

上面的代码用到了α-β剪枝, 举个例子就明白了:

还是这个博弈树,从上往下遍历。

1a( 1) ┳ 2a(-1) ┳ 3a(-1)
┃ ┗ 3b( 1)
┗ 2b(-5) ┯ 3c( 2)
├ 3d(-4)
└ 3e( 5)

2a遍历完后 upmax=-1, 继续遍历完3c后返回2b, 发现3c=2>-upmax, 这时就不用管3d和3e了, 因为无论他们的值是多少 2b=-max(3c,3d,3e)<2a 一定成立,
也就是说2b可以安全地剪掉。这就是α-β剪枝。

从上面的代码来看我的MantisChess算法与标准的α-β剪枝搜索并没有什么不同, 只不过加了排序和剪枝而已。

㈢ 天机象棋是否抄袭或者说是引用国际象棋开源代码

目前国内象棋软件几乎均引用或抄袭国际象棋的开源代码,天机也不例外。以往只为算法的不公开,也没有开源代码,所以中国象棋软件的发展很慢,自主研发的也多来自宝岛台湾。近几年来,随着国际象棋软件代码的开源,所以大陆在此领域才得以发展。
综上所述,天机“借鉴”国际象棋的代码,几乎是肯定的。

㈣ 中国象棋算法

对于中国象棋,每一个字都有自己的规则,正所谓无规矩不成方圆。

棋盘先设定好,a:array[1..10][1..9] of MapStruct;
是个二维数组,每个单元符全自定义的棋盘结构
不要定义一个棋字结构

int StepJudge(int oldx,int oldy,int nowx,int nowy)

/* oldx,oldy 棋字原来位置 */
/* oldx,oldy 棋字新位置 */
/* 判断从原位置到新位置的合法性 */
{
int index,count=0;
int nox,noy;
int x,y,x1,x2,y1,y2;
BYTE ChessId; /* 棋字是哪一方的,有RED,BLUE,NONE三种值 */
ChessId=map[oldx][oldy].Id;
if(ChessId==NONE) return 0;
if(oldx==nowx&&oldy==nowy) return 0;
if(nowx>8||nowx<0||nowy<0||nowy>9) return 0;
nox=nowx-oldx;noy=nowy-oldy;
switch(map[oldx][oldy].num)
{
case 0:/*HeaderCapital*/将或帅
{
if(map[nowx][nowy].num==0&&map[nowx][nowy].Id!=NONE&&oldx==nowx)
{
/*Face to Face*/
y1=oldy;y2=nowy;
if(nowy<oldy) Swap(&y1,&y2);
for(y=y1+1;y<y2;y++) if(map[nowx][y].Id!=NONE) count++;
if(count==0) return 1;
}
if(abs(nox)>1||abs(noy)>1||abs(nox)==1&&abs(noy)==1) return 0;
if(nowy>2&&nowy<7||nowx<3||nowx>5) return 0;
break;
}
case 14: case 15:/*Genaral*/车
{
if(abs(nox)!=0&&abs(noy)!=0) return 0;
if(abs(nox)>1&&noy==0)
{
x1=oldx;x2=nowx;
if(nowx<oldx) Swap(&x1,&x2);
for(x=x1+1;x<x2;x++) if(map[x][nowy].Id!=NONE) return 0;
}
if(nox==0&&abs(noy)>1)
{
y1=oldy;y2=nowy;
if(nowy<oldy) Swap(&y1,&y2);
for(y=y1+1;y<y2;y++) if(map[nowx][y].Id!=NONE) return 0;
}
break;
}
case 10: case 11:/*Horse*/马
{
if(abs(nox)==2&&abs(noy)==1||abs(nox)==1&&abs(noy)==2)
{
if(abs(nox)==1&&map[oldx][oldy+noy/2].Id!=NONE) return 0;
if(abs(nox)==2&&map[oldx+nox/2][oldy].Id!=NONE) return 0;
break;
}
else return 0;
}
case 12: case 13:/*Gun*/炮
{
if(abs(nox)>0&&abs(noy)>0) return 0;
if(abs(nox)>0&&noy==0)
{
x1=oldx;x2=nowx;
if(nowx<oldx) Swap(&x1,&x2);
for(x=x1+1;x<x2;x++) if(map[x][nowy].Id!=NONE) count++;
}
else if(nox==0&&abs(noy)>0)
{
y1=oldy;y2=nowy;
if(nowy<oldy) Swap(&y1,&y2);
for(y=y1+1;y<y2;y++) if(map[nowx][y].Id!=NONE) count++;
}
if(count==0&&map[nowx][nowy].Id!=NONE) return 0;
if(count==1&&map[nowx][nowy].Id==NONE) return 0;
if(count>1) return 0;
break;
}
case 3: case 4:/*Minister*/象或相
{
if(abs(nox)!=2||abs(noy)!=2) return 0;
else if(map[oldx+nox/2][oldy+noy/2].Id!=NONE) return 0;
if(nowy==0||nowy==4||nowy==5||nowy==9)
if(nowx==2||nowx==6) break;
if(nowy==2||nowy==7)
if(nowx==0||nowx==4||nowx==8) break;
}
case 1: case 2:/*Shi*/士或仕
{
if(abs(nox)!=1||abs(noy)!=1) return 0;
if(nowy>2&&nowy<7||nowx<3||nowx>5) return 0;
break;
}
case 5: case 6: case 7: case 8: case 9: /*Soldier*/兵或卒
{
if(abs(nox)>0&&abs(noy)>0) return 0;
if(ChessId==GREEN&&GreenChess[0].y<3||ChessId==RED&&RedChess[0].y<3)
{
if(oldy>4)
{
if(nox==0&&noy!=1) return 0;
if(abs(nox)!=1&&noy==0) return 0;
}
if(oldy<5) if(nox!=0||noy!=1) return 0;
}
if(ChessId==GREEN&&GreenChess[0].y>6||ChessId==RED&&RedChess[0].y>6)
{
if(oldy<5)
{
if(nox==0&&noy!=-1) return 0;
if(abs(nox)!=1&&noy==0) return 0;
}
if(oldy>4) if(nox!=0||noy!=-1) return 0;
}
index=map[oldx][oldy].num;
if(ChessId==GREEN)
if(GreenChess[0].y<3&&GreenChess[index].y>4||GreenChess[0].y>6&&GreenChess[index].y<5)
GreenChess[index].FixLevel=ADVANCED_SOLDIER_LEVEL;
if(ChessId==RED)
if(RedChess[0].y<3&&RedChess[index].y>4||RedChess[0].y>6&&RedChess[index].y<5)
RedChess[index].FixLevel=ADVANCED_SOLDIER_LEVEL;//兵过河后等级值加1
break;
}
}
if(ChessId==map[nowx][nowy].Id) return 2;
else return 1;
}

用c语言写的

㈤ 中国象棋AI实现

喜欢下象棋的朋友都知道,象棋的博弈更像是一场坚持到最后才是胜利的游戏。阿尔法狗和柯洁的国际象棋的博弈在当时可以是引起了一场轰动的,人工智能的出现更是改变了很多东西。这应该算是一个重大突破,在一个以人为智力博弈的游戏中,AI的出现的对决是一场突破人的游戏,机械人自然人的智商,其实也在说明了时代的大潮流发展,未来的世界的正朝着新领域去发展。

我们知道如果从计算机统计的步数的复杂和空间的复杂上来讲,相对来说搜索比较容易实现了,只要模拟一下博弈树,再进行极大值和极小值的搜索 + 剪枝,难么一个DFS就完成了。 举个例子,我们都知道,每一步有很多多子可以走,每一个子有那么多步可以走。如果要思考很多层,那博弈树就太大了。

这两块算法写出能跑的不难,写出能PK过自己的AI也不难,但要真的要写好是个巨大的坑,要量化自己算法的好坏就是和开源算法进行对弈,在相同开销下比胜率,或者胜率相同比开销。



㈥ 象棋软件引擎分析,详细信息,引擎是怎么搜索招式的

作者:nicepeople10

中象棋软搜索引擎揭密(一) fenon
北京大赛终于过去了, 在这场盛事前后这段时间, 静下心来回顾了走过的象棋研究的路子,心得感触良多.为了纪念这段时间的美好, 我决定把这段时间积累的对象棋引擎的心得, 总结分享出来
我个人希望通过这篇文章,把一些顶尖棋软的知识普及开来,提高开源象棋软件的水平.

1. 搜索引擎和审局之间的关系, 如何建立

阅读下面的内容时, 首先需要了解几个背景知识
a. 人工智能的博弈搜索树和PVS搜索之间的关系
b. PVS搜索是无损搜索
c. PVS的搜索效率和搜索次序的关系

首先明确几点:

a. 做一个全PVS的搜索, 在限定了层数的情况下, 如果基于不正确的知识(比如子力表),并不能保证一定能把杀棋找出来(可能会跑去吃子)
b. 为了提高棋力, 无损搜索PVS是不足够的, 还是需要剪枝的
c. 搜索树和审局之间的关系, 首先知识必须能够引导搜索到正确盘面(这个地球人应该都知道), 第二是避免搜索把正确的分支剪除掉(这个谈论得少一些,我以前曾经有很长一段时间不知道)
我认为, 审局和搜索之间的关系的建立, 在于
a. 知识是带有正确的倾向性的(只能说是倾向性,因为知识很难做到全面准确)
b. 搜索是根据知识而采取剪枝方式的(这个下面详细分析)

下面我举一个简单的例子, 来说明知识和搜索之间的关系


_____
| | |
马 _| 将_|_兵
| _ |_ |_ |_象

在这个盘面, 兵只要靠近王一步, 就可以将死了对方, 但是基于子力表做depth=1的PVS搜索,只会选择: 兵吃象, 有利, 而且评估子力分数很高, 所以吃象

那么, 有什么办法避免这种情况呢?

a. depth=1的时候不做剪枝
b. 给予引擎审局的知识, 告诉引擎保持"马非底线兵"这种组合对将才具有杀伤力

这样就给出了两种选择, 哪种更好?

实际上, b这种选择有两种局限
a. 局限于现在对审局模型建立的水平, b这种情况需要花费大量的人力功夫来维护完整的知识, 而且很难做到准确
b. 目前的引擎的搜索棋步排序, 大都是基于最近访问->杀棋步->吃子步这样的棋步排序方法, 我们可以很容易想象到, 使用全面复杂的知识, 会引起搜索结果冲突(凑着一个吃子或者杀棋的步子去走, 但是最后发现达不到预期的效果), 大大降低了搜索的效率

正是因为上面的原因, 现在我所了解到的高端引擎, 大都是通过控制剪枝的危险程度, 来弥补知识的不足, 比如, 在nullmove中限制depth>=2, 或者, 在lmr(late move rection)--如变种:fruit的history pruning, 控制depth>=3, 都是利用控制剪枝来弥补知识的缺陷.

我们很清楚知道, depth<=2的时候, 都限制了不能剪枝的话, 那么刚才的盘面, 并不需要任何知识,就可以找出杀棋步, 但是, 这个是不是我们需要的呢? 我想不是的, 如果限制了depth<=2不能剪枝的话, 我们会发现我们的搜索, 产生了大量的节点, 啊, 天啊, 可怕的搜索浪费

当然, 最理想的方法是, 搜索排序的次序是基于知识的, 而且盘面评估是基于知识的, 如果我们能够达到这样的效果, 嗯, 我想depth<=1不剪枝的限制也可以去掉了, 这样的引擎肯定效率更高吧

现在, 让我们想想, 哪些分支我们是不想被错误剪掉的? 当然是杀棋步, 杀棋>吃子, 基于子力表的搜索PVS, 很可能漏掉的棋步是杀棋步, 而这个恰恰是我们不想见到的
对于攻杀激烈的中国象棋,可以说两个引擎的差别在于,谁能更快更准确找到杀棋步.

口语化一点来说,给你多搜索两层的能耐,你能保证绝对能通过蚕食我的大子把我变成光棍司令? 尤其是随着高层效应的出现(引擎和硬件的发展,搜索的层数越来越大), 这种可能更是趋向于零, 所以, 我们应该尽量避免漏掉杀棋步

我知道有很多引擎的做法是, 对有潜在攻势的局面做出模糊判断, 并且赋予高分, 如越容易发生杀棋的棋步, 给予越高的分数, 例如三子归边的分数>马炮的分数, 这样就可避免因为吃马炮而漏掉杀棋, 但是这种模糊判断有些致命的缺点
a. 模糊知识,会造成大量的搜索浪费(条件越不准确, 越容易造成搜索浪费)
b. 模糊知识会造成错误的判断, 导致乱弃子
c. 引擎发展需要更长的发展周期, 需要大量的对局来积累知识

一种比较适中的解决方案是, 采取depth<=1不剪枝的搜索方法, 并且给予depth=1时候, 可以形成杀棋的棋型知识的判断
这种方法的原理是, depth=1的搜索,可以达到depth==2的效果, 并且可以避免模糊知识判断带来的误搜索的缺陷

这种解决方案的优点在于
a. depth=1可以生成杀棋的知识可以穷举
b. 知识准确度高,可以大幅度减少搜索浪费

缺点在于, depth=1可以形成的杀型, 覆盖面有限, 剩下的知识, 还是需要通过一些模糊判断来补充, 当然, 这种补充少很多了, 而且完善起来也难度降低很多

上面的介绍可以说是知识模型的缺陷造成的对搜索的依赖, 下面我再来说说, 知识对搜索产生的影响

我们假设有一个盘面, depth=11的PVS全搜索才能发现杀棋, 那么下面的知识, 做depth=10搜索时,哪种才能走出正确的棋步呢?

a. 对depth=1情况可杀棋的知识评估
b. 对depth>=2情况可杀棋的知识评估
c. 子力组合(如单车单王胜单王)和子力优势
d. 位置分(不是子力表,只是位置的分数,如灵活度等)

实际上我们很容易就可以判断出来, depth=1的知识评估,能走出正确的棋步,情况b也可能走出正确的棋步, 但是会有一定的误判, c, d大都情况下, 走不出正确的棋步

我们现在对所有的知识打分, 这个分数依赖的因素应该是(depth, 准确度, 搜索浪费), 即score=形势*(准确度/(depth*搜索浪费))

因为用评估盘面希望得到的分数等于depth>3的棋步, 准确度是相当低甚至会引起大量错误的, 所以我们对盘面评估会有一定的限度,同理,评估depth=1变化内的盘面,我们可以做到非常精确,这个时候可以给一个准确的分数

上面提到的a,b,c,d四种知识,对中国象棋软件的知识覆盖面是相当广了, 我们可以很简单看出, a可以奖励>马炮的分数, 而b因为可能走入误区, 常常只是奖励>士相的分数, 子力组合不会产生误区,但是需要搜索很深才能得出正解,所以分数也是不会太高,位置分则更小了

但是, 给予引擎全面而准确的知识是否恰当呢? 即, 知识是不是越全面, 棋力越强呢? 很多朋友都问过这个问题, 并且认为恰当的知识会减少搜索量, 而且这也是很多朋友追求的方向. 我实践的答案是否. 搜索其实是追求一种性价比, 单位搜索量内, 能得到最好的搜索结果, 才是好的搜索. 简单说说原理, 当盘面有两三个知识倾向都可以产生PV路径的时候, 只会带来引擎的左右徘徊, 尤其在杀棋的盘面, 会大大降低搜索的效率, 这部分的实践结果, 我会在"6. 建立以kingsafety为核心的审局, 以及审局模型的详细分析"再进一步详细分析

这里我想纠正一个错误的想法,常常有一些不了解搜索引擎原理的朋友,拿一些盘面,让棋软去判断,看谁能更快更准找到正解,要尽快解出这种盘面,往往需要大量的模糊知识,或者足够的深度,前者无疑是把棋软送上绝路的一种做法.这种评估只是有一定的意义,但绝对不是衡量棋软水平的标准.

2. fruit引擎分析, fruit引擎能达到2600的高度的原因 (对比crafty进行阐述)

fruit引擎并不追求速度,实际上,fruit并没有使用流行的bitfile,bitrank技术或者bitboard,所以fruit的nps在国际象棋引擎中并不算高(我想比起crafty应该比不上),如果说两者的差异在于评估的话,嗯,那不在我所了解的范围,我只谈谈两者引擎上面的差别

a. fruit的pv节点的意义以及基于pv节点搜索剪枝的效率
能够在搜索中, 把PV节点区分出来, 并且根据节点类型进行剪枝, fruit可以说对PVS理解是非常深刻的.

PV节点的定义大家可以查查相关资料, 既然PV节点表示正确的搜索结果, 那么就肯定不应该剪掉. 同样,对于不是PV节点的, 就不会找出正确的搜索路径, 这就应该剪掉.这个也是fruit剪枝的理论依据。

道理是这样说, 但是我们一开始并不知道每一个节点的类型, 所以在搜索的时候, 会假设某个节点不是PV节点, 然后看它是否会fail, 如果fail,再做PV节点的搜索.

假如这种假设是成立的, 那么就成功完成了对该非PV节点路径的剪枝,否则,需要重新搜索,因为对PV节点假设判断的搜索是做windows=1的搜索,所以耗费的代价是很低的.

下面来看看fruit的实现方法,我认为fruit对PV节点理解的实现方法非常优雅.

int search_root()
{
本节点做PV搜索

if (树根节点并且首节点)
下一层节点为PV节点 // 这个时候还没有找出PV路径,所以必须做PV节点搜索
else
{
下一层节点做假设不是PV节点的搜索
if (fail)
下一层节点做PV节点的搜索
}
}
int search_full()
{
根据上一层对该节点的判断, 进行节点搜索

if (首节点 || 假设不是PV节点的搜索) // 当假设不是PV节点时, windows=1这个时候不应该假设,应该直接计算了,否则就是重复计算浪费时间
下一节点的节点类型跟本节点类型一致
else
{
下一层节点做假设不是PV节点的搜索
if (fail)
下一层节点做PV节点的搜索
}
}

中象棋软搜索引擎揭密(二) fenon
crafty中,对PV节点的区分方法,是PV节点是否落在[-vMate,+vMate]中,实际上,这种判断方法,对子树的PV节点并不能做出有效的判断,这也直接导致了搜索效率的下降

正是因为PV节点的特殊意义,所以凡是PV节点,fruit都不做剪枝,不从HASH取步,甚至PV节点还需要加强搜索的强度(参考TogaII)

b. fruit的nullmove剖析

我们先来看看fruit的nullmove的实现
if (UseNull && depth >= NullDepth && node_type != NodePV) { // 不对PV节点进行剪枝, 而且depth==1时不剪枝(原因参考上文)

if (!in_check // 不是将军盘面
&& !value_is_mate(beta) // 当落入一个不知道上限的窗口时,不剪枝,这种情况发生在height==2时
&& do_null(board) // 国象规矩限定子>=2
&& (!UseNullEval || depth <= NullRection+1 || eval(board) >= beta)) { // 根据距离叶子或者alpha,beta搜索中,棋形的评估进行控制

我想, 对上面的控制条件,大家都是很好理解的, fruit中NullRedcution==3, 这个可以理解为fruit审局做得比较完善,depth<=4进入审局搜索盘面评估的结果, 逼近搜索的结果, 而eval则是对depth>4时候剪枝的控制条件,这种控制条件往往是根据棋形进行控制, crafty是控制大子的个数, fruit是控制评估的结果, 考虑到这个结果因引擎而异, 我就不在这里讨论哪种条件才是更好的了

new_depth = depth - NullRection - 1;

move_do_null(board,undo);
value = -full_search(board,-beta,-beta+1,new_depth,height+1,new_pv,NODE_OPP(node_type));
move_undo_null(board,undo);

fruit的nullmove会导致一种和以外不同的搜索情况产生,crafty的做法是,上一层做了NULLMOVE,现在轮到我了,我应该移动棋步,但是fruit的做法,会引起双方的等待,这是否正确?

答案是,很正确.首先,考虑算法上面的等价性,连续做NULLMOVE,其实等价于我不知道你是否做了NULLMOVE,不过我也尝试做一个NULLMOVE,看你是否能对我造成威胁,这个并不违背NULLMOVE的思想,而且一个不会产生PV路径的节点,做搜索有意义吗?没有意义.既然如此,那么就剪掉吧.

对nullmove的结果,fruit有两种特别的处理手段

第一,不保存结果,因为fruit的算法的剪枝,会让实际的值和nullmove产生的值差别很大
第二,对某些特殊情况,fruit会做一个nullmove verify的search, fruit尝试全面利用nullmove, 但是某些情况, nullmove成功的概率有限, 需要做一定的验证

fruit对nullmove的实现方法,可以说得上是历史性的(开源的引擎来说),这个算法的优异,是fruit搜索效率特高的一个根本原因

c. fruit的qs加强

在上文中, 我已经提过, fruit是尝试通过控制depth<=1使用全搜索的方法, 尽可能发现杀棋, 那么, 对nullmove来说, 如果depth<=4,发生了一个剪枝, 立刻进入了qs, 马上就把杀棋步剪掉了

为了防止这种情况, fruit对刚进入qs的棋步,不单单生成吃子步,还生成将军步,这可以有效防止把杀棋步漏掉的情况.

qs里面,fruit对吃子步产生的将军步,会解将,让对方保持继续进攻的机会,这也是为了防止qs漏掉杀棋步的一种有效措施

虽然qs的论述很少,而且很简单,但是,对qs中,将军的检查,却有着消耗20%性能,提高50%功能的性价比,这个也是crafty所缺少的

d. fruit的history pruning

要了解history pruning, 首先建议参考国象中成熟的算法lmr (late move rection)的论述
fruit对lmr引入了history value,并且对搜索结果做了verify,有效避免了lmr曾经的fail high的问题
这里就不对history pruning的限制条件做详细的阐述了,实际上这种防止危险的检查方法和nullmove的限制是类似的,而且会根据不同引擎知识和搜索结合的特点而存在差异
history pruning经实践证明, 是一种非常有效的剪枝方法, 并且绝对不会对棋力有降低的影响(其实根本原因是不会漏掉杀棋步)

history pruning根据国外的测试,能够提高elo 100,旧版的crafty并没有history pruning

e. fruit的hash实现方法

fruit的hash实现方法,经实践,大概比crafty的方法提高了5%~10%的性能

fruit对每个盘面,保存了一个上界和一个下界,如果对一个盘面搜索时,发现该盘面的搜索范围上界比过往的下界都要小, 则返回保存的下界, 如果发现搜索范围的下界比保存的上界要大, 则返回保存的上界, 如果发现盘面落入保存的窗口中, 则当保存的上界和下界重合而且搜索深度比当前搜索深度更深时, 返回保存的结果

这种hash的处理方法,修正了crafty中,只能对单边情况保存的不足, 有效提高了效率

需要注意的地方是, 在iterative search中, 每次fruit都会把搜索出来的PV路径都保存到hash中,这是用于取步(不是取值), 还有,在处理hash冲突时候, fruit使用了多个cluster的方法...需要细究的细节很多, 大家有兴趣可以仔细看看fruit的实现

f. fruit的search root move list

fruit对每次搜索后对root节点记录分值,并根据分值重新排序,以便下一次使用,当棋步产生振荡的时候(在两个棋步之间徘徊)会有效提高引擎的搜索效率

g. fruit的FAIL SOFT

嗯, 关于FAIL SOFT以及实践的方法, 可以参考纵马奔流的****和fruit的代码, 我就不再无聊多说一次了..

3. fruit 2.1和TogaII1.2.1的差异,elo 100的差距原因

首先需要说明的是,我是用diff的方法,比较两者在搜索实现上的差别的, 应该是没有遗漏的

两者的差别列举如下
a. 延伸的差异, 根据特定棋形做了depth+1的搜索, 也就是越搜反而越深(当然TogaII有手段防止过深)
b. 剪枝的差异, 包括打开futility, delta, 并且对底层也做了history pruning
c. 对棋步稳定的盘面(只产生一个PV路径), 用渴望窗口搜索, 减少搜索量
d. 对危险情况的搜索的加强

两者差异原理分析
简单概括TogaII的改进,那就是利用国际象棋的知识调整了fruit的搜索树,对危险的盘面进行了更深的搜索,否则就剪掉.

首先,TogaII最有效的改进,是在叶子附近,利用history value把证明曾经无效的叶子节点丢弃掉,这是一个非常有效的算法,这里面的道理值得我们深思?为什么我们不能够发现一个这样的算法呢?

如果光是观察futility和delta剪枝法, 我想肯定会有人对我提出疑问? 不是说这些根据子力情况剪掉的分支会漏掉杀棋步吗? 为什么还打开剪枝, OK, 我来一个简单的回答, 假如已经是用了知识判断过这类分支并不危险, 那就可以剪掉了.

TogaII能改进fruit的原因基于对国际象棋的深刻理解(也许是大量的测试的证明), 它的剪枝和延伸, 是相辅相成的, 如果有人想尝试这个方向, 千万不要只开剪枝或者只加延伸

这个方向, 是在搜索树中, 加入对棋类知识的判断. 调整搜索树更适合某种棋规.

4. fruit算法应用于中象引擎的分析及中象引擎算法改进分析

下面的内容,是基于上述阐述的一些具体应用的例子,可对引擎做出一定的修正

a. nullmove改进

nullmove限制条件中, 当depth<=4时, 进入nullmove. 这种情况会忽略了depth=1可能产生的杀棋步, 当审局的知识缺乏该方面的内容时, 会漏掉杀棋步

这个时候, 可以根据自己引擎的审局知识的特点, 做depth=1的search_verify

代码如下

if (depth<=4)
do_nullmove;

if (nullscore>=beta)
do_search_verify(depth=1);

这种方法可以避免一些杀棋情况的漏算, 这个也可以算是搜索和知识结合的一个典型例子吧

b. history pruning改进

考虑下面的情况

[炮]吃车1, 车2吃[炮], 车2移动, 和车1移动, 这两个棋步, 会引起同样的history value的减少, 虽然限制了history pruning发生在不吃子的情况, 但是, 中象的交换频率远>国象, 这种情况对fruit中historyvalue<9830就剪枝(60%)显然不适合, 因为中象发生上面的情况要高多了, 而historyvalue<9834(60%)只要该棋步有一次被检索的情况就会发生, 这个时候, 修正historyvalue<16384*45%, 可以有效减少误判

c. futility剪枝及delta剪枝的意义分析

嗯, 这个, 首先参考TogaII和fruit对比的文章

futility和delta, 如果不会漏掉杀棋步, 或者, 在不会被对方杀死的情况, 非常有助于扩大自己的子力优势, 这是这两个剪枝法的机制决定的(注意,这两个剪枝法的依据是扩大子力优势,所以适用的范围是有限的,对双方对杀的盘面是会削弱攻击能力的)

我建议使用这两个剪枝法, 当然是建立在调整过搜索树以后(避免在容易引发杀棋的盘面使用,常见的手段是判断kingsafety,是否处于被攻击状态中)

中象棋软搜索引擎揭密(三) fenon
d. 棋步排序的改进

从PVS搜索的原理出发, 搜索效率取决于搜索次序

常见的棋步排序是历史步->吃子步->killer->etc, 这是基于最大化子力优势的搜索, 当对杀时, 这种搜索排序效率是非常低的.

考虑killer棋步,如果能够发生一个killer步的分数是杀棋步,那么调整棋步排序为历史步->killer->吃子步->etc,这样就很好地把杀棋和吃子都结合起来了

5. fruit算法和象眼的差异, 如何提高象眼的棋力
通过本篇的介绍, 希望能够把开源的象眼程序, 改进到一个全新的高度, 假如有人希望一起完成象眼的改进, 请站内和我联系

下面是我认为可以有效提高象眼棋力的几个地方
a. 基于PV节点的nullmove pruning
b. qs加强
c. History pruning及TogaII剪枝法
d. 棋步排序
e. hash的改进
f. IID算法修正
g.search root move list

6. 建立以kingsafety为核心的审局, 以及审局模型的详细介绍

a. 对盘面区分阶段, 不同阶段采取的策略是不同的, 开中残差异是很大的

实际上, 开局通过开局库和子力位置分+若干简单知识, 是很容易走出正确的棋步盘面的, 这个研究不深, 我更多是依赖开局库解决这个问题

残局时候, 调整位置分表, 判断子力组合, 这个时候因为子力很少, 基本上难以进取, 更多是应该考虑防守, 控制搜索的危险程度和给予适当的分数, 很容易做到这点

中局是比较复杂的, 下面详细说说我所理解的地方

b. 对某个阶段的知识, 不要给引擎太多的选择, 避免引擎找出多个PV路径, 引起棋步的来回选择, 如中局, 应该集中思考杀棋或者扩大子力的优势

c. 上面1.讲述了搜索和知识之间的关系, 其中也提及了depth=1时候的杀棋知识评估的重要性, 但是, 只是局限于depth=1的杀棋知识, 我们的盘面判断力还是很有限的, 这个时候怎么办? 我们能不能对depth>=2的情况进行评估

我提供一个实践的方法, 那就是分层次打分.

比如: 三子归边的判断, 我们通过以下三种层次评分
(a) 有沉底炮, +分 (depth=3)
(b) 有沉底炮和车可做炮架, +分 (depth=2)
(c) 有沉底炮和车并且马进入了可以助攻的区域, +分 (depth=1)

刚才在上面的审局和搜索的关系中,我列举了4种知识,并且强调了知识只应该选择有效的,下面分别说说哪些知识是必须的,不在下面列表内的知识,我都不做判断了
a. 准确的杀型
利用位置分值提示车马兵攻击王周围,依赖搜索完成
b. 模糊的杀型
(a) 当头炮 (空头炮,镇中)
(b) 底炮 (三子归边)
(c) 双车杀
c. 子力组合,只做会引起问题的子力组合判断,如兑子后双马不佳
d. 某些特别容易出问题的知识的补充

7. 国际象棋Rybka的胜利以及将来棋软发展的一些展望

一些未来的研究方向, 所以个人的意见应该是一些胡言乱语,仅作笑料

上面所说的一切, 都是基于知识会有一个确定的分数, 但是, 这明显是错误的, 谁能说三子归边是400分,而不是395分呢? 有没有一种方法, 可以动态评估这个分数, 从而达到知识的最优化呢?

第二,传说中的根据知识排序棋步的方法

在国外流行的认为Rybka超越其他软件的原因是因为更聪明的搜索和知识, 从作者言论和Rybka反映的信息做一个猜测(nps超低, 搜索准确度超高), 一致认为Rybka在搜索和评估中, 都采取了全新的方法

其中一个流派3moves现在被认为是Rybka最有可能采取的方法(包含了我的理解补充)

什么是3moves? 首先, 当前盘面移动一步, 对可以攻击的子,计算3步内可以攻击的点集,这个点集每个点都有权重.那么,多个攻击子做交集的时候, 密度最高权重最高的区域, 就是当前盘面最容易攻击的位置, 这表明了这一个棋步的攻击能力
当这个棋步能攻击到王或者其他子时, 这自然就是一个好的棋步,这时候根据点集的情况进行算分,自然是非常准确的.

这种方法超越了子力表和知识分数的局限, 而且更好理解了棋规, 也难怪被认为是最有可能的

以上转载,不知是否你想要的?

㈦ C语言 象棋的代码(主要是走棋子的部分)

你好!!没有c语言的,只有窗体的象棋,还是网络版的执行文件,你试试看吧

㈧ c++程序设计 中国象棋源代码

我提供两个功能完善,而且最重要的,我认为算法设计比较好的中国象棋源代码,因为是源码网的,所以可以学习参考下:
http://www.codefans.net/soft/1466.shtml
http://www.codefans.net/soft/1289.shtml

㈨ 象棋的算法

多下慢棋,最快也要50+20的慢棋。长期慢棋且复盘能提升棋感,很多棋你可以一眼看去就知道不是好棋,从而思考的时候能把这些奇怪的方向排除掉,专注于几个看似不错的选择,再分别计算。下的慢棋越多,每一步的方向就越少,这样计算深度就有了。

长期下去,尽管这样深度足够,但往往复盘的时候会发现思维盲点,有时候类似的情况下某种手段往往不成立,但特定的局面恰好成立。记住这样的手段组合,并且在类似的局面下计算该手段是否成立。

举个栗子:

黑的少俩卒子,如果出车红的炮八平七,黑方底象被红方瞄着,多少有点难受,如果黑方再补象,红方从容的走到车六进三的话,战线漫长,红方维持先手。以上是一般的行棋思路。

但如果你的思维扩展开来,黑方双炮位置相当不错,这时候就要有动刀子的觉悟了。

………… 车1平2
炮八平七 马4进5
车六进三 车2进9
仕五退六 炮4进7!
这一步代表的就是思维的广度:洞察对方的弱点,在看似不可能的地方果断出击一搏。此时红方如果选择交换,无论何种交换方式,红方都会落入下风残局。私以为此时车六平五吃马交换,红方虽然缺双士,但位置尚佳,仍可一战。但如果退车吃炮,红方简单落入下风残棋,显然不满。在他把网上的步时限制用完后,他果然选择了最强硬的招法:

5. 炮七退二 炮7进7!

这也在我计算之内,所以我毫不犹豫砸了出去。立时红方阵型千疮百孔。我和他比赛上只下过一盘,那盘我是靠循序渐进然后靠残局一点点赢下来的,他可能没感受过我进攻时的力量,难免不大适应。这几手他都把步时用完,也没想出好办法。

6. 相五退三 炮4平6

7. 相三进五 炮6平3

8. 相五退七 车2平3

9. 帅五进一 马5退6

至此黑方以一大子的代价,换取红方全部士相,且红方的2路弱马难以处理。最终在一系列顿挫下,二路马被抓死,红方被绝杀。

如果说打士这种棋靠的是思考广度,那么保证这个计划能实行则靠的是强大的计算能力。如果黑无法保证打士成立,那么恐怕出车就是一步很糟糕的棋了,例如黑出车后红炮八平七,黑如果走个车2进7,红方有马七退六的招法,轻而易举就能立于不败,黑方只能苦苦求和了。又比如说黑方没有计算清楚,打相时红方补士黑方的应手,黑方也仍然会血本无归。

慢棋的作用就是让你习惯于长考,练得多了自然计算深度就有了。而行棋的时候则要洞察对方的弱点,然后大胆出手。有时对方的弱点并不好找,这也是需要多下多练才能找到的。

这真的没有捷径,我所能提供的,只是在你盘数上去之后,有这样的思考方式能提升计算深度和广度。至于速度和精度,这完全是靠盘数堆叠才能得到的。

㈩ 象棋游戏通过什么算法实现

你是问人工智能吧。
一般是通过录入常规棋局的走法,然后机器会根据棋局去匹配寻找最佳走法。呵呵,说白了,还是让电脑找一段相似值,然后做选择题。真正的人工学习思考的方法,目前还不成熟。

阅读全文

与象棋开源算法相关的资料

热点内容
韩国情爱电影在线 浏览:811
程序员那么可爱顾墨吃醋 浏览:201
服务器未测速怎么办 浏览:15
男主角林晨的都市小说 浏览:898
百度文库系统源码nodejs 浏览:997
电影院正在上映的电影怎么在家看 浏览:61
永辉生活app如何使用手机闪付 浏览:178
吸奶的电影 浏览:986
对越自卫反击战电影大全集免费 浏览:565
一起看电影网站源码 浏览:909
阿甘正传阿甘的英文名 浏览:159
电影天名 浏览:626
弱视矫治系统源码 浏览:899
金融市场基础知识pdf 浏览:383
三没降头电影 浏览:586
黄色武侠小说txt下载 浏览:531
如何将服务器转移至阿里平台 浏览:744
哪个网站可以看岛国片 浏览:648
代驾app如何导航到起点 浏览:667
机器人穿越外国电影 浏览:681