Ⅰ 中国象棋算法
对于中国象棋，每一个字都有自己的规则，正所谓无规矩不成方圆。
棋盘先设定好，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语言写的
Ⅱ 象棋对弈软件是如何编制出来的
呵呵，开始我也觉得没有破绽，后来发现了软件也会出昏招。原来原理很简单，只是把基本的开局定式以及常见的对弈拆解局面转换成数据库函数，当出现数据库招数，便调出同类型的宏功能。说到底，只是电脑软件做到了更多的对弈棋局收集，把相关的招数进行了数码汇编。比如：仙人指路开局，软件就会自动把存储在数据库中的符合这一定式类型的所有函数自动调出，选择基本应招（根据用户选手游戏难度不同，软件也会选择相应招数致胜比率和复杂程度）。所以按一般局面和软件玩，就等于和一个熟读兵法的谋士作战，很难赢。你会有看不透，想不到的时候，软件按步就班，数据库就是它的眼睛和脑袋。但是编制软件的并不是一流大师，他们手头上有的都是找得到的棋局，但是棋盘千变万化，有很多招式不可能存在软件中，所以软件也会碰到出昏招的时候。我们可以做一个小实验，两台电脑玩相同的象棋游戏，如果以A电脑进行先手，B电脑进行后手，以B电脑的招式来和A电脑下。百分之九十九的机率是和棋。如果我们用自己的方式操作B电脑和A电脑进行至中局（有一方有多子优势），然后再让两台电脑自己下，肯定有一台电脑是输的。你就会发现输的电脑下的棋局很一般，因为它还是在以应对的形式开展，试问没有优势的情况下，那台数据库一样的电脑软件会出现奇招嘛？也就是说软件也是会输的。我记得国际象棋那个深蓝也输给过卡斯帕罗夫，然后那个更深的蓝赢了卡斯帕罗夫。还是赢在数据采集啊。
Ⅲ 象棋人机对战怎么设计的
象棋人机对战可以使用搜索算法来设计，如果使用贪心算法或者minimax算法。
贪心算法：每次总是选择最优先的走法。
minimax算法：将游戏局面建立搜索树，在搜索树中搜索最优解。
还有其他算法如alpha-beta剪枝算法等，都是在minimax基础上进行优化。
另外，象棋人机对战还需要设计各种规则和评估函数来确定最优解。
Ⅳ 关于象棋残局编程问题,怎么实现对使用者下的棋的应对方法呢
楼上说的根本不对，没有这么简单，怎么能靠随机来让电脑下棋呢！
象棋、围棋、国际象棋等竞技类棋类的电脑思维编程采用的是CBR基于案例推理（case based reasoning -- CBR）以及启发搜索算法（heuristic search algorithm）。
CBR应用在棋局的开始阶段，一般是将开局棋谱作为case先进行数据化预处理，在人类对手下了一迹模手棋之后，电脑要搜索所有保存的case开局，找到最接近的几种开局。然后需要运用启发搜索算法根据预定义的效用函数（utility function）来计算最有效的一种开局。
进入中局和你提到的残局阶段，电脑不再参考CBR数据，而是直接根据当前棋局形式，使用启发搜索算法查找效率值最高的下一步。这个过程中要考虑的东西非常多，比如启发搜索算法的目的函数定义（吃子、换子、平局、获胜）、效用函数变化（每个子的效用值在不同的盘面下是会变的，比如象棋中的炮在子力越少的残局中效用越小）、搜索宽度（当前棋局形势的多少种下一手变化）以及搜索深度（每个搜索宽度中的下一手变化还要涉及的下面几手变化）、计算顺序（横向搜索计算顺序--Breadth-first search，纵向搜索计算顺序--Depth-first search）等等等等。对于象棋和国际象棋的残局来说其实姿虚缓是比较简单的，因为目的函数是确定的、盘面所剩棋子不多导致搜索宽度不大。但是怎么定义目的函数和效用函数是关键的问题。
一款棋类游戏的好坏，电脑对手的棋力高低，往往是由上述这些算法因素决定的。比如在一款象棋游戏里，把电脑等级调成"简单"，那么就是把电脑的搜索深度调低，让电脑不考虑很多步之后的盘面情况，或者调低电脑的效用函数值，让电脑选择效率低的下法。当年深蓝的成功，就在于为国际象棋定义了精确的目的函数和效用函数，以及恰当的运用了大型计算机的并行计算能力来提高搜索宽度和搜索深度，从而保证了电脑的棋招给卡斯帕洛夫带来了很大的挑战。
以上提到的CBR和启发搜索算法只是两种曾运用到棋类编程的算法，除此之外还有很多算法可以用到竞技棋类编程中来，誉贺比如神经网络算法等等。国际上，在人工智能领域有很多类似的棋类编程算法研究，相关论文不计期数，有兴趣可以查阅有关期刊文献。
Ⅳ 关于国际象棋中马的贪心算法证明 严重头痛啊
【问题描述】
马的遍历问题。在8×8方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
【初步设计】
首先这是一个搜索问题，运用深度优先搜索进行求解。算法如下：
1、 输入初始位置坐标x,y；
2、 步骤 c:
如果c>64输出一个解，返回上一步骤c--
(x,y) ← c
计算(x,y)的八个方位的子结点，选出那此可行的子结点
循环遍历所有可行子结点，步骤c++重复2
显然（2）是一个递归调用的过程，大致如下：
void dfs(int x,int y,int count)
{
int i,tx,ty;
if(count>N*N)
{
output_solution();//输入一个解
return;
}
for(I=0;i<8;++i)
{
tx=hn[i].x;//hn[]保存八个方位子结点
ty=hn[i].y;
s[tx][ty]=count;
dfs(tx,ty,count+1);//递归调用
s[tx][ty]=0;
}
}
这样做是完全可行的，它输入的是全部解，但是马遍历当8×8时解是非常之多的，用天文数字形容也不为过，这样一来求解的过程就非常慢，并且出一个解也非常慢。
怎么才能快速地得到部分解呢？
【贪心算法】
其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C.Warnsdorff就提出了一个有名的算法。在每个结点对其子结点进行选取时，优先选择‘出口’最小的进行搜索，‘出口’的意思是在这些子结点中它们的可行子结点的个数，也就是‘孙子’结点越少的越优先跳，为什么要这样选取，这是一种局部调整最优的做法，如果优先选择出口多的子结点，那出口少的子结点就会越来越多，很可能出现‘死’结点（顾名思义就是没有出口又没有跳过的结点），这样对下面的搜索纯粹是徒劳，这样会浪费很多无用的时间，反过来如果每次都优先选择出口少的结点跳，那出口少的结点就会越来越少，这样跳成功的机会就更大一些。这种算法称为为贪心算法，也叫贪婪算法或启发示算法，它对整个求解过程的局部做最优调整，它只适用于求较优解或者部分解，而不能求最优解。这样的调整方法叫贪心策略，至于什么问题需要什么样的贪心策略是不确定的，具体问题具体分析。实验可以证明马遍历问题在运用到了上面的贪心策略之后求解速率有非常明显的提高，如果只要求出一个解甚至不用回溯就可以完成，因为在这个算法提出的时候世界上还没有计算机，这种方法完全可以用手工求出解来，其效率可想而知。
在前面的算法基础之上，增添一些程序加以实现：
函数1：计算结点出口多少
int ways_out(int x,int y)
{
int i,count=0,tx,ty;
if(x<0||y<0||x>=N||y>=N||s[x][y]>0)
return -1;//-1表示该结点非法或者已经跳过了
for(i=0;i<8;++i)
{
tx=x+dx[i];
ty=y+dy[i];
if(tx<0||ty<0||tx>=N||ty>=N)
continue;
if(s[tx][ty]==0)
++count;
}
return count;
}
函数2：按结点出口进行排序
void sortnode(h_node *hn,int n)//采用简单排序法，因为子结点数最多只有8
{
int i,j,t;
h_node temp;
for(i=0;i<n;++i)
{
for(t=i,j=i+1;j<n;++j)
if(hn[j].waysout<hn[t].waysout)
t=j;
if(t>i)
{
temp=hn[i];
hn[i]=hn[t];
hn[t]=temp;
}
}
}
函数3：修改后的搜索函数
void dfs(int x,int y,int count)
{
int i,tx,ty;
h_node hn[8];
if(count>N*N)
{
output_solution();
return;
}
for(i=0;i<8;++i)//求子结点和出口
{
hn[i].x=tx=x+dx[i];
hn[i].y=ty=y+dy[i];
hn[i].waysout=ways_out(tx,ty);
}
sortnode(hn,8);
for(i=0;hn[i].waysout<0;++i);//不考虑无用结点
for(;i<8;++i)
{
tx=hn[i].x;
ty=hn[i].y;
s[tx][ty]=count;
dfs(tx,ty,count+1);
s[tx][ty]=0;
}
}
函数4：主调函数
void main()
{
int i,j,x,y;
for(i=0;i<N;++i)//初始化
for(j=0;j<N;++j)
s[i][j]=0;
printf("Horse jump while N=%d\nInput the position to start:",N);
scanf("%d%d",&x,&y);//输入初始位置
while(x<0||y<0||x>=N||y>=N)
{
printf("Error! x,y should be in 0~%d",N-1);
scanf("%d%d",&x,&y);
}
s[x][y]=1;
dfs(x,y,2);//开始搜索
}
Ⅵ ai象棋原理ai象棋
在AI象棋原理是指人工智能在象棋领域的应用原理。AI象棋的原理主要包括以下几个方面：
搜索算法：AI象棋通过搜索算法来寻找最优的下棋策略。常用的搜索算法包括极小化极大算法（Minimax）、Alpha-Beta剪枝算法等。这些算法通过遍历棋盘上可能的走法，评估每个走法的得分，并选择得分最高的走法作为下一步的决策。
评估函数：AI象棋通过评估函数来评估当前棋局的好坏。评估函数会考虑棋子的位置、棋子的价值、棋局的控制力等因素，从而给出一个分数来表示当前棋局的优劣。搜索算法会根据评估函数的分数来选择最优的下棋策略。
学习算法：AI象棋可以通过机器学习算法来提高自己的下棋水平。例如，可以使用强化学习算法来让AI象棋与自己进行对弈，通过不断的对弈和反馈，AI象棋可以逐渐学习到更好的下棋策略。
数据库和开局库：AI象棋可以利用大量的开局库和数据库来提高自己的下棋水平。开局库包含了各种开局的走法和变化，AI象棋可以通过学习和记忆这些开局库来在开局阶段做出更好的决策。数据库则包含了大量的棋局和对弈记录，AI象棋可以通过分析这些数据来提高自己的下棋水平。
综上所述，AI象棋的原理主要包括搜索算法、评估函数、学习算法以及数据库和开局库的应用。通过这些原理的结合，AI象棋可以在象棋领域表现出较高的水平。
象棋AI的原理主要基于两个核心思想：博弈论和机器学习。
博弈论是一种研究决策过程的数学理论，它考虑了决策者之间的相互影响和策略选择，通过预测不同决策可能产生的结果，来帮助决策者做出更好的选择。在象棋AI中，博弈论被用来模拟人类棋手的思维过程，通过推演棋局的变化，找到最优的走法。
机器学习则是通过大量数据的训练，让AI学会如何在下棋时进行决策。通过学习人类棋谱和自对弈的数据，AI可以逐渐优化自己的下棋策略，提高自己的胜率。
具体来说，象棋AI的实现通常包括以下步骤：
1. 数据收集：收集大量的象棋对局数据，包括人类棋谱和AI训练的数据。
2. 特征工程：将每一局棋的走法、当前局面、历史信息等作为特征，用于后续模型的训练。
3. 模型训练：使用深度学习算法（如神经网络）对特征进行训练，让AI逐渐学习到更优的下棋策略。
4. 模型评估：通过与人类棋手对弈或者与其他AI进行对战，评估AI的棋力水平。
通过以上步骤，象棋AI可以在不断的学习和优化中，逐渐提高自己的棋力水平。
传统ai使用的是阿尔法贝塔剪枝算法和启发式搜索函数，现在ai用的神经网络算法审局