博弈——SG函数模板

　　之前遇到博弈的题老是无从下手，今天学习了下博弈题的一个“小套路”，叫做Sprague-Grundy函数。

Sprague-Grundy函数定义为不出现在F(X)中每一个元素的Sprague-Grundy函数的最小非负数。听着有点绕，其实举个例子就很好理解了。

举例子前先说几个名词：

　　x：当前状态量

　　F(x)：表示一个点能到达点的集合

　　SG[]：0-n的SG函数值

　　S[]：x后继状态的集合

　　mex{}：表示最小的不属于这个集合的非负整数

举个栗子：一堆n个的石头，每次只能取{1,3,5}个石头，先取完石头的赢。

　　首先SG[0]=0是恒定不变的。

　　x为1时，最多只能取1个石头了，取完之后剩0个，所以SG[1]=mex{SG[0]}=mex{0}=1;

　　x为2时，最多只能取1个石头了，取完之后剩1个，SG[2]=mex{SG[1]}=mex{1}=0;

　　x为3时，能取1个或3个，剩余2个或0个，SG[3]=mex{SG[0],SG[2]}=mex{0,0}=1;

　　...

以上，就搞清楚了SG函数的计算了，然后看看有什么用呢？

先打表看下0-9下对应的SG值

然后我们不难发现：

　　当SG值为0时，该状态为必败局面。

　　当SG值非0时，该状态为必胜局面。

这就很有用了！

上面说的是一堆石头，当有几堆石头时可以类推出这样的处理：（别问我怎么推的，我也不知道╮(╯▽╰)╭

　　SG[n1]^SG[n2]^SG[n3]^....^SG[nx]

　　然后对它进行真值判断。

---

上一道例题的代码 http://hdu.hustoj.com/showproblem.php?pid=1848

#include<bits/stdc++.h>
using namespace std;
//SG打表
const int N = 20;
const int maxn = 1010;
int F[N], S[maxn], SG[maxn];
void getSG(int n)
{
    int i, j;
    memset(SG, 0, sizeof(SG));
    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;    //标记
        }
        for(j = 0;; j++)
            if(!S[j])
            {
                SG[i] = j;
                break;
            }
    }
}
int main()
{
    F[0] = 1;
    F[1] = 1;
    F[2] = 2;
    for(int i = 3; i <= 20; i++)
        F[i] = F[i - 1] + F[i - 2];
    getSG(1000);
    int m, n, p;
    while(cin >> m >> n >> p && m != 0 && n != 0  && p != 0)
    {
        /*
        if(SG[m]^SG[n]^SG[p])
            cout << "Fibo" << endl;
        else
            cout << "Nacci" << endl;
        */
        if((SG[m]^SG[n]^SG[p]) == 0)    //按位异或的优先级低于等值判定，怪不得交了几遍都是WA！！！
            cout << "Nacci" << endl;
        else
            cout << "Fibo" << endl;
        
    }
    return 0;
}