棋譜演算法

『壹』 圍棋點目怎麼算

圍棋點目演算法有兩種：數子法和計目法

1、計目（比目）法：用簡單的文字表述，就是計算比較雙方終局時所圍的地域目數，並以目數多少來判斷勝負結果，日韓圍棋規則都採用計目法。而中國的圍棋規則則是採用數子法。

2、數子法是根據棋局終局後對局雙方的棋子在棋盤上所歸屬位點的多少來計算判斷勝負結果的。

計目法由於只計算所圍的地域目數，收完單官與否並不影響勝負結果，因而規定棋局終局不收單官。所以是否收完所有單官，是數子法和計目法在終局時的主要區別。

所謂歸本數，是指數子法的基礎勝負標准。因為標准圍棋棋盤總計有361個交叉點，所以對局雙方每方應得點數應為總點數的一半，即180.5點。多於此數者勝，少於此數者敗，等於此數者和。

(1)棋譜演算法擴展閱讀：

一、基本下法

對局雙方各執一色棋子，黑先白後，交替下子，每次只能下一子。

棋子下在棋盤上的交叉點上。

棋子落子後，不得向其他位置移動。

輪流下子是雙方的權利，但允許任何一方放棄下子權而使用虛著。

二、棋子的氣：一個棋子在棋盤上，與它直線緊鄰的空點是這個棋子的「氣」。棋子直線緊鄰的點上，如果有同色棋子存在，則它們便相互連接成一個不可分割的整體。

它們的氣也應一並計算。棋子直線緊鄰的點上，如果有異色棋子存在，這口氣就不復存在。如所有的氣均為對方所佔據，便呈無氣狀態。無氣狀態的棋子不能在棋盤上存在，也就是——提子。

三、提子：把無氣之子提出盤外的手段叫「提子」。提子有二種：

1、下子後，對方棋子無氣，應立即提取。

2、下子後，雙方棋子都呈無氣狀態，應立即提取對方無氣之子。拔掉對手一顆棋子之後，就是禁著點（也叫禁入點）。棋盤上的任何一子，如某方下子後，該子立即呈無氣狀態，同時又不能提取對方的棋子，這個點，叫做「禁著點」，禁止被提方下子。

『貳』 棋盤最小路徑問題的演算法

f[i,j]=min(f[i-1][j],f[i][j-1])+這個格的數字
(f[i,j]表示由1,1到i,j這個格的最小權和.

『叄』 求8x8棋盤完美覆蓋的演算法

如果用1*2覆蓋的話
任意一塊骨牌在棋盤上的擺放都可以用一串長度為64的0、1序列來表示，比如
……0——>表示在棋盤最左上角的位置橫著擺上一塊骨牌。
考慮到骨牌既可以橫著擺也可以豎著擺，一塊骨牌在棋盤上的擺放共有2*7*8=112種情況.
這樣就可以得到一個112*60大小的矩陣，不妨將該矩陣記為A。矩陣中的元素由0和1組成，矩陣中的每一行都有且只有兩個1。
於是上述問題，就轉換成怎樣從矩陣中找出32行，抽取出來的這32行構成的新的32*60的矩陣，如果能滿足每列中有且只有一個1，那麼它就是一個完美覆蓋。

矩陣的演算法如下：
如果矩陣A為空且已經選出了32行，則找到一個完美覆蓋，成功返回；
否則選取一個列c，如果c列中不存在1的話，不成功返回;
選擇C列中每一個滿足A[r,c]=1的行r;
將r值作為解決方案的一個步驟記錄下來；
對於r行中每一個A[r,j]=1的j值，從矩陣A中將第j列刪除;
對於j列中每一個A[i,j]=1的i值，從矩陣A中將第i行刪除;
將已經縮小的矩陣重復進行上面的運算。

『肆』 馬踏棋盤演算法

#include <stdio.h>
main()
{
int a[9][9],object[9][9],step[9][3]={{0,0,0},{1,1,2},{2,1,-2},{3,-1,2},{4,-1,-2},
{5,2,1},{6,2,-1},{7,-2,1},{8,-2,-1}};
int i,j,k,x,y,z,m,n,min;
for(i=1;i<=8;i++)
for(j=1;j<=8;j++)
a[i][j]=0; /* clear data in array */
for(i=1;i<=8;i++)
for(j=1;j<=8;j++)
for(k=1;k<=8;k++)
{
x=i;y=j;
x=x+step[k][1];
y=y+step[k][2];
if(x>=1&&x<=8&&y>=1&&y<=8)
a[i][j]++ ; /* initilize array */
} /* start col and row;*/
printf("Please inpute start position x,y\n");
scanf("%d,%d",&m,&n);
for(z=1;z<=64;z++)
{
min =10;
object[m][n]=z;
a[m][n]=0;
for(k=1;k<=8;k++)
{
x=m+step[k][1];
y=n+step[k][2];
if(x>=1&&x<=8&&y>=1&&y<=8)
if(a[x][y]!=0)
{
--a[x][y];
if(a[x][y]<min)
{
min=a[x][y];
i=x;
j=y;
}
}
}
m=i;n=j;
}
for(i=1;i<=8;i++)
{
for(j=1;j<=8;j++)
printf("%6d",object[i][j]);
printf("\n");
}
}
請採納答案，支持我一下。

『伍』 棋盤覆蓋問題的演算法分析

設T(k)是演算法ChessBoard覆蓋一個2^k×2^k棋盤所需時間，從演算法的劃分
策略可知，T(k)滿足如下遞推式：
T(k) = 1 當k=0時
T(k) = 4T(k-1) 當k>0時
解此遞推式可得T(k)=O(4^k)。

『陸』 一道棋盤演算法問題！用（c++）

真巧，pku 1753就是這題。。

前幾天ICPC訓練的時候還寫過，現在懶得再寫了，要用到bfs，我幫你找到了這題的解題報告，你看看吧：

解題思路：
BFS 即寬搜

因為這題說要找出最小值，也就是求最優值問題，那麼，很快就可以想到DP 或者
搜索，而這題很難想出階段以及狀態，所以，構造DP的解法是比較困難的，至於
到底可不可以用DP，我也沒有繼續深思過，所以，我就想到直接搜索，把所有走法
都模擬出來，然後，哪種走法最快能夠實現全盤為白或黑，則答案就出來了！
搜索有BFS和DFS兩種，而BFS有能夠求出最優值的特點，故考慮用BFS！

方法：
如果把走第i步之前，盤子上所有棋子構成的狀態記為S（i-1），並且，初始狀態
記為S（0）。而且，可以發現每走一步時，在棋盤上都有4*4=16中選擇！但，當
如果盤子上出現的狀態在之前也出現過，那麼，就可以不用再繼續走了！（即剪枝）

我們從第一步開始。。。
把走完第一步後盤子的所有狀態都保存起來，如果用
很多個二維數組來保存這些狀態就浪費空間了，並且，在之後的要尋找當前狀態是否
已經出現過，也會出現麻煩！想一想，因為棋子是黑白兩面，可以等價為「0」和「1」
兩種性質，那麼如果用一個一維數組保存起來的話，例如：

bwwb
bbwb
bwwb
bwww 1001110110011000
那麼很快又可以發現另一個特點，圖只有2^16個狀態。

然後，開一個數組sign[65535]標記已經訪問過的狀態，則問題就迎刃而解了！

我的程序：

Problem: 1753 User: jlthero
Memory: 504K Time: 32MS
Language: C++ Result: Accepted

Source Code

#include<stdio.h>
#include<string.h>
#include<vector>
#include<iostream>
using namespace std;
char piece[5][5];
int bina[16];
int sign[65536];
int ans;
int toint()
{
int value=0;
int i;
for(i=15;i>=0;i--)
{
value=value*2;
value+=bina[i];
}
return value;
}
void tochar(int n)
{
int i;
for(i=0;i<16;i++)
{
bina[i]=n%2;
n=n/2;
}
}
void slip(int i)
{
bina[i]=1-bina[i];
if(i%4!=0)
bina[i-1]=1-bina[i-1];
if(i%4!=3)
bina[i+1]=1-bina[i+1];
if(i-4>=0)
bina[i-4]=1-bina[i-4];
if(i+4<16)
bina[i+4]=1-bina[i+4];
}
int DFS()
{
vector<int>quene;
int i=0,j;
int value0,value1;
value0=toint();
if(value0==0||value0==65535)
return 0;
else if(sign[value0]==0)
{
quene.push_back(value0);
sign[value0]=1;
}
while(i<quene.size())
{
value0=quene[i];
tochar(value0);
for(j=0;j<16;j++)
{
slip(j);
value1=toint();
if(value1==0||value1==65535)
return sign[value0];
else if(sign[value1]==0)
{
quene.push_back(value1);
sign[value1]=sign[value0]+1;
}
slip(j);
}
i++;
}
return -1;
}
int main()
{
int i,j;
int t,ans;
while(scanf("%s %s %s %s",piece[0],piece[1],piece[2],piece[3])!=EOF)
{
for(i=0;i<4;i++)
{
t=i*4;
for(j=0;j<4;j++)
bina[t+j]=(piece[i][j]=='b'?1:0);
}
memset(sign,0,sizeof(sign));
ans=DFS();
if(ans==-1)
printf("Impossible\n");
else
printf("%d\n",ans);
}
return 0;
}

下面是王熾輝師兄的代碼，代碼長度要比我短很多^_^：

Problem: 1753 User: wangchi
Memory: 148K Time: 30MS
Language: C Result: Accepted

Source Code
#include<stdio.h>
#include<string.h>
#define MAX 1000000
int a[16], b[16], min;
char ch[4][5];

int legal()
{
int i, t, sum;
static int k = -1;
t = (a[0] + b[0] + b[1] + b[4]) % 2;
for(i = 1; i < 16; i++){
sum = a[i] + b[i];
if(i%4 != 0) sum += b[i-1];
if(i%4 != 3) sum += b[i+1];
if(i-4 >= 0) sum += b[i-4];
if(i+4 < 16) sum += b[i+4];
if(sum % 2 != t) return 0 ;
}
return 1;
}

void dfs(int i, int num)
{
if(i==16) {
if(min > num && legal()) min = num;
return;
}

b[i] = 0;
dfs(i+1, num);

b[i] = 1;
dfs(i+1, num+1);
}

int main()
{
int i, j, t;
while(scanf("%s%s%s%s", ch[0], ch[1], ch[2], ch[3]) != EOF){
for(i = 0; i < 4; i++){
t = i * 4;
for(j = 0; j < 4; j++)
a[t+j] = (ch[i][j]=='w')?0:1;
}

min = MAX;
dfs(0, 0);
if(min == MAX) printf("Impossible\n");
else printf("%d\n", min);
}
return 0;
}

『柒』 棋盤計算器

棋盤擺米:第一格擺1粒，第二格擺2粒，第三格擺4粒……第六十四格擺2的63次方粒，則共有1+2*2+2*2*2+2*2*2*2+……最後等於（64個2相乘）-1。計算後得1.84x(10的19次方)粒。稻米的千粒重為18-32克，就按25克/千粒計，整個棋盤的米就有4.6x(10的14次方)千克，因此，棋盤擺米按50斤來算一袋共有1.84x(10的13次方)袋。