SG函数模板 hdu 1848/1847/1849/1850/1851

首先定义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
,sg
;
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
^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
e650
("%d%d%d",&m,&n,&p)!=EOF)
{
if(m==0 && n==0 && p==0)
break;
x= sg[m]^sg
^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
;
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;
}