一．巴什博奕（Bash Game）：
首先我们来玩一个比较古老的报数游戏。A和B一起报数，每个人每次最少报一个,最多报4个。轮流报数,看谁先报到30.
如果不知道巴什博弈的可能会觉得这个是个有运气成分的问题，但是如果知道的人一定知道怎样一定可以赢。
比如A先报数的话,那么B一定可以赢(这里假定B知道怎么正确的报数)
B可以这样报数,每次报5-k(A)个数,其中k(A)是A报数的个数这样的话没一次
两人报完数之后会变成5 10 15 20 25 30这样是不是B一定会赢呢?是不是有一种被欺骗的感觉呢?好吧下面我们来看看这个原理。我们先看下一个一眼就能看出答案的例子 比如说我们报到5(4+1),每次报最多报4个,最少报1个.那么是不是后者一定可以赢呢？答案是肯定的。好了到这巴什博弈的精髓基本就OK了。
那么如果我们要报到n+1,每次最多报n个,最少报1个的话,后者一定能够赢。
现在我们需要报数到n,而每次最多报数m个,最少报数1个.我们可以化成这样
n = k*(1+m)+r(0 <= r <= m）这样的话如果r不等于0那么先手一定会赢，为什么呢？首先先手报r个,那么剩下k倍(1+m)个数,那么我们每次报数1+m-k(B)个数就一定能保证最后剩下1+m个,那么就到了上面我们说的那个了,先手就一定会赢,如果r=0那么后手一定会赢,道理一样的。
到这巴什博弈也就介绍完了,知道这个道理之后我们也可以去骗小朋友了。-_-//
#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define CLR(arr, val) memset(arr, val, sizeof(arr))
using namespace std;
int main()
{
//freopen("Input.txt", "r", stdin);
int N, num, limit;
scanf("%d", &N);
while(N--)
{
scanf("%d%d", &num, &limit);
if(num % (limit + 1) != 0) //必胜局面
printf("Win
");
else
printf("Lose
");
}
return 0;
}二．威佐夫博奕（Wythoff Game）：
这种博弈比前面一种要稍微复杂一点。我们来看下下面这个游戏。
有两堆火柴棍,每次可以从某一堆取至少1根火柴棍(无上限)，或者从两堆取相同的火柴棍数。最后取完的是胜利者。好了,如果你不知道这个博弈定理,对于小数目的火柴棍数,可能还能推出来,但是如果火柴棍数一多,就不行了。看了下面的这个介绍,你也会有一种被骗的感觉。
首先我们知道两堆火柴是没有差别的,也就是说第一堆有a根,第二堆有b根和第一堆有b根,第二堆有a根是一样的结果。
我们用一个二维的状态（a,b)来记录当前剩下的火柴数，表示第一堆剩下a根火柴,第二堆剩下b根火柴。同样我们假设两个人的编号是A和B，且A先取。
那么如果某个人遇到了这样的状态(0,0)那么也就是说这个人输了。这样的状态我们叫做奇异状态,也可以叫做失败态。
那么接下来的几个失败态为(1,2),(3,5),(4,7),(6,10),(8,13)……
我们用a[i]表示失败态中的第一个,b[i]表示失败态中的第二个.(i从0开始).
那么我们可以看到b[i] = a[i]+i;（i >= 0）,a[i]是前面的失败态中没有出现过的最小的整数
下面我们可以得到三个基本的结论。
1.每个数仅包含在一个失败态中
首先我们知道a[k]是不可能和前面的失败态中的a[i],b[i]重复的(这点由a[i]的得到可以知道)
b[k] = a[k]+k > a[k-1]+k>a[k-1]+k-1+1>a[k-1]+(k-1) = b[k-1]>a[k-1]这样我们知道每个数仅在一个失败态中。
2.每个失败态可以转到非失败态。
加入当前的失败态为(a,b)，那么如果我们只在一堆中取的话,肯定会变成非失败态(这点由第一点可以保证),如果从两堆同时取的话,由于每个失败态的差是不一样的,所以也不可能得到一个失败态。也就是说一个失败态不管你怎么取,都会得到一个非失败态。
3.每个非失败态都可以转到一个失败态
对于这个结论,首先我们要知到每个状态(a,b)要么a = a[i],要么b = b[i].(每个数都出现在一个失败态中),下面我们分两种情况来讨论
I.a = a[i].如果b = a的话那么一次取完就变成了(0,0).如果b > b[i]的话,那么我们从第二堆中取走b-b[i]就变成了一个失败态。如果b < b[i].那么我们从两堆中同时取走a-a[b-a[i]]这样得到失败态(a[b-a[i]],a[b-a[i]]+b-a[i])(a[i] = a)
II.b = b[i].如果a > a[i]那么我们从第一堆中取走a-a[i]根火柴.
如果a < a[i].这里又分两种情况。第一是a = a[k](k < i)
那么我们从第二堆取走b - b[k]就行了。
第二是a = b[k]这样的话由于两堆火柴是没有区别的,所以我们把b变成a[k]就行了,也即是从第二堆火柴中取走b - a[k]就变成了失败态
至于怎么判断一个状态是否是失败态.我们可以用下面的方法来判断(本人暂时还不会证明)
a[i] = [i*(1+√5)/2](这里的中括号表示向下取整) b[i] = a[i]+i;
那么这就是一个失败态
代码如下：
#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define CLR(arr, val) memset(arr, val, sizeof(arr))
using namespace std;
int main()
{
//freopen("Input.txt", "r", stdin);
int num1, num2, tmp; //第一堆剩的数量为num1,第二堆剩num2
while(scanf("%d%d", &num1, &num2) != EOF)
{
if(num1 > num2)
swap(num1, num2);
tmp = floor((num2 - num1) * (1 + sqrt(5.0)) / 2.0); //黄金分割
if(tmp == num1) printf("Lose
"); //奇异局势必败
else printf("Win
");
}
return 0;
} 三．尼姆博奕（Nimm Game）：
指的是这样的一个博弈游戏，目前有任意堆石子，每堆石子个数也是任意的，双方轮流从中取出石子，规则如下：
1)每一步应取走至少一枚石子；每一步只能从某一堆中取走部分或全部石子；
2)如果谁取到最后一枚石子就胜。
也就是尼姆博弈（Nimm Game）。
必败局面：也叫奇异局势。无论做出何出操作，最终结果都是输的局面。必败局面经过2次操作后，可以达到另一个必败局面。
必胜局面：经过1次操作后可以达到必败局面。
即当前局面不是必败局面就是必胜局面，而必胜局面可以一步转变成必败局面。
最终状态：
（1）最后剩下一堆石子；（必胜局面）
（2）剩下两堆，每堆一个；（必败局面）
（3）当石子剩下两堆，其中一堆只剩下1颗，另一堆剩下多于n颗石子时，当前取的人只需将多于1颗的那一堆取出n-1颗，则局面变为刚才提到的必败局面。（必胜局面）
判断当前局势是否为必胜（必败）局势：
1）把所有堆的石子数目用二进制数表示出来，当全部这些数按位异或结果为0时当前局面为必败局面，否则为必胜局面；
2）在必胜局面下，因为所有数按位异或的结果是大于零的，那么通过一次取，将这个（大于其它所有数按位异或的结果的）数下降到其它所有数按位异或的结果，这时局面就变为必败局面了。
定理：一组自然数中必然存在一个数，它大于等于其它所有数按位异或的结果。
证明：原命题等价于，设a1＾a2＾... ＾an=p，p≠0时，必存在k，使得ak＾p<ak（当p=0时，对于任意的k，有ak＾p=ak）。
设p的最高位是第q位，则至少存在一个k，使得ak的第q位也是1，而ak＾p的第q位为0，所以ak^p<ak
补缀一点，（a＾b）＾b=a＾（b＾b）=a＾0=a，所以ak＾p相当于“其它所有数按位异或的结果”。
例1：2 45 45
45＾45＝0,45和45的异或等于0。
例 2：3 3 6 9
局势（3,6，9）因为3＾6＾9不等于0，所以这是一个必胜局势。
3 011
＾6 110
5 101
即从第3堆中的9个中取走9－5＝4个，则（3,6，9）－＞（3,6，5），3＾6＾5＝0，故（3,6，5）为奇异局势，即从必胜局势转变成必败局势。
代码如下：
#include<iostream>
using namespace std;
int temp[ 20 ]; //火柴的堆数
int main()
{
int i, n, min;
while( cin >> n )
{
for( i = 0; i < n; i++ )
cin >> temp[ i ]; //第i个火柴堆的数量
min = temp[ 0 ];
for( i = 1; i < n ; i++ )
min = min^temp[ i ]; //按位异或
if( min == 0 )
cout << "Lose" << endl; //输
else
cout << "Win" << 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(c)，那么SG(x) = mex{SG(a),SG(b),SG(c)}。 这样 集合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;
}
}
}例题
A:LightOJ-1186 Incredible Chess:题意：棋盘上每一纵列有黑白两个棋子， 黑色一定在白色上方，两个人一人各执一色， 白色先走，每次操作可以把自己的颜色向上或者向下移动任意格， 但是不能超出范围也不能越过另一色的棋， 无法操作的一方败。思路：nim博弈， 将两个棋子之间的距离看作是堆中的石子的数量， 然后就转化成一个简单的nim博弈。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#define maxn 10005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int main()
{
int n;
int t,T=1;
cin>>t;
int a[110],b[110];
while(t--){
cin>>n;
int ans=0;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n;i++){
cin>>b[i];
}
for(int i=0;i<n;i++)
ans^=(b[i]-a[i]-1);
if(ans==0)
printf("Case %d: black wins
",T++);
else
printf("Case %d: white wins
",T++);
}
return 0;
}B:LightOJ-1192 Left Right:给定n对点，每一对点中第一个点向右走，第二个点向左右，不能跨越...谁不能走谁输...问最后谁赢。
和上一题同样的思路；
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#define maxn 10005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int main()
{
int n;
int t,T=1;
cin>>t;
while(t--){
cin>>n;
int ans=0;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
ans^=(y-x-1);
}
if(ans==0)
printf("Case %d: Bob
",T++);
else
printf("Case %d: Alice
",T++);
}
return 0;
}C:LightOJ-1253 Misere Nim:在K堆石子的任意堆中任取>0个石子，Alice为先手，Bob为后手，先取完者输掉比赛（注意这里）。
思路没什么说的就是改成先取完输。具体怎么写模板改一下就行了。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#define maxn 10005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int main()
{
int n;
int t,T=1;
cin>>t;
while(t--){
cin>>n;
int ans=0,f=0;
for(int i=0;i<n;i++){
int x;
cin>>x;
ans^=x;
if(x>1)
f=1;
}
if(f==0){
if(n%2)
printf("Case %d: Bob
",T++);
else
printf("Case %d: Alice
",T++);
}
else{
if(ans==0)
printf("Case %d: Bob
",T++);
else
printf("Case %d: Alice
",T++);
}
}
return 0;
}D:LightOJ-1393 Crazy Calendar:题意：给定n*m的一个方格，每个方格含x个石子，Pinky 先手，每次向右或者下移动， 谁不能移动谁输。思路：如果该方格中的一个点的坐标与n+m的奇偶性相同，则不需要考虑该点。因为若该点与n+m奇偶性相同，设该点坐标为(i,j)(0<=i<=n,0<=j<=m)则(n+m)-（i+j），即到达终点的步数为偶数，也就是说先手怎么移动后手就怎么移动，也就是说等于没移动。所以我们只需要考虑与n+m不同的,说白了也就是意思n+m和i+j一个奇数一个偶数，也就是说，这些点距离终点只需要也只能移动一次，每次可以从一个方格中取任意个石子移动，这就转化为了尼姆博弈中的取石子问题，因为尼姆博弈中可以随意取石子。异或为0为必败态一定会转化为必胜态，异或为1为必胜态可以转化为必败态，具体详见下最基础的尼姆博弈--取石子问题，就ok了。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#define maxn 10005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int main()
{
int n,m;
int t,T=1;
cin>>t;
while(t--){
cin>>n>>m;
int ans=0;
int tem=(n+m)%2;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
int x;
cin>>x;
if((i+j)%2!=tem)
ans^=x;
}
}
if(ans==0)
printf("Case %d: lose
",T++);
else
printf("Case %d: win
",T++);
}
return 0;
}E:HDU-2516 取石子游戏:题意：1堆石子有n个,两人轮流取.先取者第1次可以取任意多个，但不能全部取完.以后每次取的石子数不能超过上次取子数的2倍。取完者胜.思路： 斐波那契博弈，n为斐波那契数时先手必败，记录一下斐波那契数即可。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#define maxn 10005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int main()
{
int n,fib[50];
fib[0]=2;
fib[1]=3;
for(int i=2;i<=50;i++)
fib[i]=fib[i-1]+fib[i-2];
while(cin>>n&&n){
int flag=1;
for(int i=0;i<=50;i++){
if(fib[i]==n)
flag=0;
if(fib[i]>n)
break;
}
if(flag)
cout<<"First win"<<endl;
else
cout<<"Second win"<<endl;
}
return 0;
}