博弈论 Nim游戏与SG函数

---

普通Nim游戏：
有若干堆石子，两人轮流从中取石子，取走最后一个石子的人为胜利者
我们判断先手必胜还是先手必败就要判断先手面对的局面是必胜态还是必败态
并且普通Nim游戏满足以下性质：
1.无法移动的状态是必败态
2.可以移动到必败态的局面一定是非必败态
3.在必败态做所有操作的结果都是非必败态
这些性质很好理解，就不予以证明了
接下来分析什么情况下是必败态
在普通Nim游戏中，a1^a2^a3^……^an=0是必败态
以下是证明：
从最简单的说起，若先手面对的是0 0 0 0 0 0这种局面，那么先手必败（xor为0 ）
如果a1^a2^……^ai^……^an=0，那么一定不存在某个合法操作使得ai变为ai’后依然满足a1^a2^……^ai’^……^an=0,因为xor满足消除性质，所以可以得出a1^a2^……^ai^……^an=0=a1^a2^……^ai’^……^an==>ai=ai’

所以如果先手面对的时xor=0的情况，先手必败，反之先手必胜
但是如果游戏变得稍微复杂一点，比如我规定了第一堆中只能取一颗，第二堆中只能取奇数课颗……这可怎么办呀———-锵锵锵锵！！！SG函数出场
SG函数全称为Sprague-Grundy 函数
现在我们来研究一个看上去似乎更为一般的游戏：给定一个有向无环图和一个起始顶 点上的一枚棋子，两名选手交替的将这枚棋子沿有向边进行移动，无法移动者判负。事实上，这个游戏可以认为是所有Impartial Combinatorial Games（也就是Nim游戏）的抽象模型。也就是说，任何一个ICG都可以通过把每个局面看成一个顶点，对每个局面和它的子局面连一条有向边来抽象成这个“有向图游戏”。下 面我们就在有向无环图的顶点上定义Sprague-Garundy函数。
首先定义mex(minimal excludant)运算，表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。
SG(x)=mex{SG(y) | x->y （y是x的后继）}，其实就是状态x能转移到y
对于所有的出度为0的点他们的sg函数都等于0，因为其后继集合为空集，对于每一个SG值为0的点，其后继中一定满足SG(y)！=0，对于每一个SG值不为0的点，其后继中一定存在一个SG(y)=0
以上的结论表明SG=0的点对应的是必败态，我们通过计算有向无环图每个顶点的SG值就可以找到必胜的策略
如果问题在复杂一点呢(⊙o⊙)…
让我们再来考虑一下顶点的SG值的意义。当g(x)=k时， 表明对于任意一个0<=i< k，都存在x的一个后继y满足g(y)=i。也就是说，当某枚棋子的SG值是k时，我们可以把它变成0、变成 1、……、变成k-1，但绝对不能保持k不变。不知道你能不能根据这个联想到Nim游戏，Nim游戏的规则就是：每次选择一堆数量为k的石子，可以把它变 成0、变成1、……、变成k-1，但绝对不能保持k不变。这表明，如果将n枚棋子所在的顶点的SG值看作n堆相应数量的石子，那么这个Nim游戏的每个必 胜策略都对应于原来这n枚棋子的必胜策略。
所以我们可以证明当选手处于必败态时，所有棋子所在节点的SG值xor=0
所 以我们可以定义有向图游戏的和(Sum of Graph Games)：设G1、G2、……、Gn是n个有向图游戏，定义游戏G是G1、G2、……、Gn的和(Sum)，游戏G的移动规则是：任选一个子游戏Gi 并移动上面的棋子。就可以得到以下式子：SG(G)=SG(G1)^SG(G2)^…^SG(Gn)。

如果你看了以上一堆证明感觉头大的话，我们来换一种小清新萌萌哒的证明方法：
考虑一个经常会遇到的问题：两个游戏的和。有两个游戏A和B，两个人玩，每个人每轮可以操作其中一个，但不能不操作，两个游戏都变为空集时输。
定义运算符+
A + B = {X + B | X ∈ A} ∪ {A + Y | Y ∈ B}
这是个递归定义。
于是我们来考虑SG(A + B)
容易知道：
SG(A + B) = mex({SG(X + B) | X ∈ A} ∪ {SG(A + Y) | Y ∈ B})
现在到了这里，大胆猜想吧……
经过数学家的一番折腾，发现SG(A + B) = SG(A) ^ SG(B)
其中x ^ y指x和y的异或值。

然后来考虑复杂问题：
取石子问题，有1堆n个的石子，每次只能取{1，3,4}个石子，先取完石子者胜利，那么各个数的SG值为多少？
sg[0]=0，f[]={1,3,4},
x=1时，可以取走1-f{1}个石子，剩余{0}个，mex{sg[0]}={0}，故sg[1]=1;
x=2时，可以取走2-f{1}个石子，剩余{1}个，mex{sg[1]}={1}，故sg[2]=0；
x=3时，可以取走3-f{1,3}个石子，剩余{2,0}个，mex{sg[2],sg[0]}={0,0}，故sg[3]=1;
x=4时，可以取走4-f{1,3,4}个石子，剩余{3,1,0}个，mex{sg[3],sg[1],sg[0]}={1,1,0},故sg[4]=2;
x=5时，可以取走5-f{1,3,4}个石子，剩余{4,2,1}个，mex{sg[4],sg[2],sg[1]}={2,0,1},故sg[5]=3；
以此类推…..
x 0 1 2 3 4 5 6 7 8….
sg[x] 0 1 0 1 2 3 2 0 1….
好晕啊+_+ T_T
不管了，反正我们可以得出以下性质
1.可选步数为1~m的连续整数，直接取模即可，SG(x) = x % (m+1);
2.可选步数为任意步，SG(x) = x;
3.可选步数为一系列不连续的数，用GetSG()计算
例题：BZOJ 1874
如果先手必胜则SGaixor！=0
否则先手必败，如果要知道第一步操作就暴力枚举
代码如下：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=1000+5;
int n,m,a[10+5],b[10+5],SG[maxn],vis[10+5];
void GETSG(int N){
    for(int i=1;i<=N;i++){
        memset(vis,0,sizeof(vis));
        for(int j=1;b[j]<=i&&j<=m;j++)
            vis[SG[i-b[j]]]=1;//i的后继状态即为 i-b[j],SG[i-b[j]]为后继状态到不了的状态,所以那个状态i也到不了 
        for(int j=0;j<=10;j++)//求mes中未出现的最小的自然数
            if(vis[j]==0){
                SG[i]=j;
                break;
            } 
    }
}
inline int read(){
    char ch=getchar();
    int f=1,x=0;
    while(!(ch>='0'&&ch<='9')){
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return f*x;
}
signed main(void){
    n=read();
    for(int i=1;i<=n;i++)
        a[i]=read();
    m=read();
    for(int i=1;i<=m;i++)
        b[i]=read();
    GETSG(1000);
    int ans=0;
    for(int i=1;i<=n;i++)
        ans^=SG[a[i]];
    if(!ans){
        cout<<"NO"<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m&&b[j]<=a[i];j++)
            if((ans^SG[a[i]])==SG[a[i]-b[j]]){
                cout<<"YES"<<endl<<i<<" "<<b[j]<<endl;
                return 0;
            }
    }
}

---

Anti-Nim BZOJ 1022
小约翰经常和他的哥哥玩一个非常有趣的游戏：桌子上有n堆石子，小约翰和他的哥哥轮流取石子，每个人取的时候，可以随意选择一堆石子，在这堆石子中取走任意多的石子，但不能一粒石子也不取，我们规定取到最后一粒石子的人算输。小约翰相当固执，他坚持认为先取的人有很大的优势，所以他总是先取石子，而他的哥哥就聪明多了，他从来没有在游戏中犯过错误。小约翰一怒之前请你来做他的参谋。自然，你应该先写一个程序，预测一下谁将获得游戏的胜利。
分析：
我们首先考虑最简单的情况–全都是1
如果有奇数堆，显然先手必败
偶数堆先手必胜
然后考虑下一种情况：
1 1 1 1 1 ……>1
先手必胜，为什么呢
如果前面有奇数个1，那么先手吧最后一堆取完，变成奇数个1，则后手必败
如果前面有偶数个1，那么先手把最后一堆取为1个，变成奇数堆1，后手必败
在这种情况下，sg函数也就是xor和≠0，先手必胜
如果能够保证每次先手取完之后xor=0那么先手必胜（因为后手不管怎么去sg函数一定不等于0，最后一定可以取乘1 1 1 1……>1的形式）
代码如下：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=5000+5;
int cas,n,cnt,flag,ans;
inline int read(){
    char ch=getchar();
    int f=1,x=0;
    while(!(ch>='0'&&ch<='9')){
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return f*x;
}
signed main(void){
    cas=read();
    while(cas--){
        n=read(),flag=1,ans=0;
        for(int i=1,x;i<=n;i++){
            x=read();
            if(x!=1)
                flag=0;
            ans^=x;
        }
        if(flag){
            if(n&1)
                cout<<"Brother"<<endl;
            else
                cout<<"John"<<endl;
        }
        else{
            if(ans==0)
                cout<<"Brother"<<endl;
            else
                cout<<"John"<<endl;
        }
    }
    return 0;
}

---