1.初始状态即是初始节点（先手）。

2.博弈树的or与and节点逐层交替出现，因为二人交替出招。

3.整个博弈过程始终站在一方角度，所以可使自己胜利的结局都是本原问题，相应的节点是可解节点，所有使对方胜利的节点为不可解节点。

4.博弈树从一开始产生，他包含问题所有可能情况，但是我们在使用时，他可能并不会全部展开（生成），这取决于我们要预测多远（搜索深度）以及已经做出的操作，事实上我们在最大最小搜索中某一时期所用的搜索树只是博弈树的一部分。

极大极小搜索

极大极小搜索（选择最好，避免最差），即为博弈搜索常用策略。

为了选择最好，避免最差，我们需要一个对于做出选择后的评估函数evaluate()，来作为我们选择的标准。假设博弈双方为MIN，MAX，规定对于有利于MAX方的态势，evaluate取正值，对于有利于MIN的evaluate取负值。对双方利益相同时evaluate取0

1.当MAX走时，MAX考虑对自己最好的情况（evaluate极大）

2.当MIN走时，MAX考虑对自己最坏的情况（evaluate极小）

3.评价往回倒推时，交替1.2来计算传递评价（通俗地讲就是生成几层搜索树，然后再依据MIN-MAX选择返回上层，由返回值决定最初的选择）

Wiki伪代码

function minimax(node, depth, maximizingPlayer)
02     if depth = 0 or node is a terminal node
03         return the heuristic value of node04     if maximizingPlayer
05         bestValue := ?∞
06         for each child of node
07             v := minimax(child, depth ? 1, FALSE)
08             bestValue := max(bestValue, v)
09         return bestValue10     else    (* minimizing player *)
11         bestValue := +∞
12         for each child of node
13             v := minimax(child, depth ? 1, TRUE)
14             bestValue := min(bestValue, v)
15         return bestValue

具体表现即为下图

最上层的MAX选手走，其有两种选择，每种选择后MIN选手走，最后如此重复，生成4层搜索树（这里只是向前估计2步，所以设置为4层，生成树的过程就是一个简单的广搜）。

1.    评估第四层每一个局面的评估值assessed_val，

2.    依据极大极小原则从底层返回上层（图中红色笔标记出返回路径），即MIN节点的选择其下属的节点的最小值作为自身的值，MAX选择其下属的最大的值。

3.    顶层依据返回方向，选择合理下一步，图中表现为MAX选择走左边的节点对应的那一步。

4.    重复再每一步时使用1-4的判决策略，直到某一方胜利或者平局。

井字游戏博弈代码

#include <iostream>
#include <queue>
#include <cstring>
#include <assert.h>
//MIN_MAX搜索，无Alpha与beta剪枝
using namespace std;const int MAX_INT = 65535;
const int MIN_INT = -65535;class ChessBoard{short *ptr;int how_win(int maxplayer) {//空白全下，可胜局数 ChessBoard *tmp =new ChessBoard();(*tmp) = (*this);int re=0;for(int i=0;i<cols*rows;i++) if(tmp->ptr[i]==0) tmp->ptr[i] = maxplayer;int sum = 0;for(int i=0;i<rows;i++) {sum = 0;for(int j=0;j<cols;j++) sum+=tmp->ptr[i*cols+j];if(maxplayer==1&&sum==3) re++;if(maxplayer==-1&&sum==-3) re++;}for(int i=0;i<cols;i++) {sum = 0;for(int j=0;j<rows;j++) sum+=tmp->ptr[j*cols+i];if(maxplayer==1&&sum==3) re++;if(maxplayer==-1&&sum==-3) re++;}sum = 0;for(int i=0;i<rows;i++) sum +=tmp->ptr[i*cols+i];if(maxplayer==1&&sum==3) re++;if(maxplayer==-1&&sum==-3) re++;sum = 0;for(int i=0,j=2;i<rows;i++,j--) sum +=tmp->ptr[i*cols+j];if(maxplayer==1&&sum==3) re++;if(maxplayer==-1&&sum==-3) re++;delete tmp;return re;}public://井子棋 3*3 bool max_player;                        //max选手的棋局int rows,cols;ChessBoard *childs;ChessBoard *next_borther;ChessBoard *father;int value;                       //评估值 ChessBoard(int rows=3,int cols=3) {this->rows = rows;this->cols = cols;ptr = new short[rows*cols]; for(int i=0;i<rows*cols;i++) ptr[i] = 0;next_borther = childs = NULL; }~ChessBoard() {this->rows = 0;this->cols = 0;if(ptr) delete [] ptr;ptr = NULL;}void operator = (ChessBoard &other) {//复制棋盘 if(this->rows!=other.rows || this->cols != other.cols ) return ;for(int i=0;i<rows*cols;i++) ptr[i] = other.ptr[i];}short& operator [] (int n) {return ptr[n];}void put(int row,int col,bool max_player) {//假设坐标合理输入 if(ptr[row*cols+col]==0) {ptr[row*cols+col] = max_player?1:-1;this->max_player = !max_player;}}void put_child(ChessBoard *child) {child->next_borther = childs;childs = child;}int where_is_void(int where[]) {//查看now中空白位置，并返回数量n以及位置where = i*cols+jint n=0;for(int i=0;i<rows*cols;i++) {if(ptr[i] == 0) where[n++] = i;}return n;}void show() {//cout<<"++++"<<endl;for(int i=0;i<rows;i++) {for(int j=0;j<cols;j++) {char c = '-';if(ptr[i*cols+j]==1) c = 'o';if(ptr[i*cols+j]==-1) c = 'x'; cout<<c;}cout<<endl;}cout<<"++++"<<endl;}int who_win() {int sum = 0;for(int i=0;i<rows;i++) {sum = 0;for(int j=0;j<cols;j++) sum+=ptr[i*cols+j];if(sum==3) return 1;if(sum==-3) return -1;}for(int i=0;i<cols;i++) {sum = 0;for(int j=0;j<rows;j++) sum+=ptr[i+cols*j];if(sum==3) return 1;if(sum==-3) return -1;}sum = 0;for(int i=0;i<rows;i++) sum +=ptr[i*cols+i];if(sum==3) return 1;if(sum==-3) return -1;sum = 0;for(int i=0,j=2;i<rows;i++,j--) sum +=ptr[i*cols+j];if(sum==3) return 1;if(sum==-3) return -1;return 0;//平局 }int evaluate() {//关键if(who_win()==1) return MAX_INT;else if(who_win()==-1) return MIN_INT;return (how_win(1) - how_win(-1));} }; void creat_Tree(queue<ChessBoard*> &qu_chess,ChessBoard &now,int layer=4) {//广度优先生成树  int size = now.rows*now.cols;int where[size];                       //row = where/(cols);col = where%(cols) qu_chess.push(&now); qu_chess.push(NULL);                 //第一层结束标志 while(!qu_chess.empty()) {ChessBoard *live = qu_chess.front();   //取出一节点作为扩展节点qu_chess.pop(); if(!live) {layer--; if(0==layer) break;              //生成layer层后退出 qu_chess.push(NULL);          //作为一层结束标志 live = qu_chess.front();        qu_chess.pop();}              int n = live->where_is_void(where);           //可放棋子位置与个数 for(int j=0;j<n;j++) {ChessBoard *child = new ChessBoard();(*child) = (*live);child->put(where[j]/(child->cols),where[j]%(child->cols),(live->max_player));child->father = live;            live->put_child(child);      qu_chess.push(child);           //孩子待扩展  }}
}void dispose_tree(ChessBoard *node) {//释放node的搜索树 (except node )if(node->childs == NULL) return ;else {ChessBoard *next,*tmp = node->childs;while(tmp) {dispose_tree(tmp);next = tmp->next_borther;delete tmp;tmp = next;}}
}int minmax_recu(ChessBoard *node,int depth,bool max_player) {//递归极大极小判断 if(depth==0 || node->childs==NULL) {        //到达指定深度或者节点不可扩展 return node->evaluate();    }if(max_player) {                           //此次操作为MAX int bestval = MIN_INT;ChessBoard *tmp = node->childs;while(tmp) {                           //所有孩子取最大 tmp->value = minmax_recu(tmp,depth-1,false);bestval = max<int>(bestval,tmp->value);tmp = tmp->next_borther;}return bestval;} else {                                 //此次操作为MINint bestval = MAX_INT;                             ChessBoard *tmp = node->childs;while(tmp) {                          //所有孩子取最小 tmp->value = minmax_recu(tmp,depth-1,true);bestval = min<int>(bestval,tmp->value);tmp = tmp->next_borther;}return bestval;}
} void MAX_MIN_search(ChessBoard &now_node,int &row,int &col) {//极大极小搜索//给出初始局面，计算四步推算下一步走法(row,col) queue<ChessBoard*> qu_chess;//生成2层搜索树creat_Tree(qu_chess,now_node,2); //反向极大极小推理，得到目标步骤 now_node.value = minmax_recu(&now_node,2,now_node.max_player);ChessBoard *tmp = now_node.childs->childs;tmp = now_node.childs;while(tmp && tmp->value!=now_node.value) {tmp = tmp->next_borther;}for(int i=0;i<now_node.rows*now_node.cols;i++) if(now_node[i]!=(*tmp)[i]) {row = i/(now_node.cols);col = i%(now_node.cols);}//销毁搜索树 dispose_tree(&now_node);} int main() {//这里只做了一步预测//实际模拟可以实例化两个CHessBoard,分别作为对手//各自都以自己为MAX来完成自行对弈 //其次，在搜索中若一定会出现平局或者最终根本赢不了时, //这里给出的中间步骤无参考性。 ChessBoard p;int next_row=0,next_col=0;//设置初态 p.put(2,2,true);p.put(0,2,false);MAX_MIN_search(p,next_row,next_col);p.put(next_row,next_col,true);p.show();return 0;
}

关于单纯极大极小搜索的说明

剪枝规则总结

1.    A剪枝：任何MIN的B小于任何他的先辈MAX的A时，停止该MIN以下的所有搜索，这个MIN的最终倒推值为当前的B值。（该B可能与真正的不同，但是没关系，不影响最终结果）

2.    B剪枝：任何MAX的A大于或者等与他的先辈MIN的B时，停止该MAX节点以下的所有搜索，这个MAX的最终倒推值为当前的A值。

过程见下图解（标出真正搜索过的路径）

红色笔画出箭头的地方为搜索经过的地方，没有箭头的为被剪枝部分。

标注出的红色数字为该节点的A或者B值。

下图为另一图解（标出剪枝部分）

A-  剪枝的效率与最先生成的A-B值与最终的倒推值有关，越相近，剪枝越提前并越快。

最佳情况下搜索深度为d的叶节点数相当于单纯MINMAX生成的深度为d/2的博弈树的节点数。有效分支系数为sqrt(b)，而不是b，即假设某一步有4种情况，而用上A-B剪枝，情况变为2种。