博奕：博弈论（花里胡哨取石子）

一、巴什博弈（Bash Game）

只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。最后取光者得胜。
显然，如果n=m+1，1那么由于一次最多只能取m个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则：每个回合时m+1个，如果n=（m+1)*r+s，（r为任意自然数，s≤m),那么先取者要拿走s个物品，如果后取者拿走k（≤m)个，那么先取者再拿走m+1-k个，结果剩下（m+1）（r-1）个，以后保持这样的取法，那么先取者肯定获胜。总之，要保持给对手留下（m+1）的倍数，就能最后获胜。
总结上面的分析得出公式：有n个物品每次最多取m个，先取完的获胜，则n%(m+1)==0时为必胜状态。
取石子（一）
有一堆石子共有n个，A和B轮流取，A先，每次最少取1个，最多取m个，先取完者胜，A，B足够聪明，问谁先胜？
题解：
比较简单的巴什博弈，若n%(m+1)！=0，A胜，否则B胜。
如果 n=m+1，那么由于一次最多只能取 m 个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。只要保持给对手留下(m+1)的倍数,就能最后获胜。

#include <bits/stdc++.h>#define ms(a,b) memset(a,b,sizeof(a))typedef long long ll;using namespace std;const int maxn = 1e9+5;const int inf=1<<30; int main(){ int n,m; while(cin>>n>>m) if(n%(m+1)==0) cout<<"后手必胜"<<endl; else cout<<"先手必胜"<<endl; return 0;}

二、尼姆博奕（Nimm Game）

有三堆各若干个物品，两个人轮流从某一堆取任意多的物品，规定每次至少取一个，多者不限，最后取光者得胜。
这种情况与二进制有密切关系，我们用（a，b，c）表示某种局势，首先（0，0，0）显然是奇异局势，无论谁面对奇异局势，都必然失败。第二种奇异局势是（0，n，n），只要与对手拿走一样多的物品，最后都将导致（0，0，0）。仔细分析一下，（1，2，3）也是奇异局势，无论对手如何拿，接下来都可以变为（0，n，n）的情形。
计算机算法里面有一种叫做异或的运算，我们用符号⊕（或者是xor，这个符号不好打，以下用（+）表示）表示这种运算。这种运算和一般加法不同的一点是1+1=0。先看（1，2，3）的按位异或的结果：
1 =二进制01
2 =二进制10
3 =二进制11 （+）
———————
0 =二进制00 （注意不进位）
对于奇异局势（0，n，n）也一样，结果也是0。
任何奇异局势（a，b，c）都有a（+）b（+）c =0。
如果我们面对的是一个非奇异局势（a，b，c），要如何变为奇异局势呢？假设 a < b< c,我们只要将 c 变为 a（+）b,即可,因为有如下的运算结果: a（+）b（+）(a（+）b)=(a（+）a)（+）(b（+）b)=0（+）0=0。要将c 变为a（+）b，只要从 c中减去 c-（a（+）b）即可。
例1。（14，21，39），14（+）21=27，39-27=12，所以从39中拿走12个物体即可达到奇异局势（14，21，27）。
例2。（55，81，121），55（+）81=102，121-102=19，所以从121中拿走19个物品就形成了奇异局势（55，81，102）。
例3。（29，45，58），29（+）45=48，58-48=10，从58中拿走10个，变为（29，45，48）。
总结：
n堆物品，两人轮流取，每次取某堆中不少于1个，最后取完者胜。
将n堆物品数量全部异或后结果为0则必败，否则必胜。
取石子（二）
有n堆石子，每堆石子都有任意个，A和B轮流从取任意堆里取一定的石子，每次只能从一堆里至少取一个，A先取，先取完者胜，问谁胜？
题解：
把每堆物品数全部异或起来，如果得到的值为 0，那么先手必败，否则先手必胜。

#include <bits/stdc++.h>#define ms(a,b) memset(a,b,sizeof(a))typedef long long ll;using namespace std;const int maxn = 1e9+5;const int inf=1<<30; int main(){ int n,m; while(cin>>n) { temp=0; for(int i=0; i<n; i++) { cin>>ans; temp^=ans; } if(temp==0) cout<<"后手必胜"<<endl; else cout<<"先手必胜"<<endl; } return 0;}

取石子（三）
有t堆石子，每堆石子都有n个，A和B轮流从取任意堆里取一定的石子，每次只能从一堆里至少取一个最多取m个，A先取，先取完者胜，问谁胜？(0<=m,n<=2^31)）
尼姆博弈和巴什博弈的结合。

#include <bits/stdc++.h>#define ms(a,b) memset(a,b,sizeof(a))typedef long long ll;using namespace std;const int maxn = 1e9+5;const int inf=1<<30; int main(){ int n,m; int t; cin>>t; ans=0; while(t--) { cin>>n>>m; n=n%(m+1); ans^=n; } if(ans==0) cout<<"后手必胜"<<endl; else cout<<"先手必胜"<<endl; return 0;}

三、威佐夫博奕（Wythoff Game）

有两堆各若干个物品，两个人轮流从某一堆或同时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。
这种情况下是颇为复杂的。我们用（ak，bk）（ak ≤ bk ,k=0，1，2，…,n)表示两堆物品的数量并称其为局势，如果甲面对（0，0），那么甲已经输了，这种局势我们称为奇异局势。前几个奇异局势是：（0，0）、（1，2）、（3，5）、（4，7）、（6，10）、（8，13）、（9，15）、（11，18）、（12，20）
可以看出,a0=b0=0,ak是未在前面出现过的最小自然数,而 bk= ak + k，奇异局势有
如下三条性质：
1.任何自然数都包含在一个且仅有一个奇异局势中。
由于ak是未在前面出现过的最小自然数，所以有ak > ak-1 ，而 bk= ak + k > ak-1 + k-1 = bk-1 > ak-1 。所以性质1。成立。
2.任意操作都可将奇异局势变为非奇异局势。
事实上，若只改变奇异局势（ak，bk）的某一个分量，那么另一个分量不可能在其他奇异局势中，所以必然是非奇异局势。如果使（ak，bk）的两个分量同时减少，则由于其差不变，且不可能是其他奇异局势的差，因此也是非奇异局势。
3.采用适当的方法，可以将非奇异局势变为奇异局势。
从如上性质可知，两个人如果都采用正确操作，那么面对非奇异局势，先拿者必胜；反之，则后拿者取胜。
4.（Betty 定理）：如果存在正无理数 A, B 满足 1/A + 1/B = 1，那么集合 P = { [At], t ∈ Z+}、Q = { [Bt], t ∈ Z+} 恰为集合 Z+ 的一个划分，即：P ∪ Q = Z+，P ∩ Q = ø。
5.上述矩阵中每一行第一列的数为 [Φi]，第二列的数为 [(Φ + 1)i]，其中 Φ = (sqrt(5) + 1) / 2 为黄金分割比。
那么任给一个局势（a，b），怎样判断它是不是奇异局势呢？我们有如下公式：ak =[k（1+√5）/2]，bk= ak + k （k=0，1，2，…,n 方括号表示取整函数)
奇妙的是其中出现了黄金分割数（1+√5）/2 = 1.618…,因此,由ak，bk组成的矩形近似为黄金矩形，由于2/（1+√5）=（√5-1）/2，可以先求出j=[a（√5-1）/2]，若a=[（1+√5）/2]，那么a = aj，bj = aj + j，若不等于，那么a = aj+1，bj+1 = aj+1+ j + 1，若都不是，那么就不是奇异局势。然后再按照上述法则进行，一定会遇到奇异局势。（poj 1067）
总结：黄金分割比，首先求出差值，差值＊黄金分割==最小值的话后手赢，否则先手赢。
取石子（四）
两堆石子分别n，m（n>=m）个，A和B轮流取，有两种取法，一是在任意的一堆中取走任意多的石子，最少为一；二是在两堆中同时取走相同数量的石子。A先取，先取完者胜，问A是否胜？
结论：若（n-m）＊(sqrt(5.0)+1.0)/2.0 != m ,则先手胜，否则后手胜。

#include <bits/stdc++.h>#define ms(a,b) memset(a,b,sizeof(a))typedef long long ll;using namespace std;const int maxn = 1e9+5;const int inf=1<<30;int main(){ int n,m; cin>>n>>m; if(n<m)n^=m^=n^=m; if((n-m)*((sqrt(5.0)+1.0)/2.0)==m)cout<<"后手必胜"<<endl; else cout<<"先手必胜"<<endl; return 0;}

四、斐波那契博弈（Fibonacci’s Game）

有一堆个数为n的石子，游戏双方轮流取石子，满足：
1)先手不能在第一次把所有的石子取完；
2)之后每次可以取的石子数介于1到对手刚取的石子数的2倍之间（包含1和对手刚取的石子数的2倍）。
约定取走最后一个石子的人为赢家，求必败态。
这个和之后讲到的Wythoff’s Game 和取石子游戏 有一个很大的不同点，就是游戏规则的动态化。之前的规则中，每次可以取的石子的策略集合是基本固定的，但是这次有规则：一方每次可以取的石子数依赖于对手刚才取的石子数。
这个游戏叫做Fibonacci Nim，肯定和Fibonacci数列：f[n]：1,2,3,5,8,13,21,34,55,89,… 有密切的关系。如果试验一番之后，可以猜测：先手胜当且仅当n不是Fibonacci数。换句话说，必败态构成Fibonacci数列。
就像“Wythoff博弈”需要“Beatty定理”来帮忙一样，这里需要借助“Zeckendorf定理”（齐肯多夫定理）：任何正整数可以表示为若干个不连续的Fibonacci数之和。定理的证明可以在这里 看到，不过我觉得更重要的是自己动手分解一下。
比如，我们要分解83，注意到83被夹在55和89之间，于是把83可以写成83=55+28；然后再想办法分解28，28被夹在21和34之间，于是28=21+7；依此类推 7=5+2，故 ；
如果n=83，我们看看这个分解有什么指导意义：假如先手取2颗，那么后手无法取5颗或更多，而5是一个Fibonacci数，如果猜测正确的话，（面临这5颗的先手实际上是整个游戏的后手）那么一定是先手取走这5颗石子中的最后一颗，而这个我们可以通过第二类归纳法来绕过，同样的道理，接下去先手取走接下来的后21颗中的最后一颗，再取走后55颗中的最后一颗，那么先手赢。
反过来如果n是Fibonacci数，比如n=89：记先手一开始所取的石子数为y，若y>=34颗（也就是89的向前两项），那么一定后手赢，因为89-34=55=34+21<2*34，所以只需要考虑先手第一次取得石子数y<34的情况即可，所以现在剩下的石子数x介于55到89之间，它一定不是一个Fibonacci数，于是我们把x分解成Fibonacci数：x=55+f[i]+…+f[j]，若，如果f[j]<=2y，那么对B就是面临x局面的先手，所以根据之前的分析，B只要先取f[j]个即可，以后再按之前的分析就可保证必胜。
总结：先手胜当且仅当n不是Fibonacci数。
有一堆石子，A和B轮流从中取一定的石子，但规定：第一次不能取完，至少一个；从第二次开始，每个人取的石子数至少为1,至多为对手刚取的石子数的两倍。A先取，问A是否会胜？
结论：若先手对应的石子数目刚好是斐波那契数，则先手必败，否则必胜。
取石子（五）

#include <bits/stdc++.h>#define ms(a,b) memset(a,b,sizeof(a))typedef long long ll;using namespace std;const int maxn = 1e9+5;const int inf=1<<30;ll a[1001]={0,1};int main(){ ll n; for(int i=2;i<=100;i++)a[i]=a[i-1]+a[i-2]; cin>>n; int flag=0; for(int i=1;i<100;i++)if(a[i]==n)flag=1; if(flag)cout<<"先手必败"<<endl; else cout<<"先手必胜"<<endl; return 0;}

五、SG函数

首先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。
对于任意状态 x ， 定义 SG(x) = mex(S),其中 S 是 x 后继状态的SG函数值的集合。如 x 有三个后继状态分别为 SG(a),SG(b),SG©，那么SG(x) = mex{SG(a),SG(b),SG©}。 这样 集合S 的终态必然是空集，所以SG函数的终态为 SG(x) = 0,当且仅当 x 为必败点P时。
取石子（六）
有1堆n个的石子，每次只能取{ 1, 3, 4 }个石子，先取完石子者胜利，那么各个数的SG值为多少？
SG[0]=0，f[]={1,3,4},
x=1 时，可以取走1 - f{1}个石子，剩余{0}个，所以 SG[1] = mex{ SG[0] }= mex{0} = 1;
x=2 时，可以取走2 - f{1}个石子，剩余{1}个，所以 SG[2] = mex{ SG[1] }= mex{1} = 0;
x=3 时，可以取走3 - f{1,3}个石子，剩余{2,0}个，所以 SG[3] = mex{SG[2],SG[0]} = mex{0,0} =1;
x=4 时，可以取走4- f{1,3,4}个石子，剩余{3,1,0}个，所以 SG[4] = mex{SG[3],SG[1],SG[0]} = mex{1,1,0} = 2;
x=5 时，可以取走5 - f{1,3,4}个石子，剩余{4,2,1}个，所以SG[5] = mex{SG[4],SG[2],SG[1]} =mex{2,0,1} = 3;
以此类推…
x 0 1 2 3 4 5 6 7 8…
SG[x] 0 1 0 1 2 3 2 0 1…
由上述实例我们就可以得到SG函数值求解步骤，那么计算1~n的SG函数值步骤如下：
1、使用 数组f 将 可改变当前状态 的方式记录下来。
2、然后我们使用 另一个数组 将当前状态x 的后继状态标记。
3、最后模拟mex运算，也就是我们在标记值中 搜索 未被标记值 的最小值，将其赋值给SG(x)。
4、我们不断的重复 2 - 3 的步骤，就完成了 计算1~n 的函数值。

void getsg(int n){ bool mex[11111]; for(int i=0;i<n;i++) { memset(mex,false,sizeof(mex)); for (int j = 1; j <= k; ++j)//k为fa数组元素个数 { if (i - fa[j] >= 0) { mex[sg[i - fa[j]]] = true; } } for(int j=0;j<=n;j++) if(mex[j]==false) { sg[i]=j; break; } }