1.1 博弈论(sg函数）

博弈论

出自于省赛的丢人，算是第一篇博客吧，来学习博弈论

---

巴什博弈

• 只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。
  最后取光者得胜。

显然，如果n=m+1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个，

后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则：

如果n=（m+1）r+s，（r为任意自然数，s≤m),那么先取者要拿走s个物品，如果后取者拿走
k（≤m)个，那么先取者再拿走m+1-k个，结果剩下（m+1）（r-1）个，以后保持这样的
取法，那么先取者肯定获胜。总之，要保持给对手留下（m+1）的倍数，就能最后获胜。

---

威佐夫博弈

• 有两堆各若干个物品，两个人轮流从某一堆或同时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。

我们再用逆推归纳法分析。我们用（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。

若两堆物品的初始值为（a , b），且x < y，定义k=b-a；定义x = [ ( ( sqrt(5) + 1 ) / 2 ) * k ]
若x=a，则先手必败，否则先手必胜。

---

Nim博弈

• 有n堆各若干个物品，两个人轮流从某一堆取任意多的物品，规定每次至少取一个，多者不限，最后取光者得胜。

这里奇异局势变成了多堆(x1,x2,x3…..)，所以有一个结论就是把每堆Xi异或起来，结果为0则先手必败

---

sg函数

在网上看过了很多介绍sg函数的文章，但是感觉还是不太明白，就像当初第一次知道dp的时候。。。。。所以，还是自己再进行以下，浅显的个人理解。
sg函数：SG(x)=mex{ SG(y) | x->y }，mex(x)表示非x集合中最小的自然数
以下就是个人的浅显理解：
在解释之前，首先要知道sg值只需要关注0和非0两种状态就行了

在看了mex函数之后，是不是感觉字面理解了，但是，啥意思呢？
首先，一个点的下一个状态，也就是子状态会有很多个，然后每个子状态又会有自己的子状态。当一个状态的子状态可以直接判断为必胜态或者必败态的时候，子状态返回自己的sg值，然后，用一个vis数组存下来，这里vis数组就相当于mex函数，然后当当前状态的所有子状态都返回了自己的sg值，并用vis记录了下来，那么，vis从0开始，没有被标记过的第一个自然数则是当前状态的sg值。
当一个值被vis数组记录过，那么说明当前状态可以转换成对应sg值的状态，那么，如果0被标记了，那么说明当前状态可以转换成必败态，呢么当前状态的sg值一定是非0的，也就是必胜态。到这里，mex函数的意义是不是有点明白了，就是寻找第一个不能转换到的状态，那么，在看之前说的只需要关注0和非0两种状态就行了，意思就是，当你通过mex函数也就是vis数组找到的当前点的sg值为0则说明，当前点没办法转换到必败态，那么，当前点就是必败态，所以sg值为0；反之，非0则说明可以转换到必败态，那么当前则是必胜态。

当所有点的sg值都推出来了，答案一般就是所求点的sg值异或，异或值为0则先手必败，否则先手必胜。

那么，之前求出来的sg值非0时会有相同的值，那想一下，一旦出现了两个相同的先手必胜态，先手走什么，后手模仿的话，那么肯定是先手输，所以sg值非0相同时，异或值也是0，这个应该比较好想。

以上就是个人的理解，如有错误，希望大家帮我指出，不胜感激。

以下就是一些入门级的博弈论题目，有很多种解法，为了练习sg函数，就用的是sg函数的解法。希望大家能从中受益。

题目+代码

HOJ1847（单堆取次幂）

sg入门 ：

#include
using namespace std;

int main() {
    int n = 0;
    int cnt[10];
    int sg[1005];
    int s[1005];
    memset(cnt,0,sizeof(cnt));
    for(int i = 0; i < 11; i++) {
        cnt[i] = 1<memset(sg,0,sizeof(sg));
    sg[0] = 0;
    for(int i = 0; i < 1005; i++) {
        memset(s,0,sizeof(s));
        for(int j = 0;cnt[j] <= i;j++){
            s[sg[i-cnt[j]]] = 1;
        }
        int j = 0;
        while(s[j])
            j++;
        sg[i] = j;
    }
    while(cin >> n) {
        if(sg[n])
            cout << "Kiki" << endl;
        else
            cout <<"Cici" << endl;
    }
}

HOJ3980（环取连续段）

#include
using namespace std;
int s[1008];
int ss[1008];
int sg(int n,int m) {

    s[m] = 1;
    for(int i = m+1; i <= n; i++) {
        memset(ss,0,sizeof(ss));
        for(int j =0 ; j < i-m; j++) {
            ss[s[j]^s[i-m-j]] = 1;
        }
        int j =0 ;
        while(ss[j])
            j++;
        s[i] = j;
    }
    return s[n];
}

int main() {
    int t;
    cin >> t;
    int cnt = 0;
    while(t--) {
        memset(s,0,sizeof(s));
        cnt++;
        int n,m;
        cin >> n >> m;
        cout << "Case #" << cnt << ": ";
        if(n < m) {
            cout << "abcdxyzk" << endl;
        } 
        else {
            int ans = sg(n-m,m);
            if(ans)
                cout << "abcdxyzk" << endl;
            else
                cout << "aekdycoin" << endl;
        }
    }
}

POJ3537（同上一题，只不过要判断好子情况实际上最大是5个单位）

//#include
#include
#include

using namespace std;
int s[2008];
int sg[2008];

int main() {
    //int t;
    //cin >> t;
    //int cnt = 0;
    memset(sg,0,sizeof(sg)); 
    sg[1] = sg[3] = sg[2] = 1;                  //      sg函数初始值 
    for(int i = 4; i <= 2000; i++) {            //      第一个需要递推的状况 
        memset(s,0,sizeof(s));
        for(int j = 2 ; j <= i-1; j++) {        

//      模板，j是最小的子情况，i-m是另一边长度（这里m=1）

            if(i-1-j < 2)                       

//      每放下一个，就会使左右两边2个的位置变成必败态

                s[sg[j-2]^0] = 1;        

//      端点位置不够2个时，位置不够的为必败态，另一边长度则减2 

            else
                s[sg[i-1-j-2]^sg[j-2]] = 1;

//      sg[i]实际就是子情况的异或
        }
        int j = 0 ;
        while(s[j])
            j++;
        sg[i] = j;
    }
    int n = 0;
    while(cin >> n) {   
    //  cnt++;
    //  int n;
    //  cin >> n;
        if(sg[n])
            cout << 1 << endl;
        else
            cout << 2 << endl;
    }
}

poj1704（阶梯博弈）

Nim博弈进阶版，原型是有N堆石子，每次可以向左移动一堆中m个，最少一个，移到地面就不能动了，谁先不能移动谁就输了。
这个，根据分析，只要保证自己移动奇数堆，或者对方移动了偶数堆的后，把新加入奇数堆的
再移动到偶数堆，就能保证最终对面一直只能移动偶数堆，从而自己先手获胜。
所以，只需要让奇数堆石子数异或起来不等于0，则先手必胜。
这里，因为棋子不能在同一个格子，每个棋子最多只能贴在上一个棋子后面，所以，想象一下，把每两个棋子中的间隔当作一堆棋子，因为每两个棋子会发现，只要前一个动，后一个再贴上就和没有变化一样，所以，两个为一组，那么每两个中间的间隔，就是一堆石子，所以就又转化为前面说的阶梯博弈了。当然，这里到了第一个格子就没法动了，所以，有奇数个棋子的时候，就当作在“0”的位置还有一个棋子就可以了。

#include
#include
#include
#include
using namespace std;

int a[10005];
int main() {
    int t = 0;
    cin >> t;
    while(t--) {
        int ans = 0;
        memset(a,0,sizeof(a));
        int n =0;
        cin >> n;
        for(int i =1 ;i <= n;i++){
            cin >> a[i];
        }
        sort(a+1,a+n+1);
        for(int i = n;i > 0;i-=2 ){
            ans ^= (a[i]-a[i-1]-1);           

//    每一堆棋子间隙为石子数量

        }
        if(ans)
            cout << "Georgia will win" << endl;
        else
            cout << "Bob will win" << endl;

    }
}

poj2425（在图上的Nim博弈）

    //#include
    #include
    #include
    #include
    #include
    using namespace std;

    int a[1005][1005];
    int s[1005];
    int sg[1005];
    int vis[1005][1005];
    int dfs(int n,int x)
    {
        if(s[x])
            return sg[x];
        else{
            for(int i = 0;i < n;i++){        //还是模板，dfs充当了第一层for
                if(a[x][i]){          
                    vis[x][dfs(n,i)] = 1;    
                    //这里因为是在图上记录sg值，所以vis数组开成二维数组
                }
            }
//调试
            /*cout << x << ":" << endl;
            for(int h = 0;h < n;h++){
                cout << vis[x][h] << "**";
            }
            cout << endl;*/
//调试结束
            int j = 0;
            while(vis[x][j]){ 
                j++;
            } 
            sg[x] = j;
            s[x] = 1;              //s[x]=1表示sg值已确定
            return sg[x];
        }
    }
    int main() {
        std::ios::sync_with_stdio(false);
        cin.tie();
        int n;
        while(cin >> n) {
            if(n == 0)
                return 0;
            memset(a,0,sizeof(a));
            memset(s,0,sizeof(s));
            memset(sg,0,sizeof(sg));
            memset(vis,0,sizeof(vis));
            for(int i = 0; i < n; i++) {
                int m;
                cin >> m;
                if(m == 0)
                    s[i] = 1;
                for(int j = 0;j < m;j++){
                    int x =0;
                    cin >> x;
                    a[i][x] = 1;
                }
            }
//调试
            /*for(int i = 0;i < n;i++){ 
                for(int j =0;j < n;j++)
                    cout << a[i][j] << " ";
                cout << endl; 
            } */
//调试结束


            for(int i = 0;i < n;i++)
                sg[i] = dfs(n,i); 

//调试
            /*for(int i = 0;i < n;i++){
                cout << i << ":" << sg[i] << endl;
            }*/
//调试结束
            int q;
            while(cin >> q){
                if(q == 0)
                    break;
                    int ans = 0;
                for(int i = 0;i < q;i++){
                    int num;
                    cin >> num;
                    ans ^= sg[num]; //答案依然是各个点的sg值异或
                }
                if(ans)
                    cout << "WIN" << endl;
                else
                    cout << "LOSE" << endl;
            }
        }
    }