关于博弈论的一些整理

巴什博弈

样例

只有一堆n个物品，两个人轮流从这堆物品中取物， 规定每次至少取一个，最多取m个。最后取光者得胜。这个就是巴么博弈的原题。

1、先手取胜：每次最多取m个物品，如果轮到对面时剩下m+1个，那么先手必定获胜。
一开始有n个物体，我们可以在每次取出后剩下m+1的倍数个物体，只要维持这种状态，那么先手必胜。
2、由于知道了先手获胜的情况，那么我们就可以知道后手获胜的情况了，即开始时物体的个数是m+1的倍数，那么先手取完后无论如何也不可能剩下m+1的倍数个，后手必胜。

例题

HDU1946 Brave Game

#include<cstdio>
int main()
{
    int n,m,t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        if(n%(m+1)==0)printf("second\n");
        else printf("first\n");
    }
    return 0;
}

例题二

HDU 2149 Public Sale

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n%(m+1)==0)
            cout<<"none"<<endl;
        else if(n<=m)
        {
            for(int i=n;i<=m;i++)
            {
                cout<<i;
                if(i!=m)
                {
                    cout<<" ";
                }
            }
            cout<<endl;
        }
        else
            cout<<n%(m+1)<<endl;
    }
    return 0;
}

威佐夫博弈

样例

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

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
    double k=(1+sqrt(5))/2;
    int a,b;
    while(cin>>a>>b)
    {
        if(a>b)
            swap(a,b);
        int x=(b-a)*k;
        if(x==a)
        {
            cout<<0<<endl;
        }
        else
        {
            cout<<1<<endl;
        }
    }
    return 0;
}

斐波那契博弈

HDU2516 取石子游戏
这个题和巴什博奕差不多，不过先手必败态从m+1变为了斐波那契数列。

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
long long int arr[100];
int main()
{
    arr[0]=0;
    arr[1]=1;
    for(int i=2;i<=50;i++)
    {
        arr[i]=arr[i-1]+arr[i-2];
    }
    int a;
    while(scanf("%d",&a)&&a)
    {
        if(binary_search(arr,arr+50,a))cout<<"Second win"<<endl;
        else cout<<"First win"<<endl;
    }
    return 0;
}

尼姆博奕

HDU 1850 Being a Good Boy in Spring Festival
a¹^a²···^aⁿ==0(奇异局势),先手必败。

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int arr[105];
int main()
{
    int n;
    while(cin>>n,n)
    {
        int ans=0,res=0;
        for(int i=0;i<n;i++)
        {
            cin>>arr[i];
            ans^=arr[i];
        }
        if(ans==0)
            cout<<0<<endl;
        else
        {
            for(int i=0;i<n;i++)
            {
                int k=ans^arr[i];
                if(arr[i]>=k)
                    res++;
            }
            cout<<res<<endl;
        }
    }
    return 0;
}

SG函数

例题一

HDU1847 Good Luck in CET-4 Everybody!
必胜点和必败点的概念：
P点：必败点，换而言之，就是谁处于此位置，则在双方操作正确的情况下必败。
N点：必胜点，处于此情况下，双方操作均正确的情况下必胜。
当 n = 0 时，显然为必败点，因为此时你已经无法进行操作了
当 n = 1 时，因为你一次就可以拿完所有牌，故此时为必胜点
当 n = 2 时，也是一次就可以拿完，故此时为必胜点
当 n = 3 时，要么就是剩一张要么剩两张，无论怎么取对方都将面对必胜点，故这一点为必败点。
以此类推，最后你就可以得到；
n ： 0 1 2 3 4 5 6 …
position： P N N P N N P …

#include<iostream>
#include<cstring>
using namespace std;
int n,k;
int sg[10000],f[20],s[10000];
void sg1()
{
    memset(sg,0,sizeof(sg));
    for(int i=1;i<=1005;i++)
    {
        memset(s,0,sizeof(s));
        for(int j=0;f[j]<=i;j++)
        {
                s[sg[i-f[j]]]=1;
        }
        for(k=0;;k++)
        {
            //cout<<s[k]<<" ";
            if(s[k]==0)
            {
                sg[i]=k;
                break;
            }
        }
    }
}
int main()
{
    f[0]=1;
    for(int i=1;i<15;i++)
    {
        f[i]=f[i-1]*2;
    }
    sg1();
    //for(int i=0;i<1000;i++)
    //    cout<<sg[i]<<endl;
    while(cin>>n)
    {
        if(!sg[n])
            cout<<"Cici"<<endl;
        else
            cout<<"Kiki"<<endl;
    }
    return 0;
}

HDU1848 Fibonacciagain and again
思路同上

#include<iostream>
#include<cstring>
using namespace std;
int n,m,p,k;
int sg[10000],f[20],s[10000];
void sg1()
{
    memset(sg,0,sizeof(sg));
    for(int i=1;i<=1005;i++)
    {
        memset(s,0,sizeof(s));
        for(int j=0;f[j]<=i;j++)
        {
                s[sg[i-f[j]]]=1;
        }
        for(k=0;;k++)
        {
            //cout<<s[k]<<" ";
            if(s[k]==0)
            {
                sg[i]=k;
                break;
            }
        }
    }
}
int main()
{
    f[0]=1;
    f[1]=1;
    for(int i=2;i<19;i++)
    {
        f[i]=f[i-1]+f[i-2];
    }
    sg1();
    //for(int i=0;i<1000;i++)
      //  cout<<sg[i]<<endl;
    while(cin>>m>>n>>p)
    {
        if(m==0&&n==0&&p==0)
            break;
        if(sg[n]^sg[m]^sg[p])
            cout<<"Fibo"<<endl;
        else
            cout<<"Nacci"<<endl;
    }
    return 0;
}

SG函数模板

//f[N]:可改变当前状态的方式，N为方式的种类，f[N]要在getSG之前先预处理
//SG[]:0~n的SG函数值
//S[]:为x后继状态的集合
int f[N],SG[MAXN],S[MAXN];
void  getSG(int n){
    int i,j;
    memset(SG,0,sizeof(SG));
    //因为SG[0]始终等于0，所以i从1开始
    for(i = 1; i <= n; i++){
        //每一次都要将上一状态 的 后继集合 重置
        memset(S,0,sizeof(S));
        for(j = 0; f[j] <= i && j <= N; j++)
            S[SG[i-f[j]]] = 1;  //将后继状态的SG函数值进行标记
        for(j = 0;; j++) if(!S[j]){   //查询当前后继状态SG值中最小的非零值
            SG[i] = j;
            break;
        }
    }
}

转自一位神仙博客