博弈论（巴什博奕，威佐夫博弈，尼姆博弈，斐波那契博弈，sg函数）

原文：http://blog.csdn.net/ac_gibson/article/details/41624623

一.  巴什博奕（Bash Game）：

  A和B一块报数，每人每次报最少1个，最多报4个，看谁先报到30。这应该是最古老的关于巴什博奕的游戏了吧。

其实如果知道原理，这游戏一点运气成分都没有，只和先手后手有关，比如第一次报数，A报k个数，那么B报5-k个数，那么B报数之后问题就变为，A和B一块报数，看谁先报到25了，进而变为20,15,10,5，当到5的时候，不管A怎么报数，最后一个数肯定是B报的，可以看出，作为后手的B在个游戏中是不会输的。

那么如果我们要报n个数，每次最少报一个，最多报m个，我们可以找到这么一个整数k和r，使n=k*（m+1）+r，代入上面的例子我们就可以知道，如果r=0，那么先手必败；否则，先手必胜。

 

巴什博奕：只有一堆n个物品，两个人轮流从中取物，规定每次最少取一个，最多取m个，最后取光者为胜。

代码如下：

[cpp] view plain copy

1. #include <iostream>  
2. using namespace std;  
3. int main()  
4. {  
5.     int n,m;  
6.     while(cin>>n>>m)  
7.       if(n%(m+1)==0)  cout<<"后手必胜"<<endl;  
8.       else cout<<"先手必胜"<<endl;  
9.     return 0;  
10. }  

 

例题有：HDU4764  Stone：

题目大意：Tang和Jiang轮流写数字，Tang先写，每次写的数x满足1<=x<=k，Jiang每次写的数y满足1<=y-x<=k，谁先写到不小于n的数算输。

结论：r=（n-1）%（k+1），r=0时Jiang胜，否则Tang胜。

 

 

二.  威佐夫博弈（Wythoff Game）：

有两堆各若干的物品，两人轮流从其中一堆取至少一件物品，至多不限，或从两堆中同时取相同件物品，规定最后取完者胜利。

直接说结论了，若两堆物品的初始值为（x，y），且x<y，则另z=y-x；

记w=（int）[（（sqrt（5）+1）/2）*z  ]；

若w=x，则先手必败，否则先手必胜。

代码如下：

[cpp] view plain copy

1. #include <cstdio>  
2. #include <cmath>  
3. #include <iostream>  
4. using namespace std;  
5. int main()  
6. {  
7.     int n1,n2,temp;  
8.     while(cin>>n1>>n2)  
9.     {  
10.         if(n1>n2)  swap(n1,n2);  
11.         temp=floor((n2-n1)*(1+sqrt(5.0))/2.0);  
12.         if(temp==n1) cout<<"后手必胜"<<endl;  
13.         else cout<<"先手必胜"<<endl;  
14.     }  
15.     return 0;  
16. }  

 

三.  尼姆博弈（Nimm Game）：

尼姆博弈指的是这样一个博弈游戏：有任意堆物品，每堆物品的个数是任意的，双方轮流从中取物品，每一次只能从一堆物品中取部分或全部物品，最少取一件，取到最后一件物品的人获胜。

结论就是：把每堆物品数全部异或起来，如果得到的值为0，那么先手必败，否则先手必胜。

代码如下：

[cpp] view plain copy

1. #include <cstdio>  
2. #include <cmath>  
3. #include <iostream>  
4. using namespace std;  
5. int main()  
6. {  
7.     int n,ans,temp;  
8.     while(cin>>n)  
9.     {  
10.         temp=0;  
11.         for(int i=0;i<n;i++)  
12.         {  
13.             cin>>ans;  
14.             temp^=ans;  
15.         }  
16.         if(temp==0)  cout<<"后手必胜"<<endl;  
17.         else cout<<"先手必胜"<<endl;  
18.     }  
19.     return 0;  
20. }  

 

四.  斐波那契博弈：

有一堆物品，两人轮流取物品，先手最少取一个，至多无上限，但不能把物品取完，之后每次取的物品数不能超过上一次取的物品数的二倍且至少为一件，取走最后一件物品的人获胜。

结论是：先手胜当且仅当n不是斐波那契数（n为物品总数）

如HDU2516

[cpp] view plain copy

1. #include <iostream>    
2. #include <string.h>    
3. #include <stdio.h>    
4. using namespace std;    
5. const int N = 55;      
6. int f[N];     
7. void Init()    
8. {    
9.     f[0] = f[1] = 1;    
10.     for(int i=2;i<N;i++)    
11.         f[i] = f[i-1] + f[i-2];    
12. }      
13. int main()    
14. {    
15.     Init();    
16.     int n;    
17.     while(cin>>n)    
18.     {    
19.         if(n == 0) break;    
20.         bool flag = 0;    
21.         for(int i=0;i<N;i++)    
22.         {    
23.             if(f[i] == n)    
24.             {    
25.                 flag = 1;    
26.                 break;    
27.             }    
28.         }    
29.         if(flag) puts("Second win");    
30.         else     puts("First win");    
31.     }    
32.     return 0;    
33. }   

五.  SG函数：http://blog.csdn.net/strangedbly/article/details/51137432

解题模型：

1.把原游戏分解成多个独立的子游戏，则原游戏的SG函数值是它的所有子游戏的SG函数值的异或。

       即sg(G)=sg(G1)^sg(G2)^...^sg(Gn)。

2.分别考虑没一个子游戏，计算其SG值。

     SG值的计算方法：（重点）

      1.可选步数为1~m的连续整数，直接取模即可，SG(x) = x % (m+1);

2.可选步数为任意步，SG(x) = x;

3.可选步数为一系列不连续的数，用模板计算。

        模板1：打表

  

[cpp] view plain copy

1. //f[]：可以取走的石子个数  
2. //sg[]:0~n的SG函数值  
3. //hash[]:mex{}  
4. int f[N],sg[N],hash[N];       
5. void getSG(int n)  
6. {  
7.     int i,j;  
8.     memset(sg,0,sizeof(sg));  
9.     for(i=1;i<=n;i++)  
10.     {  
11.         memset(hash,0,sizeof(hash));  
12.         for(j=1;f[j]<=i;j++)  
13.             hash[sg[i-f[j]]]=1;  
14.         for(j=0;j<=n;j++)    //求mes{}中未出现的最小的非负整数  
15.         {  
16.             if(hash[j]==0)  
17.             {  
18.                 sg[i]=j;  
19.                 break;  
20.             }  
21.         }  
22.     }  
23. }  

     

  模板二：DFS

[cpp] view plain copy

1. //注意 S数组要按从小到大排序 SG函数要初始化为-1 对于每个集合只需初始化1遍  
2. //n是集合s的大小 S[i]是定义的特殊取法规则的数组  
3. int s[110],sg[10010],n;  
4. int SG_dfs(int x)  
5. {  
6.     int i;  
7.     if(sg[x]!=-1)  
8.         return sg[x];  
9.     bool vis[110];  
10.     memset(vis,0,sizeof(vis));  
11.     for(i=0;i<n;i++)  
12.     {  
13.         if(x>=s[i])  
14.         {  
15.             SG_dfs(x-s[i]);  
16.             vis[sg[x-s[i]]]=1;  
17.         }  
18.     }  
19.     int e;  
20.     for(i=0;;i++)  
21.         if(!vis[i])  
22.         {  
23.             e=i;  
24.             break;  
25.         }  
26.     return sg[x]=e;  
27. }  

一般DFS只在打表解决不了的情况下用，首选打表预处理。

如

LightOJ 1315Game of Hyper Knights，此题打表不好处理，只好DFS。

3.计算sg(G)=sg(G1)^sg(G2)^...^sg(Gn)，

    sg(G)=0,即P-Position,即先手比败。