c五子棋演算法
㈠ 怎樣用c語言編五子棋
任何一種棋類游戲其關鍵是對當前棋局是否有正確的評分,評分越准確則電腦的AI越高。五子棋游戲也是如此，但在打分之前，我們先掃描
整個棋盤，把每個空位從八個方向上的棋型填入數組gStyle(2, 15, 15, 8, 2)，其中第一個下標為1時表示黑棋，為2時表示白棋，第二和第三
個下標表示(x,y)，第四個下標表示8個方向，最後一個下標為1時表示棋子數，為2時表示空格數，如：
gStyle(1,2,2,1,1)=3表示與坐標(2,2)在第1個方向上相鄰的黑棋棋子數為3
gstyle(1,2,2,1,2)=4表示與坐標(2,2)在第1個方向上的最近的空格數為4
在定義方向時，也應該注意一定的技巧，表示兩個相反的方向的數應該差4，在程序中我是這樣定義的：
Const DIR_UP = 1
Const DIR_UPRIGHT = 2
Const DIR_RIGHT = 3
Const DIR_RIGHTDOWN = 4
Const DIR_DOWN = 5
Const DIR_DOWNLEFT = 6
Const DIR_LEFT = 7
Const DIR_LEFTUP = 8
這樣我們前四個方向可以通過加四得到另一個方向的值。如果你還是不太明白，請看下面的圖：
---------
---------
---oo----
-ox*xx---
---------
---------
圖中的*點從標為(4,4),（打*的位置是空位）,則:
gStyle(2,4,4,1,1)=1在(4,4)點相鄰的上方白棋數為1
gStyle(2,4,4,1,2)=2在(4,4)點的上方距上方白棋最近的空格數為2
gStyle(1,4,4,3,1)=2在(4,4)點相鄰的右方黑棋數為2
gStyle(1,4,4,3,2)=1在(4,4)點的右方距右方黑棋最近的空格數為3
...
一旦把所有空點的棋型值填完，我們很容易地得出黑棋水平方向上點(4,4)的價值，由一個沖1（我把有界的棋稱為沖）和活2（兩邊無界的
棋稱為活）組成的。對於而白棋在垂直方向上點(4,4)的價值是一個活1，而在/方向也是活1所以，只要我們把該點的對於黑棋和白棋的價值算出
來，然後我們就取棋盤上各個空點的這兩個值的和的最大一點作為下棋的點。然而，對各種棋型應該取什麼值呢？我們可以先作如下假設：
Fn 表示先手n個棋子的活棋型，如：F4表示先手活四
Fn'表示先手n個棋子的沖棋型，如：F4'表示先手沖四
Ln 表示後手n個棋子的活棋型，如：L3表示後手活三
Ln'表示後手n個棋子的沖棋型，如：L3'表示後手沖三
.
.
.
根據在一行中的棋型分析，得到如下關系：
L1'<=F1'<L2'<=F2'<=L1<F1<L2<F2<L3'<=F3'<L4'<F4'=F4
從這個關系包含了進攻和防守的關系（當然，這個關系是由我定的，你可以自己定義這些關系）。對這些關系再進一步細化，如在一個可下
棋的點，其四個方向上都有活三，也比不上一個沖四，所以我們可以又得到4*F3<L4'這個關系，同樣，我們還可以得到其它的關系，如：4*F2<L3、4*L3<F3...，這些的關系由於你的定法和我的定法制可能不一樣，這樣計算機的AI也就不一樣，最後我們把分值最小的L1'值定為1，則我們就得
到了下面各種棋型的分值，由C語言表示為：
F[2][5]={{0,2,5,50,16000},{0,10,30,750,16000}};
L[2][5]={{0,1,5,50,3750},{0,10,30,150,4000}};
F數組表示先手，第一個下標為0時表示沖型，第二個下標表示棋子數，則F2'對應F[0][2]L數組表示後手，第一個下標為0時表示沖型，第二
個下標表示棋子數，則L2對應F[1][2]Ok，棋型的分值關系確定好了以後，我們把每一個可下點的四個方向的棋型值相加（包括先手和後手的分
值），最後選擇一個最大值，並把這一點作為計算機要下的點就OK了:)。
後話：
1、得到最大值也許不止一個點，但在我的程序中只選擇第一個最大點，當然你可以用於個隨機數來決定
選擇那一個最大值點，也可以對這些最大值點再作進一步的分析。
2、在這個演算法中我只考慮了周圍有棋子的點，而其它點我沒有考慮。
3、可以再更進一步，用這個演算法來預測以後的幾步棋，再選擇預測值最好的一步，這樣電腦的AI就更高了
4、這個演算法沒有考慮黑棋的禁手（雙3、雙四和多於五子的連棋）。因為在平時我下的五子棋是沒有這些
禁手的。
㈡ 五子棋怎麼計算勝負
五子棋 、六子棋、連珠已經成為歐洲現代五子棋的組成部分，舉行了很多次大大小小的比賽，並且將三種棋的世界錦標賽聯合舉行。下面我給你介紹五子棋怎麼計算勝負，歡迎閱讀。
五子棋比賽中斷的情況
1. 比賽在正常情況下絕對不能中斷。
2. 特殊情況下被迫暫時中斷比賽。
如果比賽場地由於各種原因不能繼續正常進行比賽，暫時中斷比賽是必要的。一旦問題得到解決，比賽必須馬上恢復進行。
3. 暫時中斷比賽的程序
裁判必須嚴格遵守下面的封棋程序：
(1) 裁判必須記錄下此刻雙方棋盤上的局面並經過雙方棋手確認。裁判記錄當前局面所用的時間不計入雙方棋手的比賽時間。
(2) 在離開賽場前，非輪走方棋手必須將自己所用的時間記錄在他的比賽記錄紙上，並交給裁判。
(3) 輪走方棋手封棋前，必須把他的下一步著法暗記在他的比賽記錄紙上(無需讓他人看到)。此著法可以不在棋盤上走出。
(4) 裁判須停止雙方的棋鍾，輪走方棋手必須把自己所用的時間記錄在他的比賽記錄紙上，並交給裁判。
(5) 裁判必須將記錄下來的封棋局面和雙方的比賽記錄裝入信封密封並妥善保管，至續賽時啟封。
(6) 輪走方棋手暗記下來的封棋著法必須是合乎規則的著法，否則判負。
4.封棋續賽的程序
在封棋續賽開始時，裁判須嚴格遵守下面的程序：
(1) 打開密封的信封。
(2) 把比賽記錄紙發還給雙方棋手。
(3) 由雙方棋手確認封棋時的局面和剩餘用時。
(4) 輪走方棋手必須走他在封棋時暗記在記錄紙上的著法，然後按停自己的棋鍾，對方開始計時。
五子棋怎麼計算勝負
雙方確認的終局或被裁判員判定的終局均為終局。終局分勝局與和局。
l. 勝局
(1) 最先宣布自己在棋盤上形成五連，並得到對手或裁判認可的一方為勝。白棋長連視同五連。
(2) 黑方出現禁手，無論是自願或被迫走出，只要白方立即指出，則判白方勝。
如白方在黑方出現禁手後，未立即指出而又落下一白子，則黑方禁手不再成立。
黑方走出長連禁手則不同，只要是在終局前，無論白方何時發現此長連禁手，指出此禁手而宣布勝利，判白方勝。
黑方五連與禁手同時形成，禁手失效，黑方勝。
(3) 無論在任何情況下，雙方均認可的勝局。
對局中，一方出現下列情況之一，裁判員判對方勝。
A 比賽對局中故意移子，故意散亂棋局者。
B 超過規定時限者，包括比賽對局時限和遲到時限。棋手或裁判員發現後指出均可。
C 一方宣布認輸者。
D 當局棄權者或未通知裁判員而中途退出比賽者。
E 在要求記錄的比賽中無故拒絕記錄者。
F 對局結束時，拒絕在成績單上簽字者。
G 拒絕遵守本規則者。
H 在同一局中，單方面先出現第二次違例者。
I 對局過程中棋手查閱有關資料游帆慶或離席與他人商討棋局者，或用記譜紙、筆分析棋局，可構成輔助計算行為者。
J 正常對局過程中主動停鍾者。
K 對局過轎消程中接打、觀看通訊工具者。
2. 和局
對局中出現下列情況之一，判和棋。
(1) 對局雙方一致同意和棋。
(2) 對局雙方同一回合均放棄行棋權。
(3) 全盤均下滿，已無空白交叉點，且無勝局出現。
(4) 雙方比賽時限在發現時均已超時，但又不能確定哪方先超時神握。
(5) 無意移子或棋局散亂情況符合和棋規定的(參看行棋章節)。
3. 提和
(1) 欲提和者應在自己剛下完一著後提出，在提和後方可按鍾。
(2) 一方提和，對方可對提和建議表示同意，也可用口頭拒絕或完成一著棋的形式表示拒絕。
(3) 在對方棋鍾走動時提和者，裁判員可判提和者違例。
(4) 在一局中，一方提和次數不能超過對方兩次，否則，裁判員可判提和者違例。
(5) 在一局中，只要提和次數不超過對方兩次，對局雙方均可反復提和也可反復拒絕提和。
㈢ c語言五子棋判斷誰贏演算法的疑問
下一個新的子在wei處，然後以這個子為基準來判斷，case
0為例，橫著判斷-》贏得可能性有：這個子是5個子最右邊的子…盯做…這旁鍵個子是五個子最左邊的子。所以贏得可能性中，那最左邊的子的坐標就是wei.x-4,wei.y
即count=4，然後一次判斷左邊第三個子，第二個子，……右邊運則巧第四個子，如果有連續的5個子（通過count2或3的值來判斷）就算贏了。
㈣ 五子棋的演算法用哪種比較簡單
可以採用這樣的笨演算法，運行起來慢點，但是很簡單易懂，而且效果很好。如果能夠加以優化，則其實是很好的演算法：
1、首先遍歷整個棋盤，找到一個可以落子的點，然後假設自己在該點落子，再然後判斷如果棋子落到這個點上後會對自己有什麼利益，比如會不會形成沖4活三、雙活三等等，（事先將沖四活三、雙活三等效果定義上利益值，當然，如果是五個子連起來了的話，利益值要被定義成最高，最好是無窮大的），將各種效果的利益值相加，得到己方的利益值。
2、將角色互換一下，重復第一步，得到對方的利益值（其實是遞桂演算法）。
3、將己方的利益值減去對方的利益值，得到該點的總利益值。
4、整個棋盤所有能落子的點都計算出利益值之後，找出利益值最大的那個點，將棋子落到該點。
當然，這個演算法可以有很大程度的優化，比如，如果沒有相鄰的棋子，可以放棄該點。還有一旦找出可以勝利的點，就不再繼續往下計算。。。。
模擬演算法：
int liyi(角色, 層次）
{
if(層次=0)
return 0;
for(第一個可以落子的點 到 最後一個可以落子的點）
{
int 利益,最大利益;
//遞桂...
利益 = 獲取本角色利益值() - liyi(角色=相反角色,層次-1);
if(利益>最大利益)
{
最大利益 = 利益；
保存該點。
}
落子到所保存的點。
}
㈤ c語言的五子棋代碼（博弈演算法）
#include<stdio.h>
#include<bios.h>
#include<ctype.h>
#include<conio.h>
#include<dos.h>
#defineCROSSRU0xbf/*右上角點*/
#defineCROSSLU0xda/*左上角點*/
#defineCROSSLD0xc0/*左下角點*/
#defineCROSSRD0xd9/*右下角點*/
#defineCROSSL0xc3/*左邊*/
#defineCROSSR0xb4/*右邊*/
#defineCROSSU0xc2/*上邊*/
#defineCROSSD0xc1/*下邊*/
#defineCROSS0xc5/*十字交叉點*/
/*定義棋盤左上角點在屏幕上的位置*/
#defineMAPXOFT5
#defineMAPYOFT2
/*定義1號玩家的操作鍵鍵碼*/
#definePLAY1UP0x1157/*上移--'W'*/
#definePLAY1DOWN0x1f53/*下移--'S'*/
#definePLAY1LEFT0x1e41/*左移--'A'*/
#definePLAY1RIGHT0x2044/*右移--'D'*/
#definePLAY1DO0x3920/*落子--空格鍵*/
/*定義2號玩家的操作鍵鍵碼*/
#definePLAY2UP0x4800/*上移--方向鍵up*/
#definePLAY2DOWN0x5000/*下移--方向鍵down*/
#definePLAY2LEFT0x4b00/*左移--方向鍵left*/
#definePLAY2RIGHT0x4d00/*右移--方向鍵right*/
#definePLAY2DO0x1c0d/*落子--回車鍵Enter*/
/*若想在游戲中途退出,可按Esc鍵*/
#defineESCAPE0x011b
/*定義棋盤上交叉點的狀態,即該點有無棋子*/
/*若有棋子,還應能指出是哪個玩家的棋子*/
#defineCHESSNULL0/*沒有棋子*/
#defineCHESS1'O'/*一號玩家的棋子*/
#defineCHESS2'X'/*二號玩家的棋子*/
/*定義按鍵類別*/
#defineKEYEX99v0/*退出鍵*/
#defineKEYFALLCHESS1/*落子鍵*/
#defineKEYMOVECURSOR2/*游標移動鍵*/
#defineKEYINVALID3/*無效鍵*/
/*定義符號常量:真,假---真為1,假為0*/
#defineTRUE1
#defineFALSE0
/**********************************************************/
/*定義數據結構*/
/*棋盤交叉點坐標的數據結構*/
structpoint
{
intx,y;
};
或者下面這個：
#include<graphics.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#defineN15
#defineB7
#defineSTOP-10000
#defineOK1
#defineNO0
#defineUP328
#defineDOWN336
#defineLEFT331
#defineRIGHT333
inta[N+1][N+1];
intzx,zy;
intwrite=1,biaoji=0;
structzn{
longsum;
inty;
intx;
}w[N+1][N+1],max,max1;
voidcbar(inti,intx,inty,intr);
voidmap(inta[][]);
intgetkey();
intkey();
voidzuobiao(intx,inty,inti);
inttu(inta[][],intwrite);
intwtu(inta[][],intwrite);
intneng(inta[][]);
intzh5(inty,intx,inta[][]);
longzzh5(intb[][],inti);
main()
{
inti,j;
intgdriver=DETECT;
intgmode;
initgraph(&gdriver,&gmode,"");
zx=(N+1)/2;
zy=(N+1)/2;
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
a[i][j]=0;
map(a);
i=1;
while(i)
{
intk,n;
k=wtu(a,write);
if(k==STOP)gotoend;
map(a);
n=neng(a);
if(n==STOP)gotoend;
map(a);
}
end:
;
}
intneng(inta[N+1][N+1])
{
inti,j;
intk;
max.sum=-1;
for(i=0;i<=N;i++)
for(j=0;j<+N;j++)
{
w[i][j].sum=0;
w[i][j].x=i;
w[i][j].y=j;
}
for(i=1;i<=N-4;i++)
for(j=1;j<=N-4;j++)
{
k=zh5(i,j,a);
if(k==STOP)return(STOP);
}
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
{
if(max.sum<w[i][j].sum)
{
max.sum=w[i][j].sum;
max.y=i;
max.x=j;
}
elseif(max.sum==w[i][j].sum)
{
if(((max.y-zy)*(max.y-zy)+(max.x-zx)*(max.x-zx))>((i-zy)*(i-zy)+(j-zx)*(j-zx)))
max.sum=w[i][j].sum;
max.y=i;
max.x=j;
}
}
if(a[max.y][max.x]==0)
{
a[max.y][max.x]=-1;
zy=max.y;
zx=max.x;
}
}
intzh5(inty,intx,inta[N+1][N+1])
{
inti,j;
intb[6][6];
longc[13];
longd[6][6];
longtemp;
for(i=y;i<=y+4;i++)
for(j=x;j<=x+4;j++)
b[i+1-y][j+1-x]=a[i][j];
c[1]=b[1][1]+b[1][2]+b[1][3]+b[1][4]+b[1][5];
c[2]=b[2][1]+b[2][2]+b[2][3]+b[2][4]+b[2][5];
c[3]=b[3][1]+b[3][2]+b[3][3]+b[3][4]+b[3][5];
c[4]=b[4][1]+b[4][2]+b[4][3]+b[4][4]+b[4][5];
c[5]=b[5][1]+b[5][2]+b[5][3]+b[5][4]+b[5][5];
c[6]=b[1][1]+b[2][1]+b[3][1]+b[4][1]+b[5][1];
c[7]=b[1][2]+b[2][2]+b[3][2]+b[4][2]+b[5][2];
c[8]=b[1][3]+b[2][3]+b[3][3]+b[4][3]+b[5][3];
c[9]=b[1][4]+b[2][4]+b[3][4]+b[4][4]+b[5][4];
c[10]=b[1][5]+b[2][5]+b[3][5]+b[4][5]+b[5][5];
c[11]=b[1][1]+b[2][2]+b[3][3]+b[4][4]+b[5][5];
c[12]=b[1][5]+b[2][4]+b[3][3]+b[4][2]+b[5][1];
for(i=1;i<=12;i++)
{
switch(c[i])
{
case5:biaoji=1;return(STOP);
case-5:biaoji=-1;return(STOP);
case-4:c[i]=100000;break;
case4:c[i]=100000;break;
case-3:c[i]=150;break;
case3:c[i]=150;break;
case-2:c[i]=120;break;
case2:c[i]=100;break;
case-1:c[i]=1;break;
case1:c[i]=1;break;
default:c[i]=0;
}
}
for(i=1;i<=12;i++)
{
if(c[i]==150)
c[i]+=zzh5(b,i);
}
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
d[i][j]=0;
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(i==j)d[i][j]+=c[11];
if((i+j)==6)d[i][j]+=c[12];
d[i][j]+=c[i]+c[j+5];
}
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(b[i][j]!=0)
d[i][j]=-2;
}
max1.sum=-1;
max1.y=0;
max1.x=0;
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(max1.sum<d[i][j])
{
max1.sum=d[i][j];
max1.y=i;
max1.x=j;
w[i+y-1][j+x-1].sum+=max1.sum;
}
elseif(max1.sum==d[i][j])
{
if(((i+y-1-zy)*(i+y-1-zy)+(j+x-1-zx)*(j+x-1-zx))>((max1.y+y-1-zy)*(max1.y+y-1-zy)+(max1.x+x-1-zx)*(max1.x+x-1-zx)))
{
max1.sum=d[i][j];
max1.y=i;
max1.x=j;
}
}
}
}
longzzh5(intb[6][6],intn)
{
inti,j,k,l,m;
switch(n)
{
case1:i=b[1][1];j=b[1][2];k=b[1][3];l=b[1][4];m=b[1][5];break;
case2:i=b[2][1];j=b[2][2];k=b[2][3];l=b[2][4];m=b[2][5];break;
case3:i=b[3][1];j=b[3][2];k=b[3][3];l=b[3][4];m=b[3][5];break;
case4:i=b[4][1];j=b[4][2];k=b[4][3];l=b[4][4];m=b[4][5];break;
case5:i=b[5][1];j=b[5][2];k=b[5][3];l=b[5][4];m=b[5][5];break;
case6:i=b[1][1];j=b[2][1];k=b[3][1];l=b[4][1];m=b[5][1];break;
case7:i=b[1][2];j=b[2][2];k=b[3][2];l=b[4][2];m=b[5][2];break;
case8:i=b[1][3];j=b[2][3];k=b[3][3];l=b[4][3];m=b[5][3];break;
case9:i=b[1][4];j=b[2][4];k=b[3][4];l=b[4][4];m=b[5][4];break;
case10:i=b[1][5];j=b[2][5];k=b[3][5];l=b[4][5];m=b[5][5];break;
case11:i=b[1][1];j=b[2][2];k=b[3][3];l=b[4][4];m=b[5][5];break;
case12:i=b[1][5];j=b[2][4];k=b[3][3];l=b[4][2];m=b[5][1];break;
}
if((i==0&&j==1&&k==1&&l==1&&m==0))
return(900);
if((i==0&&j==-1&&k==-1&&l==-1&&m==0))
return(1000);
if((i==0&&j==0&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==0&&m==0))
return(20);
if((i==0&&j==0&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==0&&m==0))
return(20);
if((i==-1&&j==1&&k==1&&l==1&&m==1)||(i==1&&j==-1&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==-1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==-1&&m==1)||(i==1&&j==1&&k==1&&l==1&&m==-1))
return(-60);
if((i==1&&j==-1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==-1&&m==1))
return(-60);
}
intwtu(inta[N+1][N+1],intwrite)
{
inti=1;
map(a);
zuobiao(zx,zy,1);
while(i)
{
intk;
k=tu(a,write);
if(k==OK)i=0;
if(k==STOP)return(STOP);
}
}
intgetkey()
{
intkey,lo,hi;
key=bioskey(0);
lo=key&0x00ff;
hi=(key&0xff00)>>8;
return((lo==0)?hi+256:lo);
}
intkey()
{
intk;
k=getkey();
switch(k)
{
case27:return(STOP);
case13:
case'':return(OK);
case328:return(UP);
case336:return(DOWN);
case331:return(LEFT);
case333:return(RIGHT);
default:return(NO);
}
}
voidzuobiao(intx,inty,inti)
{
intr;
if(i!=0)
{
setcolor(GREEN);
for(r=1;r<=5;r++)
circle(75+25*x,25+25*y,r);
}
else
{
if(a[zy][zx]==1)
{
setcolor(8);
for(r=1;r<=5;r++)
circle(75+25*x,25+25*y,r);
}
elseif(a[zy][zx]==-1)
{
setcolor(WHITE);
for(r=1;r<=5;r++)
circle(75+25*x,25+25*y,r);
}
else
{
setcolor(B);
for(r=1;r<=5;r++)
circle(75+25*x,25+25*y,r);
setcolor(RED);line(75+25*zx-5,25+25*zy,75+25*x+5,25+25*zy);
line(75+25*zx,25+25*zy-5,75+25*zx,25+25*zy+5);
}
}
}
inttu(inta[N+1][N+1],intwrite)
{
intk;
re:
k=key();
if(k==OK)
{
if(a[zy][zx]==0)
{
a[zy][zx]=write;
}
else
gotore;
}
if(k==STOP)return(STOP);
if(k==NO)gotore;
if(k==UP)
{
inti,j;
if(zy==1)j=zy;
elsej=zy-1;
zuobiao(zx,zy,0);
zuobiao(zx,j,1);
zy=j;
gotore;
}
if(k==DOWN)
{
inti,j;
if(zy==N)j=zy;
elsej=zy+1;
zuobiao(zx,zy,0);
zuobiao(zx,j,1);
zy=j;
gotore;
}
if(k==LEFT)
{
inti,j;
if(zx==1)i=zx;
elsei=zx-1;
zuobiao(zx,zy,0);
zuobiao(i,zy,1);
zx=i;
gotore;
}
if(k==RIGHT)
{
inti,j;
if(zx==N)i=zx;
elsei=zx+1;
zuobiao(zx,zy,0);
zuobiao(i,zy,1);
zx=i;
gotore;
}
}
voidcbar(inti,intx,inty,intr)
{
if(i!=0)
{
if(i==1)
setcolor(8);
elseif(i==-1)
setcolor(WHITE);
for(i=1;i<=r;i++)
{
circle(x,y,i);
}
}
}
voidmap(inta[N+1][N+1])
{
inti,j;
cleardevice();
setbkcolor(B);
setcolor(RED);
for(i=0;i<N;i++)
{
line(100,50+25*i,75+N*25,50+25*i);
line(100+25*i,50,100+25*i,25+N*25);
}
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
cbar(a[i][j],75+25*j,25+25*i,10);
}
㈥ c語言五子棋代碼，
package day17.gobang;
import java.util.Arrays;
public class GoBangGame {
public static final char BLANK='*';
public static final char BLACK='@';
public static final char WHITE='O';
public static final int MAX = 16;
private static final int COUNT = 5;
//棋盤
private char[][] board;
public GoBangGame() {
}
//開始游戲
public void start() {
board = new char[MAX][MAX];
//把二維數組都填充『*』
for(char[] ary: board){
Arrays.fill(ary, BLANK);
}
}
public char[][] getChessBoard(){
return board;
}
public void addBlack(int x, int y) throws ChessExistException{
//@
//char blank = '*';
//System.out.println( x +"," + y + ":" + board[y][x] + "," + BLANK);
if(board[y][x] == BLANK){// x, y 位置上必須是空的才可以添棋子
board[y][x] = BLACK;
return;
}
throw new ChessExistException("已經有棋子了！");
}
public void addWhite(int x, int y)
throws ChessExistException{
if(board[y][x] == BLANK){// x, y 位置上必須是空的才可以添棋子
board[y][x] = WHITE;
return;
}
throw new ChessExistException("已經有棋子了！");
}
//chess 棋子：'@'/'O'
public boolean winOnY(char chess, int x, int y){
//先找到y方向第一個不是 blank的棋子
int top = y;
while(true){
if(y==0 || board[y-1][x]!=chess){
//如果y已經是棋盤的邊緣， 或者的前一個不是chess
//就不再繼續查找了
break;
}
y--;
top = y;
}
//向回統計所有chess的個數，如果是COUNT個就贏了
int count = 0;
y = top;
while(true){
if(y==MAX || board[y][x]!=chess){
//如果找到頭 或者 下一個子不是chess 就不再繼續統計了
break;
}
count++;
y++;
}
return count==COUNT;
}
//chess 棋子：'@'/'O'
public boolean winOnX(char chess, int x, int y){
//先找到x方向第一個不是 blank的棋子
int top = x;
while(true){
if(x==0 || board[y][x-1]!=chess){
//如果x已經是棋盤的邊緣， 或者的前一個不是chess
//就不再繼續查找了
break;
}
x--;
top = x;
}
//向回統計所有chess的個數，如果是COUNT個就贏了
int count = 0;
x = top;
while(true){
if(x==MAX || board[y][x]!=chess){
//如果找到頭 或者 下一個子不是chess 就不再繼續統計了
break;
}
count++;
x++;
}
return count==COUNT;
}
//chess 棋子：'@'/'O'
public boolean winOnXY(char chess, int x, int y){
//先找MAX向第一個不是 blank的棋子
int top = y;
int left = x;
while(true){
if(x==0 || y==0 || board[y-1][x-1]!=chess){
//如果x已經是棋盤的邊緣， 或者的前一個不是chess
//就不再繼續查找了
break;
}
x--;
y--;
top = y;
left=x;
}
//向回統計所有chess的個數，如果是COUNT個就贏了
int count = 0;
x = left;
y = top;
while(true){
if(x==MAX || y==MAX || board[y][x]!=chess){
//如果找到頭 或者 下一個子不是chess 就不再繼續統計了
break;
}
count++;
x++;
y++;
}
return count==COUNT;
}
//chess 棋子：'@'/'O'
public boolean winOnYX(char chess, int x, int y){
//先找到x方向第一個不是 blank的棋子
int top = y;
int left = x;
while(true){
if(x==MAX-1 || y==0 || board[y-1][x+1]!=chess){
//如果x已經是棋盤的邊緣， 或者的前一個不是chess
//就不再繼續查找了
break;
}
x++;
y--;
top = y;
left=x;
}
//向回統計所有chess的個數，如果是COUNT個就贏了
int count = 0;
x = left;
y = top;
while(true){
if(x==0 || y==MAX || board[y][x]!=chess){
//如果找到頭 或者 下一個子不是chess 就不再繼續統計了
break;
}
count++;
x--;
y++;
}
return count==COUNT;
}
public boolean whiteIsWin(int x, int y) {
//在任何一個方向上贏了，都算贏
return winOnY(WHITE, x, y) ||
winOnX(WHITE, x, y) ||
winOnXY(WHITE, x, y) ||
winOnYX(WHITE, x, y);
}
public boolean blackIsWin(int x, int y) {
return winOnY(BLACK, x, y) ||
winOnX(BLACK, x, y) ||
winOnXY(BLACK, x, y) ||
winOnYX(BLACK, x, y);
}
}
㈦ C語言五子棋
我瀏覽了一下你的代碼，你對勝利的判斷採用的是檢查整個棋盤的方式，這樣做的最大弊端自然是低效，而且在編寫斜方向判斷的時候比較復雜。我建議你採用下子後判斷的方式，即玩家1下了一個字後，像該子周圍8個方向檢查是否存在5子的情況，只需要一個判斷方法，而且較為簡單。
void chooseONE()
{
printf("第一玩家請選擇下棋位置\n");
printf("第幾個直的\n");
scanf("%d",&co);
printf("第幾個橫的\n");
scanf("%d",&ro);
while(arr[ro][co]==1||arr[ro][co]==2)
{
printf("重復了!!!\n");
printf("第幾個直的\n");
scanf("%d",&co);
printf("第幾個橫的\n");
scanf("%d",&ro);
}
arr[ro][co]=1;
//這里加判斷代碼，建議用一個判斷函數，我給你寫個吧
}
//我這里這個方法寫了個大概，你看一下和你的代碼結合一下就可以了，我用i和j作為for循環的變數，你用來做最大的長寬值，這些你都要改一下。
flag作為判斷是否勝利的標志，playerNum是玩家的標志，分1和2，這個函數只寫了左和左上的判斷，其他方向樓主仿照著寫
int win(int row, int col, int playerNum){
int i = 0,j = 0;
int flag = 1;
if(row - 4 >= 0){
flag = 1;
for(i = row; i >= 0; i--){
if(arr[i][j] != playerNum){
flag = 0;
break;
}
}
if(flag == 1){
return 1;
}
}
if(row - 4 >= 0 && col - 4 >= 0){
flag = 1;
for(i = row ,j = col ; i >= 0&&j>=0; i--,j--){
if(arr[i][j] != playerNum){
flag = 0;
break;
}
}
if(flag == 1){
return 1;
}
}
}
㈧ 圍棋（5子棋）是怎麼下的 有幾中演算法
分類: 體育/運動 >> 棋牌麻將
解析:
五子棋：陪返帶就是連成五個子勝利，但是對於先下的黑棋有禁手限制，黑棋不可以三三/四四/以及長連（6個子以上連），這樣算禁手白棋贏，國際比賽上白棋逼迫黑棋禁手也算白贏。
圍棋：主要有三種規則，中國數子規則，蘆蘆日本比目規則，以及台灣的應式規則。數子規則要求填單官，以雙方佔有子和空的總數比輸贏，作為先手有利的黑貼3又3/4子世段。比目規則不填單官，以空的數目和吃對方子的數目和雙方比較論輸贏，這種規則適合實戰棋手數目，黑貼7目半。應式規則沿用較少，黑白各180子，填滿計點較輸贏，黑貼8點。
㈨ C#五子棋的演算法
我終於編程編出來了，代碼如下，這是其中的一部分
棋盤大小設置：
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.dwExStyle=cs.dwExStyle|WS_EX_TOPMOST; //
cs.style=WS_SYSMENU|WS_OVERLAPPED|WS_MINIMIZEBOX;//;
//設置窗口大小：400*340
cs.cx=450;
cs.cy=500;
return TRUE;
}
初始化變數：
CMy3_1View::CMy3_1View()
{
// TODO: add construction code here
//櫻數Load滑鼠圖像和棋子點陣圖
hcursorblack=AfxGetApp()->LoadCursor(IDC_CURSOR1);
hcursorwhite=AfxGetApp()->LoadCursor(IDC_CURSOR2);
m_bmwhite.LoadBitmap(IDB_WHITE);
m_bmblack.LoadBitmap(IDB_BLACK);
//清理棋盤
//數組值為0表示沒有棋子
for(int i=0;i<19;i++)
for(int j=0;j<19;j++)
wzq[i][j]=0;
//白棋先下
colorwhite=true;
}
現在我們就可以開始畫棋盤
void CMy3_1View::OnDraw(CDC* pDC)
{
CMy3_1Doc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
//畫背景
CBrush mybrush1;
mybrush1.CreateSolidBrush(RGB(192,192,192));
CRect myrect1(0,0,1200,800);
pDC->FillRect(myrect1,&mybrush1);
//畫棋盤框線
CPen mypen;
CPen*myoldPen;
mypen.CreatePen(PS_SOLID,1,RGB(0,0,0));
myoldPen=pDC->SelectObject(&mypen);
for(int i=0;i<19;i++)
{
pDC->MoveTo(40,40+i*20);
pDC->LineTo(400,40+i*20);
pDC->MoveTo(40+i*20,40);
pDC->LineTo(40+i*20,400);
}
//重畫時纖態顯示存在的棋子
CDC Dc;
if(Dc.CreateCompatibleDC(pDC)==FALSE)
AfxMessageBox("Can't create DC");
for(int n=0;n<19;n++)
for(int m=0;m<19;m++)
if(wzq[n][m]==1)
{
//顯示白棋毀頌源
Dc.SelectObject(m_bmwhite);
pDC->BitBlt(n*20+32,m*20+32,160,160,&Dc,0,0,SRCCOPY);
}
else if(wzq[n][m]==-1)
{
//顯示黑棋
Dc.SelectObject(m_bmblack);
pDC->BitBlt(n*20+32,m*20+32,160,160,&Dc,0,0,SRCCOPY);
}
}
下棋操作：
void CMy3_1View::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CDC *pDC=GetDC();
CDC Dc;
if(Dc.CreateCompatibleDC(pDC)==FALSE)
AfxMessageBox("Can't create DC");
//是否在棋盤內
if(point.x>30&&point.x<410&&point.y>30&&point.y<410)
{
int px=(point.x-30)/20;
int py=(point.y-30)/20;
//是否已經有棋子
if(colorwhite&&wzq[px][py]==0)
{
Dc.SelectObject(m_bmwhite);
pDC->BitBlt(px*20+32,py*20+32,160,160,&Dc,0,0,SRCCOPY);
//表示存在白棋
wzq[px][py]=1;
//檢查是否結束
over(point);
//換黑棋下
colorwhite=false;
}
else if(wzq[px][py]==0)
{
Dc.SelectObject(m_bmblack);
pDC->BitBlt(px*20+32,py*20+32,160,160,&Dc,0,0,SRCCOPY);
wzq[px][py]=-1;
over(point);
colorwhite=true;
}
}
CView::OnLButtonUp(nFlags, point);
}
㈩ 求五子棋C語言AI演算法(原創思路)
你網路，極大極小數alpha-beta剪枝樹演算法這是最基礎的演算法，如果你想做得好，這個東西絕對夠你研究個三年五年的。我寫過五子棋人工智慧，如果你需要，我有源碼發給你。