從人落子開始到出現勝負或者和局，之間所落的子，構成了一個解。而解空間就是一個樹，解就是這解空間中的一條路徑。只不過這個解空間是電腦的選擇和人的選擇共同構成的（奇數層是電腦（因為輪到電腦落子麼），偶數層是人）。

極大極小值搜尋演算法，來搜尋（回溯）這個解空間：它假設人和電腦都是極其聰明的，他們都會選擇出最優的一步。

但是搜尋整棵樹是不現實的，16*16！指數級，所以只回溯n步，即這個AI考慮的是N步之內的最優解，它是考慮了n步之後的情況的

-------------------------------------------------------------------我是分割線-------------------------------------------------------------------------

假設玩家執黑子，電腦執白子

評估函式：評估函式將對棋盤上的所有黑子做出評分（連成線的等級越高，數量越多，估分就越高）作scorehumber；也將對棋盤上的所有白子做出評分（連成線的等級越高，數量越多，估分就越高）作scorecomputer。然後評估值為【scorecoputer-scorehumber】。它將認為，這個評估值越高，整個局面對電腦越有利；這個評估值越低，整個局面對玩家越有利。

max-min搜尋最優解，即向後回溯depth步，輪到電腦時，電腦做出最有利於自己的選擇（選擇最高的評估值），輪到玩家時，玩家做出最有利於自己的選擇（選擇最低的評估值）。（他們的選擇將被推遲，葉子節點先做出選擇，然後層層往上推出那一層的最優解

int MinMax(int depth) { // 函式的評估都是以白方的角度來評估的
　if (SideToMove() == WHITE) {　// 白方是“最大”者 
　　return Max(depth); 
　} else {　　　　　　　　　　　// 黑方是“最小”者 
　　return Min(depth); 
　} 
} 　 
int Max(int depth) { 
　int best = -INFINITY; 
　if (depth <= 0) { 
　　return Evaluate(); 
　} 
　GenerateLegalMoves(); 
　while (MovesLeft()) { 
　　MakeNextMove(); 
　　val = Min(depth - 1); 
　　UnmakeMove(); 
　　if (val > best) { 
　　　best = val; 
　　} 
　} 
　return best; 
} 　 
int Min(int depth) { 
　int best = INFINITY;　// 注意這裡不同於“最大”演算法 
　if (depth <= 0) { 
　　return Evaluate(); 
　} 
　GenerateLegalMoves(); 
　while (MovesLeft()) { 
　　MakeNextMove(); 
　　val = Max(depth - 1); 
　　UnmakeMove(); 
　　if (val < best) { 　// 注意這裡不同於“最大”演算法 
　　　best = val; 
　　} 
　} 
　return best; 
} 
 

計分板

int max_noalphabeta(int depth,int i1,int i2);//輪到電腦走步時，電腦作的選擇 
int min_noalphabeta(int depth,int i1,int i2);//輪到人走步時，人作的選擇 
void generatepoint(vector< pair<int,int> > &v);//產生空子序列 
int scoretable(int number,int empty1);//積分表 
int countscore(vector<int> n,int turn);	//算單個數組分 
bool hasne(int x,int y);//周圍是否有子存在，無子的就加考慮 

bool hasne(int x,int y)//空子只算旁邊有子的
{
	int i,j;
	for(i=(x-3>0?x-3:0);i<=x+3&&i<16;++i)
		for(j=(y-3>0?y-3:0);j<=y+3&&j<16;++j)
			if(i!=0||j!=0)
				if(pos[i][j]!=0)
					return true;
	return false;
} 
void generatepoint(vector< pair<int,int> > &v)//產生空子序列		
{
	for(int i=0;i<16;++i)
		for(int j=0;j<16;++j)
			if(pos[i][j]==0&&hasne(i,j))
			{
				pair<int,int> p;
				p.first=i;
				p.second=j;
				v.push_back(p);
			} 
}
//按照成五100000、活四10000、活三1000、活二100、活一10、死四1000、死三100、死二10的規則 
//給棋盤上的所有棋子打分，之和為電腦的單方面得分scorecomputer，然後對玩家的棋子同樣打分，之和為scorehumber
//scoreComputer-scorehumber即為當前局勢的總分數 
int scoretable(int number,int empty1)//計分板
{
	if(number>=5)	return 100000;
	else if(number==4)
	{
		if(empty1==2)	return 10000;
		else if(empty1==1)	return 1000;
	}
	else if(number==3)	
	{
		if(empty1==2)	return 1000;
		else if(empty1==1)	return 100;
	}
	else if(number==2)
	{
		if(empty1==2)	return 100;
		else if(empty1==1)	return 10;
	}
	else if(number==1&&empty1==2)	return 10;
	return 0;
}
int countscore(vector<int> n,int turn)//正斜線、反斜線、橫、豎，均轉成一維陣列來計算 
{
	int scoretmp=0;
	int len=n.size();
	int empty1=0;
	int number=0;
	if(n[0]==0)	++empty1;
	else if(n[0]==turn)	++number;
	int i=1;
	while(i<len)
	{
		if(n[i]==turn)	++number;
		else if(n[i]==0)
		{
			if(number==0)	empty1=1;
			else
			{
				scoretmp+=scoretable(number,empty1+1);
				empty1=1;
				number=0;
			}
		}
		else
		{
			scoretmp+=scoretable(number,empty1);
			empty1=0;
			number=0;
		}
		++i;
	}
	scoretmp+=scoretable(number,empty1);
	return scoretmp;
}
int evaluate_minmax_noalphabeta()//評估函式，評估局勢
{
	int scorecomputer=0;
	int scorehumber=0;
	//橫排們 
	for(int i=0;i<16;++i)
	{
		vector<int> n;
		for(int j=0;j<16;++j)
			n.push_back(pos[i][j]);
		scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	}
	//豎排們
	for(int j=0;j<16;++j)
	{
		vector<int> n;
		for(int i=0;i<16;++i)
			n.push_back(pos[i][j]);
		scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	} 
	//上半正斜線們 
	for(int i=0;i<16;++i)
	{
		int x,y;
		vector<int> n;
		for(x=i,y=0;x<16&&y<16;++x,++y)
			n.push_back(pos[y][x]);
		scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	} 
	//下半正斜線們
	for(int j=1;j<16;++j)
	{
		int x,y;
		vector<int> n;
		for(x=0,y=j;y<16&&x<16;++x,++y)
			n.push_back(pos[y][x]);
	 	scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	} 
	//上半反斜線們
	for(int i=0;i<16;++i)
	{
		vector<int> n;
		int x,y;
		for(y=i,x=0;y>=0&&x<16;--y,++x)
			n.push_back(pos[y][x]);
		scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	} 
	//下半反斜線們
	for(int j=1;j<16;++j)
	{
		vector<int> n;
		int x,y;
		for(y=j,x=15;y<16&&x>=0;++y,--x)
			n.push_back(pos[x][y]);
		scorecomputer+=countscore(n,2);
		scorehumber+=countscore(n,1);
		n.clear();
	} 
	return scorecomputer-scorehumber;
} 
int min_noalphabeta(int depth,int i1,int i2)//玩家落子時													//當min（人）走步時，人的最好情況 
{
	int res=evaluate_minmax_noalphabeta();
	Chess cc;
	cc.chess_isover(i1,i2,2);
	if(isover!=0||depth<=0)
	{
		isover=0;
		return res;
	}
	vector< pair<int,int> > v;
	generatepoint(v);
	int len=v.size();
	int best=INT_MAX;
	for(int i=0;i<len;++i)
	{
		pos[v[i].first][v[i].second]=1;
		int tmp=max_noalphabeta(depth-1,v[i].first,v[i].second);
		if(tmp<best)	best=tmp;//玩家落子時選擇最有利自己的局面，將推遲，葉子節點做出選擇後，層層往上推	
		pos[v[i].first][v[i].second]=0;
	} 
	return best;
}
int max_noalphabeta(int depth,int i1,int i2)													//當max（電腦）走步時，max（電腦）應該考慮最好的情況 
{
	int res=evaluate_minmax_noalphabeta();
	Chess cc;
	cc.chess_isover(i1,i2,1);
	if(isover!=0||depth<=0)
	{
		isover=0;
		return res;
	}
	vector< pair<int,int> > v;
	generatepoint(v);
	int len=v.size();
	int best=INT_MIN;
	for(int i=0;i<len;++i)
	{
		pos[v[i].first][v[i].second]=2;
		int tmp=min_noalphabeta(depth-1,v[i].first,v[i].second);
		if(tmp>best)	best=tmp;//電腦落子時，選擇最有利於自己的局面，將推遲	
		pos[v[i].first][v[i].second]=0;
	} 
	return best;
}
void Chess::chess_ai_minmax_noalphabeta(int &x,int &y,int depth)//極大極小值演算法搜尋n步後的最優解 
{
	vector< pair<int,int> > v;
	generatepoint(v);
	int best=INT_MIN;
	int len=v.size();
	vector< pair<int,int> > v2; 
	for(int i=0;i<len;++i)
	{
		pos[v[i].first][v[i].second]=2;	//選該子，將該子置白，防止後面遞迴時，再遞迴到 
		int tmp=min_noalphabeta(depth-1,v[i].first,v[i].second);
		if(tmp==best)
			v2.push_back(v[i]);
		if(tmp>best)
		{
			best=tmp;
			v2.clear();
			v2.push_back(v[i]);
		}
		pos[v[i].first][v[i].second]=0;	//假設完之後，該子需要重新置空，恢復原來的樣子 
	}
	len=v2.size();
	int i=(int)(rand()%len);
	x=v2[i].first;
	y=v2[i].second; 
}

http://blog.csdn.net/lihongxun945/article/details/50625267

http://blog.csdn.net/kingkong1024/article/details/7639401