}
//计算可落子的位置个数,及该位置落子后翻过的棋子的个数（board->cell[i][j].stable）
intChessboard:
:
judge（Chessboard*board,enumColorplayer）
{
inti,j;
unsignednum=0;
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
if（board->cell[i][j].color==BLANK）
{
intx,y;
board->cell[i][j].stable=0;
for（x=-1;x<=1;x++）
{
for（y=-1;y<=1;y++）
{
if（x||y）/*8个方向*/
{
inti2,j2;
unsignednum2=0;
for（i2=i+x,j2=j+y;i2>=0&&i2<=7&&j2>=0&&j2<=7;i2+=x,j2+=y）
{
if（board->cell[i2][j2].color==（enumColor）-player）
{
num2++;
}
elseif（board->cell[i2][j2].color==player）
{
board->cell[i][j].stable+=player*num2;
break;
}
elseif（board->cell[i2][j2].color==BLANK）
{
break;
}
}
}
}
}
if（board->cell[i][j].stable）
{
num++;
}
}
}
}
returnnum;
}
//落子,翻子.
intChessboard:
:
putChess（Chessboard*board,Choice*choice,enumColorplayer）
{
inti=choice->posX,j=choice->posY;
intx,y;
if（board->cell[i][j].color!
=BLANK||board->cell[i][j].stable==0||player==BLANK）
{
return-1;
}
board->cell[i][j].color=player;
board->cell[i][j].stable=0;
if（player==WHITE）
{
board->whiteNum++;
}
elseif（player==BLACK）
{
board->blackNum++;
}
for（x=-1;x<=1;x++）
{
for（y=-1;y<=1;y++）
{
if（x||y）/*8个方向*/
{
inti2,j2;
unsignednum=0;
for（i2=i+x,j2=j+y;i2>=0&&i2<=7&&j2>=0&&j2<=7;i2+=x,j2+=y）
{
if（board->cell[i2][j2].color==（enumColor）-player）
{
num++;
}
elseif（board->cell[i2][j2].color==player）
{
board->whiteNum+=（player*WHITE）*num;
board->blackNum+=（player*BLACK）*num;
for（i2-=x,j2-=y;num>0;num--,i2-=x,j2-=y）
{
board->cell[i2][j2].color=player;
board->cell[i2][j2].stable=0;
}
break;
}
elseif（board->cell[i2][j2].color==BLANK）
{
break;
}
}
}
}
}
return0;
}
/*
*设置棋子的稳定性（计算得分的依据），空白处除外.
*/
voidChessboard:
:
setStable（Chessboard*board）
{
inti,j;
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
if（board->cell[i][j].color!
=BLANK）
{
intx,y;
board->cell[i][j].stable=1;
for（x=-1;x<=1;x++）
{
for（y=-1;y<=1;y++）
{
/*4个方向*/
if（x==0&&y==0）
{
x=2;
y=2;
}
else
{
inti2,j2,flag=2;
for（i2=i+x,j2=j+y;i2>=0&&i2<=7&&j2>=0&&j2<=7;i2+=x,j2+=y）
{
if（board->cell[i2][j2].color!
=board->cell[i][j].color）
{
flag--;
break;
}
}
for（i2=i-x,j2=j-y;i2>=0&&i2<=7&&j2>=0&&j2<=7;i2-=x,j2-=y）
{
if（board->cell[i2][j2].color!
=board->cell[i][j].color）
{
flag--;
break;
}
}
if（flag）/*在某一条线上稳定*/
{
board->cell[i][j].stable++;
}
}
}
}
}
}
}
}
/*
*评价棋手得分.
*/
intChessboard:
:
evaluate（Chessboard*board,enumColorplayer）
{
intvalue=0;
inti,j;
setStable（board）;
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
value+=（board->cell[i][j].color）*（board->cell[i][j].stable）;
}
}
value+=64*board->cell[0][0].color;
value+=64*board->cell[0][7].color;
value+=64*board->cell[7][0].color;
value+=64*board->cell[7][7].color;
value-=32*board->cell[1][1].color;
value-=32*board->cell[1][6].color;
value-=32*board->cell[6][1].color;
value-=32*board->cell[6][6].color;
returnvalue*player;
}
//考虑step步，选择最优方案.采用最大最小博弈和α-β剪裁算法
Choice*maximin（Chessboard*board,enumColorplayer,intstep,intmin,intmax,Choice*choice）
{
inti,j,k,num;
Choice*allChoices;
choice->score=-MAX;
choice->posX=-1;
choice->posY=-1;
num=board->judge（board,player）;
if（num==0）/*无处落子*/
{
if（board->judge（board,（enumColor）-player））/*对方可以落子,让对方下.*/
{
ChessboardtempBoard;
ChoicenextChoice;
Choice*pNextChoice=&nextChoice;
board->clone（&tempBoard,board）;
pNextChoice=maximin（&tempBoard,（enumColor）-player,step-1,-max,-min,pNextChoice）;
choice->score=-pNextChoice->score;
choice->posX=-1;
choice->posY=-1;
returnchoice;
}
else/*对方也无处落子,游戏结束.*/
{
intvalue=WHITE*（board->whiteNum）+BLACK*（board->blackNum）;
if（player*value>0）
{
choice->score=MAX-1;
}
elseif（player*value<0）
{
choice->score=-MAX+1;
}
else
{
choice->score=0;
}
returnchoice;
}
}
if（step<=0）/*已经考虑到step步,直接返回得分*/
{
choice->score=board->evaluate（board,player）;
returnchoice;
}
allChoices=（Choice*）malloc（sizeof（Choice）*num）;
k=0;
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
if（i==0||i==7||j==0||j==7）
{
if（board->cell[i][j].color==BLANK&&board->cell[i][j].stable）
{
allChoices[k].score=-MAX;
allChoices[k].posX=i;
allChoices[k].posY=j;
k++;
}
}
}
}
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
if（（i==2||i==5||j==2||j==5）&&（i>=2&&i<=5&&j>=2&&j<=5））
{
if（board->cell[i][j].color==BLANK&&board->cell[i][j].stable）
{
allChoices[k].score=-MAX;
allChoices[k].posX=i;
allChoices[k].posY=j;
k++;
}
}
}
}
for（i=0;i<8;i++）
{
for（j=0;j<8;j++）
{
if（（i==1||i==6||j==1||j==6）&&（i>=1&&i<=6&&j>=1&&j<=6））
{
if（board->cell[i][j].color==BLANK&&board->cell[i][j].stable）
{
allChoices[k].score=-MAX;
allChoices[k].posX=i;
allChoices[k].posY=j;
k++;
}
}
}
}
for（k=0;k{
ChessboardtempBoard;
ChoicethisChoice,nextChoice;
Choice*pNextChoice=&nextChoice;
thisChoice=allChoices[k];
board->clone（&tempBoard,board）;
board->putChess（&tempBoard,&thisChoice,player）;
pNextChoice=maximin（&tempBoard,（enumColor）-player,step-1,-max,-min,pNextChoice）;
thisChoice.score=-pNextChoice->score;
if（thisChoice.score>min&&thisChoice.score{
min=thisChoice.score;
choice->score=thisChoice.score;
choice->posX=thisChoice.posX;
choice->posY=thisChoice.posY;
}
elseif（thisChoice.score>=max）/*好的超乎预计*/
{
choice->score=thisChoice.score;
choice->posX=thisChoice.posX;
choice->posY=thisChoice.posY;
break;
}
/*不如已知最优值*/
}
free（allChoices）;
returnchoice;
}
intmain（void）/////////////主函数
{
Chessboardboard;
Chessboard*pBoard=&board;
enumColorplayer=BLANK,nowPlayer=BLACK;//声明两个enum枚举变量player，nowplayer
Choicechoice;
Choice*pChoice=&choice;
intdif=-1,step=4,success=0;
charrestart='';
start:
/////////////////////////////////////////////
player=BLANK;/////////////////////////////////////////////
nowPlayer=BLACK;
dif=-1;
step=4;
restart='';
intb;
cout<<"输入1为人人对战,否则为人机对战：
";
cin>>b;
if（b==1
升级会员 