博弈演算法

A. 博弈均衡的進化穩定策略的演算法

計算進化穩定策略的方法主要有兩大類：一是從動態過程出發，求出系統的平衡點，然後，再根據進化穩定策略的定義進行驗證就可以了；另一種方法就是直接用進化穩定策略定義來求。第一種方法涉及到具體的動態過程，並且只要知道動態過程就很容易求出進化穩定策略，本文略（可以參考張良橋2001）。第二種方法就是通過定義來求，下面給出一種簡單的處理方法。
根據納什均衡的定義可以知道，如果策略 是博弈的納什均衡，那麼，所有以正概率進入最優混合策略的純策略都是最優的，參與人在所有這些純策略所得的支付都是無差異的（見《博弈論與信息經濟學》102-103頁，張維迎），即有：
表示混合策略中非零概率的純策略。假定存在 且下標為 的純策略滿足 ，令B是矩陣A中對應於非零純策略的 階子矩陣。且令C為 矩陣，其中代表元素為： 。那麼當且僅當C是負定的， 就是進化穩定策略(見John Haigh 1974)。
證明：假定 ，並且存在 ，有 ，那麼很明顯有 ，其中 是第 個純策略，即在與穩定策略者群體博弈時，突變策略者得到的支付比穩定策略者還要大，所以策略 不是進化穩定策略，所以式（6）是進化穩定策略的必要條件。因此，對應於非零概率的純策略滿足： ，對滿足條件的策略 有（注意 ）：
對任意 ，當且僅當
有： 。綜上所述，利用該方法來求進化穩定策略的步驟如下：
首先，令 個非零混合策略，然後解 個方程： ，定義B，C再考察矩陣C的所有特徵根是否都為負，若都是負則所得的策略就是進化穩定策略。
如求對稱博弈 ，它有兩個進化穩定策略： 。
如果某策略組合是嚴格納什均衡策略，那麼就可以直接得出它就是進化穩定策略，但如果是弱納什均衡策略，那麼就可運用上述的方法來進行判定。由此，可得到求博弈的進化穩定策略步驟：一是求出博弈所有的納什均衡；二是由支付判斷出其中的嚴格納什均衡；三對非嚴格納什均衡而言就代入上述方程，並判斷是否為負定即可以求出博弈中所有進化穩定策略。

B. 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. 博弈問題可以用粒子群演算法求解嗎

個人覺得不可以，粒子群主要用於優化計算。
博弈雖然也是要達到最有利或最優，但是邏輯明顯復雜得多。

D. 謝謝，各位大神啊~~簡述博弈論與最優化理論的不同之處

我的理解，就經濟學來說，博弈論是方法，最優化是方法的方法。博弈論有具體含義，應用於特定情況；最優化作為一個更為根本的分枝，其應用范圍更大更廣。我的博弈論老師就是數學系研究最優化演算法出身，他經常用最優化裡面的方法來求解博弈論。至於重復博弈中的「收斂到均衡點」與最優化方法中的「收斂到最優解」的關系，我理解，使前者達到均衡點的「策略」類比於使後者達到最優解的「演算法」，並且都可能不是唯一的。

E. 關於C#博弈樹演算法

首先，C#可以實現任何C++可以實現的演算法。我不想討論關於博弈樹的問題，因為對於初學者來說，學習較常見的演算法和數據結構，對學習語言和演算法本身都有益。學習編程不能好高騖遠，如果對演算法本身很了解，又有C#基礎，不愁寫不出來。

F. 博弈演算法里的剪枝怎麼用（具體的）

極大極小過程，以及阿爾法-貝塔剪紙。極小極大搜索方法是博弈樹搜索的基本方法，現在博弈樹搜索中最常用的α-β剪枝搜索方法，就是從這一方法發展而來的。
首先假定，有一個評價函數可以對所有的棋局進行評估。當評價函數值大於0時，表示棋局對我方有利，對對方不利。當評價函數小於0時，表示棋局對我方不利，對對方有利。而評價函數值越大，表示對我方越有利。當評價函數值等於正無窮大時，表示我方必勝。評價函數值越小，表示對我方越不利。當評價函數值等於負無窮大時，表示對方必勝。假設雙方都是對弈高手，在只看一步棋的情況下，我方一定走評價函數值最大的一步棋，而對方一定走評價函數值最小的一步棋。會下棋的讀者都知道，在只看一步的情況下最好的棋，從全局來說不一定就好，還可能很不好。因此為了走出好棋，必須多看幾步，從多種可能狀態中選擇一步好棋。
想一想人是如何下棋的呢？人實際上採用的是一種試探性的方法。首先假定走了一步棋，看對方會有那些應法，然後再根據對方的每一種應法，看我方是否有好的回應......這一過程一直進行下去，直到若干步以後，找到了一個滿意的走法為止。初學者可能只能看一、兩個輪次，而高手則可以看幾個，甚至十幾個輪次。
極小極大搜索方法，模擬的就是人的這樣一種思維過程。當輪到我方走棋時，首先按照一定的搜索深度生成出給定深度d以內的所有狀態，計算所有葉節點的評價函數值。然後從d-1層節點開始逆向計算：對於我方要走的節點（用MAX標記，稱為極大節點）取其子節點中的最大值為該節點的值（因為我方總是選擇對我方有利的棋）；對於對方要走的節點（用MIN標記，稱為極小節點）取其子節點中的最小值為該節點的值（對方總是選擇對我方不利的棋）。一直到計算出根節點的值為止。獲得根節點取值的那一分枝，即為所選擇的最佳走步。
在圖3.5所示的例子中，假定搜索深度為2，D～J是7個葉節點，在它們下邊括弧中的數字是這些節點的評價函數值（假定可以計算得到）。A、B、C是三個極小節點，它們分別取各自子節點最小值為自己的值，得到三個節點的值分別為-6、-2和-4。s是極大節點，從A、B、C三個節點的值中取最大值，得到-2。由於-2來自於節點B，所以搜索的結果是應選擇B作為我方的走步。對於我方來說，-2並不是一個好的結果，但卻是在對方不犯錯誤的情況下，對我方最有利的結果。因為從圖中可以看出，如果選擇A為我方的走步，如果對方回應D的話，我方可以得到評價值9，固然對我方有利。但是如果對方是一個高手的話，他一定回選擇E，而不是D。在這種情況下，我方只能得到-6，結果豈不是更差。因此，極小極大過程是一種假定對手每次回應都正確的情況下，如何從中找出對我方最有利的走步的搜索方法。
值得注意的是，不管設定的搜索深度是多少層，經過一次搜索以後，只決定了我方一步棋的走法。等到對方回應一步棋之後，需要在新的棋局下重新進行搜索，來決定下一步棋如何走。極小極大搜索策略是考慮雙方對弈若干步之後，從可能的走步中選一步相對好棋的著法來走，即在有限的搜索深度范圍內進行求解。為此要定義一個靜態估計函數f，以便對棋局的勢態（節點）作出優劣估值，這個函數可根據勢態優劣特徵來定義（主要用於對端節點的"價值"進行度量）。一般規定有利於MAX的勢態，f（p）取正值，有利於MIN的勢態，f（p）取負值，勢均力敵的勢態，f（p）取0值。若f（p）＝＋∞，則表示MAX贏，若f（p）＝－∞，則表示MIN贏。下面的討論規定：頂節點深度d＝0，MAX代表程序方，MIN代表對手方，MAX先走。
圖3.5是一個表示考慮兩步棋的例子，圖中端節點給出的數字是用靜態函數f（p）計算得到，其他節點不用f（p）估計，因為不夠精確，而應用倒推的辦法取值。例如A、B、C是MIN走步的節點，MAX應考慮最壞的情況，故其估值應分別取其子節點f（p）估值中最小者，而s是MAX走步的節點，可考慮最好的情況，故估值應取A、B、C值中的最大者。這樣求得f（s）＝－2，依此確定了相對較優的走步應是走向B，因為從B出發，對手不可能產生比f（s）＝－2更差的效果。實際上可根據資源條件，考慮更多層次的搜索過程，從而可得到更准確的倒推值，供MAX選取更正確的走步。當用端節點的靜態估計函數f（p）求倒推值時，兩位選手應採取不同的策略，從下往上逐層交替使用極小和極大的選值方法，故稱極小極大過程。

G. 計算博弈理論改變著誰的思考方式

計算思維
一．計算思維的定義
計算思維是運用計算機科學的基礎概念進行問題求解、系統設計、以及人類行為理解等涵蓋計算機科學之廣度的一系列思維活動。
進一步地定義為：
1．通過約簡、嵌入、轉化和模擬等方法，把一個看來困難的問題重新闡釋成一個我們知道問題怎樣解決的方法；
2．是一種遞歸思維，是一種並行處理，是一種把代碼譯成數據又能把數據譯成代碼，是一種多維分析推廣的類型檢查方法；
3．是一種採用抽象和分解來控制龐雜的任務或進行巨大復雜系統設計的方法，是基於關注分離的方法（S oc方法）；
4．是一種選擇合適的方式去陳述一個問題，或對一個問題的相關方面建模使其易於處理的思維方法；
5．是按照預防、保護及通過冗餘、容錯、糾錯的方式，並從最壞情況進行系統恢復的一種思維方法；
6．是利用啟發式推理尋求解答，也即在不確定情況下的規劃、學習和調度的思維方法；
7．是利用海量數據來加快計算，在時間和空間之間，在處理能力和存儲容量之間進行折衷的思維方法。
計算思維吸取了問題解決所採用的一般數學思維方法，現實世界中巨大復雜系統的設計與評估的一般工程思維方法，以及復雜性、智能、心理、人類行為的理解等的一般科學思維方法。
二．計算思維的深層次理解
1．計算思維的優點
計算思維建立在計算過程的能力和限制之上，由人由機器執行。計算方法和模型使我們敢於去處理那些原本無法由個人獨立完成的問題求解和系統設計。
2．計算思維的內容
計算思維最根本的內容，即其本質（Essence）是抽象（Abstraction）和自動化（Automation）。計算思維中的抽象完全超越物理的時空觀，並完全用符號來表示，其中，數字抽象只是一類特例。與數學和物理科學相比，計算思維中的抽象顯得更為豐富，也更為復雜。數學抽象的最大特點是拋開現實事物的物理、化學和生物學等特性，而僅保留其量的關系和空間的形式，而計算思維中的抽象卻不僅僅如此。操作模式 計算思維建立在計算過程的能力和限制之上，由人由機器執行。計算方法和模型使我們敢於去處理那些原本無法由任何個人獨自完成的問題求解和系統設計。
3．計算思維用途
計算思維是每個人的基本技能，不僅僅屬於計算機科學家。我們應當使每個孩子在培養解析能力時不僅掌握閱讀、寫作和算術（Reading, writing, and arithmetic——3R），還要學會計算思維。正如印刷出版促進了3R的普及，計算和計算機也以類似的正反饋促進了計算思維的傳播。
計算思維是運用計算機科學的基礎概念去求解問題、設計系統和理解人類的行為。它包括了涵蓋計算機科學之廣度的一系列思維活動。
當我們必須求解一個特定的問題時，首先會問：解決這個問題有多麼困難？怎樣才是最佳的解決方法？計算機科學根據堅實的理論基礎來准確地回答這些問題。表述問題的難度就是工具的基本能力，必須考慮的因素包括機器的指令系統、資源約束和操作環境。
為了有效地求解一個問題，我們可能要進一步問：一個近似解是否就夠了，是否可以利用一下隨機化，以及是否允許誤報（false positive）和漏報（false negative）。計算思維就是通過約簡、嵌入、轉化和模擬等方法，把一個看來困難的問題重新闡釋成一個我們知道怎樣解決的問題。
4．計算思維是一種遞歸思維
它是並行處理。它是把代碼譯成數據又把數據譯成代碼。它是由廣義量綱分析進行的類型檢查。對於別名或賦予人與物多個名字的做法，它既知道其益處又了解其害處。對於間接定址和程序調用的方法，它既知道其威力又了解其代價。它評價一個程序時，不僅僅根據其准確性和效率，還有美學的考量，而對於系統的設計，還考慮簡潔和優雅。
5．抽象和分解
來迎接龐雜的任務或者設計巨大復雜的系統。它是關注的分離（SOC方法）。它是選擇合適的方式去陳述一個問題，或者是選擇合適的方式對一個問題的相關方面建模使其易於處理。它是利用不變數簡明扼要且表述性地刻畫系統的行為。它使我們在不必理解每一個細節的情況下就能夠安全地使用、調整和影響一個大型復雜系統的信息。它就是為預期的未來應用而進行的預取和緩存。計算思維是按照預防、保護及通過冗餘、容錯、糾錯的方式從最壞情形恢復的一種思維。它稱堵塞為「死鎖」，稱約定為「界面」。計算思維就是學習在同步相互會合時如何避免「競爭條件」（亦稱「競態條件」）的情形。計算思維利用啟發式推理來尋求解答，就是在不確定情況下的規劃、學習和調度。它就是搜索、搜索、再搜索，結果是一系列的網頁，一個贏得游戲的策略，或者一個反例。計算思維利用海量數據來加快計算，在時間和空間之間，在處理能力和存儲容量之間進行權衡。
計算思維將滲透到我們每個人的生活之中，到那時諸如演算法和前提條件這些詞彙將成為每個人日常語言的一部分，對「非確定論」和「垃圾收集」這些詞的理解會和計算機科學里的含義驅近，而樹已常常被倒過來畫了。
6．計算思維在其他學科中的影響
例如，機器學習已經改變了統計學。就數學尺度和維數而言，統計學慣用於各類問題的規模僅在幾年前還是不可想像的。各種組織的統計部門都聘請了計算機科學家。計算機學院（系）正在與已有或新開設的統計學系聯姻。
計算機學家們對生物科學越來越感興趣，因為他們堅信生物學家能夠從計算思維中獲益。計算機科學對生物學的貢獻決不限於其能夠在海量序列數據中搜索尋找模式規律的本領。最終希望是數據結構和演算法（我們自身的計算抽象和方法）能夠以其體現自身功能的方式來表示蛋白質的結構。計算生物學正在改變著生物學家的思考方式。類似地，計算博弈理論正改變著經濟學家的思考方式，納米計算改變著化學家的思考方式，量子計算改變著物理學家的思考方式。
這種思維將成為每一個人的技能組合成分，而不僅僅限於科學家。普適計算之於今天就如計算思維之於明天。普適計算是已成為今日現實的昨日之夢，而計算思維就是明日現實。
計算機科學是計算的學問——什麼是可計算的，怎樣去計算。計算機科學不是計算機編程。像計算機科學家那樣去思維意味著遠不止能為計算機編程，還要求能夠在抽象的多個層次上思維。
7．計算思維是根本的，不是刻板的技能
根本技能是每一個人為了在現代社會中發揮職能所必須掌握的。刻板技能意味著機械的重復。具有諷刺意味的是，當計算機像人類一樣思考之後，思維可就真的變成機械的了。
8．計算思維是人的，不是計算機的思維方式
計算思維是人類求解問題的一條途徑，但決非要使人類像計算機那樣地思考。計算機枯燥且沉悶，人類聰穎且富有想像力。是人類賦予計算機激情。配置了計算設備，我們就能用自己的智慧去解決那些在計算時代之前不敢嘗試的問題，實現「只有想不到，沒有做不到」的境界。
9．計算思維是數學和工程思維的互補與融合
計算機科學在本質上源自數學思維，因為像所有的科學一樣，其形式化基礎建築於數學之上。計算機科學又從本質上源自工程思維，因為我們建造的是能夠與實際世界互動的系統，基本計算設備的限制迫使計算機學家必須計算性地思考，不能只是數學性地思考。構建虛擬世界的自由使我們能夠設計超越物理世界的各種系統。

H. 博弈邏輯的博弈邏輯的例子

一個分蛋糕的例子：n個人分一塊大蛋糕，每個人都希望能最大化自己的所得，那麼怎麼分才公平呢？（這里的公平是指每個人都認為自己可以使自己分得的那部分不少於1/n。）
如果n=2，可以使用歷史悠久的「我分你選」演算法，可以實行公平的分配。當n>=3時，有幾種可能的分法。人們討論一種「修整法」：當第一個人切下一塊「屬於」他的蛋糕時，這塊蛋糕必須由其他n–1個人進行審查，在審查過程中，如果有人覺得這塊蛋糕太大，可以對它進行修整，切下的那些放回原處。蛋糕被輪流檢查過以後，如果這n-1個人當中沒有任何人修整它，這塊蛋糕就屬於第一個人，如果至少有一個人對它進行了修整，那麼這塊蛋糕就屬於最後一個修整它的人。這種演算法能保證蛋糕的公平分配，可以通過博弈邏輯這一工具對此加以證明 。

I. C語言 五子棋 博弈樹演算法 葉子節點的分值是如何計算的

其實這個不是難點的，那個分數是當前落子後所形成的以這個棋子為中心的9x9矩陣中所形成的棋型，計算其他地方的棋型顯然沒有什麼意義，再有就是不是C語言才可以寫演算法的，對於極大極小原理，博弈樹和alpha-beta剪枝演算法都是基於這個原理的，如果你是剛學編程不久，而且沒有數據結構的基礎是寫不出來運用博弈樹演算法的五子棋的，先把基礎打好再說。。