首先定义mex(minimal excludant)运算,这是施加于一个集合的运算,表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。

对于一个给定的有向无环图,定义关于图的每个顶点的Sprague-Grundy函数g如下:g(x)=mex{ g(y) | y是x的后继 },这里的g(x)即sg[x]

例如:取石子问题,有1堆n个的石子,每次只能取{1,3,4}个石子,先取完石子者胜利,那么各个数的SG值为多少?

sg[0]=0,f[]={1,3,4},  //我们可以将 f[] , 从小到大排序

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;

注意:

f[]需要从小到大排序

1.可选步数为1~m的连续整数,直接取模即可,SG(x) = x % (m+1);

2.可选步数为任意步,SG(x) = x;   , Nim问题

3.可选步数为一系列不连续的数,用GetSG()计算

模板1如下:

// SG打表, 利用动态规划

// f[] 为堆中可取的石子个数
// x为堆中石子的总数, 如果有多个堆, 取堆中最多数为x.
int
f[N],sg[N]; void getSG(int x) { sg[0]=0; for(int i=1; i<=x ; i++) // 这个x 是所有要用到的x 的最大值 { set<int>S; // 集合中无重复的元素, 且元素是按从小到大排序 for(int j=0 ; f[j]<= i; j++) // f[]数组 的下标是 从0开始的 S.insert(sg[i-f[j]]); int g=0; while(S.count(g) != 0) g++; sg[i] = g; } }

模板2如下:(dfs)

 sg[1] =mex{sg[0]} = mex{0}  sg[1] =1

sg[2] = mex{sg[1]} =  mex{1}  sg[2] = 0

sg[3] = mex{sg[2], sg[0]} = mex{0, 0} = 1

sg[4] = mex{sg[3], sg[1], sg[0]} = mex{1, 1, 0}  sg[4] = 2

sg[5] =  mex{sg[4], sg[2], sg[1]} = mex{2, 0, 1}  sg[5] = 3

 

代码如下:


//注意 f数组要按从小到大排序
//SG函数要初始化为-1 对于每个集合只需初始化1遍
//n是集合f的大小 f[i]是定义的特殊取法规则的数组



int
f[N_f],vis[N_f]; int sg[N_x],n; int SG_dfs(int x) { int i; if(sg[x]!=-1) return sg[x]; memset(vis,0,sizeof(vis)); for(i=0;i<n;i++) // n是集合f[]的大小 { if(x>=f[i]) { SG_dfs(x-f[i]); vis[sg[x-f[i]]]=1; } } int e; for(i=0;;i++) if(!vis[i]) { e=i; break; } return sg[x]=e; }

 hdu 1848 

三堆石子,  每堆只能去 fabonacci 数列。 直接对 三堆石子的总数 求 sg , 然后异或 ,即 sg[m]^sg[n]^sg[p] !=0. 。first 赢。 

代码如下:

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#define N 1010
using namespace std;
int f[17];
int sg[1005];
// F[16] = 1597,故Fibonacci 打表只需要达到16
void Fibo_init()
{
    f[1] =1;
    f[2]= 2;
    for(int i=3;i<=16; i++)
        f[i] = f[i-1] +f[i -2];
}
// SG函数打表
void init_SG(int x)
{
    sg[0] =0 ;
    for(int i=1; i<=x ; i++)
    {
        set<int>S;
        for(int j=1; f[j]<=i ; j++) //f[]下标从1开始
            S.insert(sg[i-f[j]]);
        int g=0;
        while(S.count(g)!= 0) g++;
        sg[i]= g;
    }
}

int main(){

    Fibo_init();
    init_SG(1000);
    int n,m,p,x;
    while(scanf("%d%d%d",&m,&n,&p)!=EOF)
    {
        if(m==0 && n==0 && p==0)
            break;
        x= sg[m]^sg[n]^sg[p];
        if(x) puts("Fibo");
        else
            puts("Nacci");
    }
    return 0;
}
View Code

  到此,我们需要更加深刻的理解多堆,表示多个游戏。是否具有像积性函数 这样的性质?

假设有N堆, 每堆数为x1,x2,...,xn,从中按照一定的数量规则f[]取石子。 

可以转换为, N 个棋子, 每个棋子为xi, 作为有向无环图的顶点, 分别计算 sg[xi].

 我们有个结论: 即当多个棋子的有向图游戏的局面是first赢, 当且仅当 所有棋子所在位置的sg函数值 异或 为 0.

所以我们可以定义有向图游戏的和(sum of Graph Games): 设G1,G2,、、、Gn 是n 个有向图游戏, 定义游戏G 是 G1,G2,..., Gn 的和, 游戏G 的移动规则为,  任选一个子游戏 Gi 并移动上面的棋子. Sprague- Grundy Theorem :就是:  sg[G] = sg[G1] ^sg[G2] ^...^sg[Gn]. 也就是说, 游戏的和 的SG函数值 是它的 所有子游戏 的sg 函数值的 异或。

可以参考:http://www.docin.com/p-557540496.html

 hdu 1847  , 一堆石子, 可以取的数组为 2的幂次(10次就可以了 , 2^10=1024>1000), 直接求sg[x],如果sg[x] !=0 first 赢

 Good Luck in CET-4 Everybody!

题目来源:http://acm.hdu.edu.cn/showproblem.php?pid=1847

代码如下:

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#define Inf 0x7fffffff // 0x 是数字0,而不是字母o
#define N 1010
using namespace std;
int f[11];
int sg[1005];

// SG函数打表
void init_SG(int x)
{
    sg[0] =0 ;
    for(int i=1; i<=x ; i++)
    {
        set<int>S;
        for(int j=0; f[j]<=i ; j++) //f[]下标从1开始
            S.insert(sg[i-f[j]]);
        int g=0;
        while(S.count(g)!= 0) g++;
        sg[i]= g;
    }
}

int main(){
   int x;
   for(int i=0 ; i<=10; i++)
       f[i]=pow(2.0,(double)i);
    init_SG(1000);
   while(cin>>x)
   {
        if(sg[x]) puts("Kiki");
        else puts("Cici");
   }
    return 0;
}
View Code

 

 hdu 1849 Nim, m个棋子,m堆, 每堆可以取任意棋子, 直到为空。 , 直接对输入的堆的个数(相当于位移长度)取 异或 即可。

题目来源:http://acm.hdu.edu.cn/showproblem.php?pid=1849

代码如下:

int main(){
   int m,temp,x;
   while(cin>>m&&m)
   {
       x=0;
       for(int i=0;i<m ;i++)
       {
           cin>>temp;
           x^=temp;
       }
        if(x) puts("Rabbit Win!");
        else  puts("Grass Win!");
   }
    return 0;
}
View Code

 

 hdu 1850 Nim博弈, 如果异或值x不为0, 表示first赢,  first 可以走的方案数, 为 使异或值 x为0的temp[i] 数的个数, 即(temp[i] > (temp^x))

题目来源:

http://acm.hdu.edu.cn/showproblem.php?pid=1850

代码如下:

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#define Inf 0x7fffffff // 0x 是数字0,而不是字母o
#define N 105
using namespace std;

int main(){
   int m,temp[105],x,ans;
   while(cin>>m&&m)
   {
       x=0,ans=0;
       for(int i=0;i<m ;i++)
       {
           cin>>temp[i];
           x^=temp[i];
       }
        for(int i=0; i<m; i++)
            if(temp[i]> (temp[i]^x))
                ans++;
        cout<<ans<<endl;
   }
    return 0;
}

 

hdu 1851 题目来源:http://acm.hdu.edu.cn/showproblem.php?pid=1851

共有n堆, 每堆石子数为mi, 最多可取Li ,  则 sg[mi] = mi %(Li+1), 然后对每堆  取异或x,x不为0, first赢。

代码如下:

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#define Inf 0x7fffffff // 0x 是数字0,而不是字母o
#define N 15
using namespace std;
int sg[N];
int main(){
   int t,n,m,l;
   cin>>t;
   while(t--)
   {
       cin>>n;
       int x=0;
       for(int i=0;i<n;i++)
       {
           cin>>m>>l;
           x^=m%(l+1);
       }
       if(x) puts("No");
       else puts("Yes");
   }
    return 0;
}