hdu 1848 Fibonacci again and again（组合博弈）

Fibonacci again and again

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5254    Accepted Submission(s): 2190

Problem Description

任何一个大学生对菲波那契数列(Fibonacci numbers)应该都不会陌生，它是这样定义的：
F(1)=1;
F(2)=2;
F(n)=F(n-1)+F(n-2)(n>=3);
所以，1,2,3,5,8,13……就是菲波那契数列。
在HDOJ上有不少相关的题目，比如1005 Fibonacci again就是曾经的浙江省赛题。
今天，又一个关于Fibonacci的题目出现了，它是一个小游戏，定义如下：
1、  这是一个二人游戏;
2、  一共有3堆石子，数量分别是m, n, p个；
3、  两人轮流走;
4、  每走一步可以选择任意一堆石子，然后取走f个；
5、  f只能是菲波那契数列中的元素（即每次只能取1，2，3，5，8…等数量）；
6、  最先取光所有石子的人为胜者；

假设双方都使用最优策略，请判断先手的人会赢还是后手的人会赢。

 

Input

输入数据包含多个测试用例，每个测试用例占一行，包含3个整数m,n,p（1<=m,n,p<=1000）。
m=n=p=0则表示输入结束。

 

Output

如果先手的人能赢，请输出“Fibo”，否则请输出“Nacci”，每个实例的输出占一行。

 

Sample Input

  
  

   
   1 1 1
1 4 1
0 0 0
  
  

 

Sample Output

  
  

   
   Fibo
Nacci
  
  

 

这个用到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);        （bash game）

2.可选步数为任意步，SG(x) = x;                     （nim游戏）

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

模板1如下（SG打表）：

 1 //f[]：可以取走的石子个数
 2 //sg[]:0~n的SG函数值
 3 //hash[]:mex{}
 4 int f[N],sg[N],hash[N];     
 5 void getSG(int n)
 6 {
 7     int i,j;
 8     memset(sg,0,sizeof(sg));
 9     for(i=1;i<=n;i++)
10     {
11         memset(hash,0,sizeof(hash));
12         for(j=1;f[j]<=i;j++)
13             hash[sg[i-f[j]]]=1;
14         for(j=0;j<=n;j++)    //求mes{}中未出现的最小的非负整数
15         {
16             if(hash[j]==0)
17             {
18                 sg[i]=j;
19                 break;
20             }
21         }
22     }
23 }

模板2如下（dfs）：

 1 //注意 S数组要按从小到大排序 SG函数要初始化为-1 对于每个集合只需初始化1遍
 2 //n是集合s的大小 S[i]是定义的特殊取法规则的数组
 3 int s[110],sg[10010],n;
 4 int SG_dfs(int x)
 5 {
 6     int i;
 7     if(sg[x]!=-1)
 8         return sg[x];
 9     bool vis[110];
10     memset(vis,0,sizeof(vis));
11     for(i=0;i<n;i++)
12     {
13         if(x>=s[i])
14         {
15             SG_dfs(x-s[i]);
16             vis[sg[x-s[i]]]=1;
17         }
18     }
19     int e;
20     for(i=0;;i++)
21         if(!vis[i])
22         {
23             e=i;
24             break;
25         }
26     return sg[x]=e;
27 }

 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int sg[1005];
int f[20];
int hash[20];

void fun()
{
    int i;
    f[1]=1;
    f[2]=2;
    for(i=3;i<19;i++)
        f[i]=f[i-1]+f[i-2];
}

void getsg()
{
    memset(sg,0,sizeof(sg));
    int i,j;
    for(i=1;i<1005;i++)
    {
        memset(hash,0,sizeof(hash));
        for(j=1;f[j]<=i;j++)
        {
            hash[sg[i-f[j]]]=1;
        }
        for(j=0;j<20;j++)
        {
            if(hash[j]==0)
            {
                sg[i]=j;
                break;
            }
        }
    }
}

int main()
{
    int m,n,p;
    fun();
    getsg();
    while(cin>>m>>n>>p,m||n||p)
    {
        if((sg[n]^sg[m]^sg[p])==0)      //注意异或运算的整个结果要加括号，我在这里wa到死
            cout<<"Nacci"<<endl;
        else
            cout<<"Fibo"<<endl;
    }
    return 0;
}