【博弈】SG函数模板 nyoj913取石子(十)

SG函数模板

源于http://www.cnblogs.com/frog112111/p/3199780.html

首先定义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},

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....


计算从1-n范围内的SG值。
f(存储可以走的步数，f[0]表示可以有多少种走法)
f[]需要从小到大排序

1.可选步数为1~m的连续整数，直接取模即可，SG(x) = x % (m+1);
2.可选步数为任意步，SG(x) = x;
3.可选步数为一系列不连续的数，用GetSG()计算

模板1如下（SG打表）：

//f[]：可以取走的石子个数
//sg[]:0~n的SG函数值
//hash[]:mex{}
int f[N],sg[N],hash[N];     
void getSG(int n)
{
    int i,j;
    memset(sg,0,sizeof(sg));
    for(i=1;i<=n;i++)
    {
        memset(hash,0,sizeof(hash));
        for(j=1;f[j]<=i;j++)
            hash[sg[i-f[j]]]=1;
        for(j=0;j<=n;j++)    //求mes{}中未出现的最小的非负整数
        {
            if(hash[j]==0)
            {
                sg[i]=j;
                break;
            }
        }
    }
}

模板2如下（dfs）：

//注意 S数组要按从小到大排序 SG函数要初始化为-1 对于每个集合只需初始化1遍
//n是集合s的大小 S[i]是定义的特殊取法规则的数组
int s[110],sg[10010],n;
int SG_dfs(int x)
{
    int i;
    if(sg[x]!=-1)
        return sg[x];
    bool vis[110];
    memset(vis,0,sizeof(vis));
    for(i=0;i<n;i++)
    {
        if(x>=s[i])
        {
            SG_dfs(x-s[i]);
            vis[sg[x-s[i]]]=1;
        }
    }
    int e;
    for(i=0;;i++)
        if(!vis[i])
        {
            e=i;
            break;
        }
    return sg[x]=e;
}

nyoj913

取石子（十）

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 6

描述

不知不觉取石子已经到第十道了。地球上的石子也快要取完了！

开个玩笑，当然还是有很多石子的，取石子的题目也是做不完的，今天又来了一道！

有n堆石子，每一堆的规则如下：

第一堆每次只能取2的幂次（即：1，2，4，8，16…）；

第二堆只能取菲波那契数列中的元素（即每次只能取1，2，3，5，8…等数量，斐波那契数即后面的数是前面两个数的和）；

第三堆可以取任意多个，最小1个，最多可以把这一堆石子取完；

第四堆只能取1和偶数个（即：1,2,4,6,8,10...）；

第五堆只能取奇数个（即：1,3,5,7,9.....）；

好吧，这样下去太烦人了，六堆及其以后每堆最多取的数量为堆数编号，即第六堆只能取（1,2,3,4,5,6），第七堆只能取（1,2,3,4,5,6,7）....

别看规则很多，但Yougth和Hrdv都是聪明人，现在由Yougth先取，比赛规定谁先取完所有石子既为胜者，输出胜者的名字。

输入

有多组测试数据，每组测试数据开始有一个n。
后面有n个数代表每一堆石子的数量，当n为0是表示输入结束。(所有数据小于1000)

输出

假如Yougth赢输出“Yougth”，Hrdv赢输出“Hrdv”。

样例输入

6
2 4 2 3 6 7 

样例输出

Hrdv

分别把每一堆的SG函数计算出来，就可以利用组合游戏的结论进行Nim异或了

第一堆求出SG函数可以发现有规律0，1，2，0，1，2……循环

第二堆无规律求出sg2[]

第三堆sg[a]=a;

第四堆无规律求出sg4[]

第五堆规律0，1，0，1，0，1……

第六堆及其以后根据巴什博弈，sg[a]=a%(i+1);

code:

#include<stdio.h>
#include<string.h>
int f[25],sg2[1005],vis[1005];
int ff[1000],sg4[1005];
void fib()//斐波那契数
{
    f[1]=1;
    f[2]=2;
    for(int i=3; i<=20; i++)
        f[i]=f[i-1]+f[i-2];
    return ;

}
void get_ff()//1和偶数
{
    ff[1]=1;
    for(int i=1; i<=500; i++)
    {
        ff[i+1]=2*i;
    }
}
int get_sg2(int n)//第二堆sg
{
    fib();
    memset(sg2,0,sizeof(sg2));
    for(int i=1; i<=n; i++)
    {
        memset(vis,0,sizeof(vis));
        for(int j=1; f[j]<=i; j++)
            vis[sg2[i-f[j]]]=1;
        for(int j=0; j<=n; j++)
            if(vis[j]==0)
            {
                sg2[i]=j;
                break;
            }
    }
    return sg2[n];
}
int get_sg4(int n)//第四堆sg
{
    memset(sg4,0,sizeof(sg4));
    get_ff();
    for(int i=1; i<=n; i++)
    {
        memset(vis,0,sizeof(vis));
        for(int j=1; ff[j]<=i; j++)
            vis[sg4[i-ff[j]]]=1;
        for(int j=0; j<=n; j++)
            if(vis[j]==0)
            {
                sg4[i]=j;
                break;
            }
    }
    return sg4[n];
}
int main()
{
    int m,n,p,a;
    while(~scanf("%d",&n)&&n)
    {
        int f=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a);
            if(i==1)
            {
                f^=(a%3);
            }
            else if(i==2)
            {
                f^=get_sg2(a);
            }
            else if(i==3)
            {
                f^=a;
            }
            else if(i==4)
            {
                f^=get_sg4(a);
            }
            else if(i==5)
            {
                f^=(a%2);
            }
            else
            {
                f^=(a%(i+1));
            }
        }
        if(f>0)
        {
            printf("Yougth\n");
        }
        else
        {
            printf("Hrdv\n");
        }
    }
}