算法设计——极大极小搜索

转载 http://blog.csdn.net/urecvbnkuhbh_54245df/article/details/5811060

极大极小搜索策略一般都是使用在一些博弈类的游戏之中：

 

这样策略本质上使用的是深度搜索策略，所以一般可以使用递归的方法来实现。在搜索过程中，对本方有利的搜索点上应该取极大值，而对本方不利的搜索点上应该取极小值。

极小值和极大值都是相对而言的。

 

在搜索过程中需要合理的控制搜索深度，搜索的深度越深，效率越低，但是一般来说，走法越好。

 

极大极小搜索可以分开写，也可以放在一起写。

 

主要的算法步骤如下：

 

输入：搜索的深度

输出：节点的最佳走法，及其对应的最佳估值

函数形式：int minMaxSearch(int depth )   这里也可以添加int side参数表示当前谁是走棋方

 

如果轮到红方走棋，则

      初始化最优值best = 负无穷大                     //极大点        ，这里认为红方先走棋

否则

      初始化最优值best = 正无穷大                     //极小点

 

如果depth<= 0

      调用评估函数值

 

否则

      生成当前所有合理的走法

      对每一步走法

             执行走法

             调用minMaxSearch(depth -1 ) , 并把值赋给value

             撤销走法

 

             如果轮到红方走棋，则

                     如果value > best

                              best = value

                              如果depth == MAX_DEPTH

                                     bestMove = mv

             否则

                     如果value < best

                              best = value

                              如果depth == MAX_DEPTH

                                     bestMove = mv

 

返回best

 

在局面评估函数中一般返回双方优势的差值，以此作为评估值。

 

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

这里总结一下负极大值搜索策略：

一个局面对红方的优势为X，那么对于黑方的优势就是-X；一个局面对红方的优势为-X，对黑方的优势就是X。在负极大值搜索算法中，没有了极小点，只有极大点。需要注意的是，局面对一方的优势转化为另一方的优势时需要加负号。局面估计区间是一个关于0点对称的区间:

[-MaxValue,MaxValue].需要注意的是，为了能使负极大值搜索算法得到正确的评价，必须修改局面评估函数的返回值，原来在极大极小搜索算法中始终返回的是红方的优势，现在要改为当前走棋方的优势。

 

负极大值搜索算法：

 

输入：搜索深度

输出：节点的最佳走法，及对应的最佳估值

函数形式：int negaMaxSearch(int depth)

 

初始化最优值best=负无穷大                //都是极大点

如果depth小于等于0

       调用评估函数，并将结果赋给value

       返回value值

 

否则

      生成当前所有合法的走法

      对于每一步走法

            执行走法

            value= -negaMaxSearch(depth-1)             //注意函数之前有负号

            撤销走法

            如果 value> best

                    best=value

                    如果  depth == Max_Depth

                            bestMove=mv

返回best                                                                 //返回某个搜索分支的最优评估值

 

 

评估函数的算法:

 

输入：棋局

输出：局面对当前走方的优势

 

rValue:红方的优势总和

bValue：黑方的优势总和

 

分别进行评估，具体问题具体设计，获得rValue和bValue的值

 

如果当前局面是红方走棋

     return rValue-bValue;

否则

     return bValue-rValue;

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

极大极小搜索策略与负极大值搜索策略的改进——alpha-beta剪枝搜索策略

 

一般来说，为了在搜索过程中引起剪枝，在递归过程中要向下传递两个参数。第1个参数是alpha，它表示当前搜索节点走棋的一方搜索到的最好值，任何比它小的值都没有意义。第2个值是beta，表示对手目前的劣势，这是对手所能承受的最还的结果，比它大的值都会被舍弃。

因为是负极大值搜索，beta值越大，表示对方的劣势越明显，beta值越小，表示劣势也越小。

 

对于alpha-beta搜索剪枝算法，由于初始状态时还没有alpha-beta值，可以使用-MaxValue~MaxValue对应。

 

Alpha-Beta搜索剪枝算法如下：

 

输入：搜索深度、alpha、beta

输出：节点的最佳走法、及对应的最佳估值

函数形式：int alphaBetaSearch(int depth ,int alpha,int beta)

 

如果depth小于等于0

      调用评估函数，并将结果赋给value

      返回value值

否则

      生成当前所有合理的走法

      对每一个走法

           执行走法

           value= - alphaBetaSearch( depth-1 , -beta , -alpha)； 

           //注意函数前面有负值，且参数alpha，beta分别取负值并进行交换

           撤销走法

           如果 value>=beta             //使得可能引起的走法先被搜索，因为搜索的效率很大程度上取决于剪枝的效果

                  返回beta

          如果   value>alpha

                  alpha=value

                  如果 depth == Max_Depth

                  bestmove=mv

      返回alpha

 

调用形式：alphaBetaSearch（MaxDepth，-MaxValue，MaxValue）

习惯上把传递给一个待搜索节点的alpha和beta值组成的这个区间称为搜索窗口。

搜索窗口越窄，引发剪枝的可能性就越大，，搜索效率就越高。

传递给一个待搜索节点的alpha值会大于beta值吗？（绝对不会，连等于都不可能）。

 

 

下面是POJ3317 Stake your Claim的题目，分别使用负极大值搜索和alpha-beta剪枝优化的代码，从这个实验发现alpha-beta剪枝对效率的提高很有帮助。

 

下面是定义的一个局面评估的类：

 

[cpp]  view plain copy

1. #include<iostream>  
2. #include<cstring>  
3. using namespace std;  
4. /* 
5.  *  对局面进行评价的类  
6. */  
7. class Evaluater{  
8.       
9. public:  
10.       
11.     Evaluater(char map[][8],int s ):size(s){  
12.           
13.         //memcpy(square , map ,sizeof(map));  
14.         for(int i=0;i<8 ;i++)  
15.             for(int j=0 ; j<8 ; j++)  
16.                 square[i][j] = map[i][j];  
17.       
18.       
19.           
20.     }   
21.       
22.     /* 
23.     *   局面的评估函数  
24.     */   
25.     int getValuated(int side){  
26.       
27.         int p0Value=0,p1Value=0;  
28.         for(int i=0; i<size ; i++){  
29.           
30.             for(int j=0 ; j<size ; j++){  
31.               
32.                 if( '0' == square[i][j]){  
33.                       
34.                       
35.                     getMostSquares('0',i,j);  
36.                     if( count > p0Value)  
37.                         p0Value=count;  
38.                     count=1;  
39.                 }  
40.                   
41.                 if( '1' == square[i][j] ){  
42.                   
43.                       
44.                     getMostSquares('1',i,j);  
45.                     if(count > p1Value)  
46.                         p1Value= count ;  
47.                     count=1;  
48.                 }     
49.             }  
50.         }  
51.           
52.         if( 1 == side )  
53.             return p0Value - p1Value ;  
54.         else  
55.             return p1Value - p0Value ;  
56.       
57.     }  
58.   
59.   
60. private:  
61.   
62.     /* 
63.     *   搜索最大region中的己方棋子数量  
64.     */  
65.     void getMostSquares( char flag ,int x,int y){  
66.       
67.         static int dir[4][2]={{0,-1},{-1,0},{0,1},{1,0}};  
68.           
69.         int i,j;  
70.           
71.         square[x][y]='x';                   //试探过的空格标记为'x'   
72.           
73.         for(int k=0 ;k<4 ; k++ ){  
74.               
75.             i= x+ dir[k][0];  
76.             j= y+ dir[k][1];  
77.               
78.             if( i<0 || i>=size || j<0 || j>=size || square[i][j]!=flag )  
79.                 continue;  
80.                   
81.             else{  
82.                   
83.                 count++;  
84.                 getMostSquares( flag , i , j );  
85.              }  
86.                
87.         }  
88.           
89.           
90.     }  
91.   
92.       
93.     enum TableSize{MAX_SIZE=8};             //棋盘最大的大小   
94.     int size;                               //棋盘的实际大小   
95.     char square[MAX_SIZE][MAX_SIZE];        //棋盘   
96.     static int count;  
97. };  
98.   
99. int Evaluater::count=1;                     //静态变量一定要在类外初始化   

 

下面是负极大值搜索的实现：一开始使用极大极小总是得不到正确的结果，后来直接使用负极大值搜索策略，这里需要注意的是，负极大值搜索对应的评估函数需要针对不同的当前下棋方来来返回评估值，另外在搜索函数中，所有的点都是极大值的点，所以best的值就可以直接赋值为INT_MIN.在递归函数返回时，也不必进行side的判断了。

 

[cpp]  view plain copy

1. /* 
2.  *  POJ 3317 Stake Your Claim 
3.  *  这是一道博弈题  
4.  *  搜索策略：极大极小  
5. */   
6. #include<iostream>  
7. #include<fstream>  
8. #include<ctime>  
9. #define __DEBUG 0  
10. #include "MapEvaluate.h"  
11. using namespace std;   
12.   
13. #define MAX 8  
14.   
15. char map[MAX][MAX];  
16. int num;                    //棋盘的实际大小   
17. //1 :player0 , -1:player1  
18. int currSide;             
19. //最大的搜索深度  
20. int MAX_DEPTH;    
21.   
22.   
23. typedef struct move{  
24.       
25.     int x;  
26.     int y;  
27.     move(){}  
28.     move(int x1,int y1):x(x1),y(y1){}  
29.     friend ostream& operator<<(ostream& out,const move& m){  
30.           
31.         return out<<"("<<m.x<<","<<m.y<<")";  
32.     }  
33. }Move;  
34.   
35. Move bestMove;                  //最好的移动   
36.   
37. void print(){  
38.       
39.         for(int i=0 ; i<num ; i++){  
40.         for(int j=0 ; j< num ; j++){  
41.               
42.             cout<<map[i][j]<<" ";  
43.               
44.               
45.             }  
46.               
47.             cout<<endl;  
48.         }  
49. }  
50.   
51.   
52.   
53.   
54. /* 
55.  *  产生所有可能的移动方案  
56. */  
57. int genAllMove(Move* array){  
58.       
59.     int count=0;  
60.     for(int i=0 ; i<num ; i++)  
61.         for(int j=0 ; j< num ; j++){  
62.               
63.             if( '.' == map[i][j] ){  
64.                   
65.                 array[count]= Move(i,j);  
66.                 count++;  
67.             }  
68.                   
69.         }  
70.           
71.     return count;  
72.       
73. }  
74.   
75. /* 
76.  *  走棋  
77. */  
78. inline void makeMove(Move mv,int side){  
79.       
80.     map[mv.x][mv.y] = (1 == side)? '0': '1' ;  
81. }  
82.   
83. /* 
84.  *  还原棋盘  
85. */  
86. inline void unMakeMove(Move mv) {  
87.       
88.     map[mv.x][mv.y] = '.' ;  
89. }  
90.   
91. /* 
92.  *  极大极小搜索函数的核心算法  
93. */  
94. int negMaxSearch(int depth , int side) {  
95.       
96.     int best,value;  
97.     Move moveArray[12];                     //最多可能有1~10个空格   
98.     Move tmpMv;  
99.       
100.     //使用负极大值搜索时，best的值始终为INT_MIN   
101.     best = INT_MIN;  
102.           
103.     if( 0 == depth ){  
104.           
105.         Evaluater v(map,num);  
106.         return v.getValuated(side);  
107.     }  
108.           
109.           
110.     int num=genAllMove(moveArray) ;  
111.   
112.     for(int i =0 ; i< num ; i++){  
113.           
114.         tmpMv = moveArray[i];  
115.         makeMove(tmpMv,side) ;  
116.           
117.         if(__DEBUG){  
118.         print();  
119.         cout<<endl; }  
120.            
121.         //注意：这里不能用"~side ",否则side值一直为true   
122.         //这里side递归返回之后，side恢复原值，因为"!side"没有改变side的原值   
123. //      value = minMaxSearch(depth-1 , !side);  //每次变换走棋方   
124.         value = -minMaxSearch(depth -1 ,-1*side );  
125.           
126.           
127.         unMakeMove(tmpMv);  
128.   
129.         if(__DEBUG){  
130.         print();  
131.         cout<<endl; }  
132.           
133.         //负极大值搜索   
134.         if( value > best ){  
135.               
136.             best = value ;  
137.             if(depth == MAX_DEPTH)  
138.                 bestMove = tmpMv;  
139.         }  
140.           
141.     }  
142.     //返回最佳的极值   
143.     if( depth == MAX_DEPTH)   
144.         cout<<bestMove;  
145.     return best;  
146.       
147. }  
148.   
149.   
150. int main(){  
151.       
152.     ifstream in("test.txt");  
153.     int count0,count1;   
154.       
155.     while(1){  
156.           
157.         in>>num;  
158.         if(0 == num)  
159.             break;  
160.               
161.         //每局开始都初始化   
162.         count1=0;  
163.         count0=0;   
164.           
165.         for(int i=0; i<num ; i++){  
166.               
167.             for(int j=0 ; j<num ;j++){  
168.                   
169.                 in>>map[i][j];              
170.                 if( '1' == map[i][j]){  
171.                       
172.                     count1 ++;  
173.                 }  
174.                 if( '0' == map[i][j]){  
175.                       
176.                     count0 ++ ;  
177.                 }  
178.             }  
179.         }  
180.           
181.           
182.         currSide= (count0 >count1)? -1 : 1 ;  
183.         //对所有的空位进行搜索   
184.         MAX_DEPTH = num*num - count1 - count0;  
185.         if(__DEBUG){  
186.             cout<<currSide<<endl;  
187.             cout<<MAX_DEPTH<<endl;  
188.         }  
189.               
190.         clock_t time=clock();  
191.         cout<<" "<<negMaxSearch(MAX_DEPTH,currSide)<<endl;  
192.         cout<<"计算用时："<<clock()-time<<"MS"<<endl;  
193.   
194.     }  
195. }  

 

下面是增加alpha-beta剪枝后的代码，注意的是剪枝的方法：

 

[cpp]  view plain copy

1. /* 
2.  *  POJ 3317 Stake Your Claim 
3.  *  这是一道博弈题  
4.  *  搜索策略：极大极小  
5. */   
6. #include<iostream>  
7. #include<fstream>  
8. #include<ctime>  
9. #define __DEBUG 0  
10. #include "MapEvaluate.h"  
11. using namespace std;   
12.   
13. #define MAX 8  
14.   
15. char map[MAX][MAX];  
16. int num;                    //棋盘的实际大小   
17. //1 :player0 , -1:player1  
18. int currSide;             
19. //最大的搜索深度  
20. int MAX_DEPTH;    
21.   
22.   
23. typedef struct move{  
24.       
25.     int x;  
26.     int y;  
27.     move(){}  
28.     move(int x1,int y1):x(x1),y(y1){}  
29.     friend ostream& operator<<(ostream& out,const move& m){  
30.           
31.         return out<<"("<<m.x<<","<<m.y<<")";  
32.     }  
33. }Move;  
34.   
35. Move bestMove;                  //最好的移动   
36.   
37. void print(){  
38.       
39.         for(int i=0 ; i<num ; i++){  
40.         for(int j=0 ; j< num ; j++){  
41.               
42.             cout<<map[i][j]<<" ";  
43.               
44.               
45.             }  
46.               
47.             cout<<endl;  
48.         }  
49. }  
50.   
51.   
52.   
53.   
54. /* 
55.  *  产生所有可能的移动方案  
56. */  
57. int genAllMove(Move* array){  
58.       
59.     int count=0;  
60.     for(int i=0 ; i<num ; i++)  
61.         for(int j=0 ; j< num ; j++){  
62.               
63.             if( '.' == map[i][j] ){  
64.                   
65.                 array[count]= Move(i,j);  
66.                 count++;  
67.             }  
68.                   
69.         }  
70.           
71.     return count;  
72.       
73. }  
74.   
75. /* 
76.  *  走棋  
77. */  
78. inline void makeMove(Move mv,int side){  
79.       
80.     map[mv.x][mv.y] = (1 == side)? '0': '1' ;  
81. }  
82.   
83. /* 
84.  *  还原棋盘  
85. */  
86. inline void unMakeMove(Move mv) {  
87.       
88.     map[mv.x][mv.y] = '.' ;  
89. }  
90.   
91. /* 
92.  *  极大极小搜索函数的核心算法  
93. */  
94. int alphaBetaSearch(int depth , int side ,int alpha ,int beta) {  
95.       
96.     int best,value;  
97.     Move moveArray[12];                     //最多可能有1~10个空格   
98.     Move tmpMv;  
99.       
100.           
101.     if( 0 == depth ){  
102.           
103.         Evaluater v(map,num);  
104.         return v.getValuated(side);  
105.     }  
106.           
107.           
108.     int num=genAllMove(moveArray) ;  
109.   
110.     for(int i =0 ; i< num ; i++){  
111.           
112.         tmpMv = moveArray[i];  
113.         makeMove(tmpMv,side) ;  
114.           
115.         if(__DEBUG){  
116.         print();  
117.         cout<<endl; }  
118.            
119.         //注意：这里不能用"~side ",否则side值一直为true   
120.         //这里side递归返回之后，side恢复原值，因为"!side"没有改变side的原值   
121. //      value = minMaxSearch(depth-1 , !side);  //每次变换走棋方   
122.         value = -minMaxSearch(depth -1 ,-1*side, -beta , -alpha );  
123.           
124.           
125.         unMakeMove(tmpMv);  
126.   
127.         if(__DEBUG){  
128.         print();  
129.         cout<<endl; }  
130.           
131.         //alpha-beta剪枝搜索  
132.         if( value >= beta )   
133.             return beta ;  
134.         if( value > alpha ){  
135.               
136.             alpha = value ;  
137.             if(depth == MAX_DEPTH )  
138.                 bestMove = tmpMv ;  
139.         }  
140.           
141.     }  
142.     //返回最佳的极值   
143.     if( depth == MAX_DEPTH)   
144.         cout<<bestMove;  
145.     return alpha ;  
146.       
147. }  
148.   
149.   
150. int main(){  
151.       
152.     ifstream in("test.txt");  
153.     int count0,count1;   
154.       
155.     while(1){  
156.           
157.         in>>num;  
158.         if(0 == num)  
159.             break;  
160.               
161.         //每局开始都初始化   
162.         count1=0;  
163.         count0=0;   
164.           
165.         for(int i=0; i<num ; i++){  
166.               
167.             for(int j=0 ; j<num ;j++){  
168.                   
169.                 in>>map[i][j];              
170.                 if( '1' == map[i][j]){  
171.                       
172.                     count1 ++;  
173.                 }  
174.                 if( '0' == map[i][j]){  
175.                       
176.                     count0 ++ ;  
177.                 }  
178.             }  
179.         }  
180.           
181.           
182.         currSide= (count0 >count1)? -1 : 1 ;  
183.         //对所有的空位进行搜索   
184.         MAX_DEPTH = num*num - count1 - count0;  
185.         if(__DEBUG){  
186.             cout<<currSide<<endl;  
187.             cout<<MAX_DEPTH<<endl;  
188.         }  
189.               
190.         clock_t time=clock();  
191.         cout<<" "<<alphaBetaSearch(MAX_DEPTH,currSide,-100,100)<<endl;  
192.         cout<<"计算用时："<<clock()-time<<"MS"<<endl;  
193.   
194.     }  
195. }