博弈例题、SG函数应用

一、取石子：
有1堆n个的石子，每次只能取{ 1, 3, 4 }个石子，先取完石子者胜利，那么各个数的SG值为多少？

SG[0]=0，f[]={1,3,4},

x=1 时，可以取走1 - f{1}个石子，剩余{0}个，所以 SG[1] = mex{ SG[0] }= mex{0} = 1;

x=2 时，可以取走2 - f{1}个石子，剩余{1}个，所以 SG[2] = mex{ SG[1] }= mex{1} = 0;

x=3 时，可以取走3 - f{1,3}个石子，剩余{2,0}个，所以 SG[3] = mex{SG[2],SG[0]} = mex{0,0} =1;

x=4 时，可以取走4- f{1,3,4}个石子，剩余{3,1,0}个，所以 SG[4] = mex{SG[3],SG[1],SG[0]} = mex{1,1,0} = 2;

x=5 时，可以取走5 - f{1,3,4}个石子，剩余{4,2,1}个，所以SG[5] = mex{SG[4],SG[2],SG[1]} =mex{2,0,1} = 3;

以此类推…

x 0 1 2 3 4 5 6 7 8…

SG[x] 0 1 0 1 2 3 2 0 1…

由上述实例我们就可以得到SG函数值求解步骤，那么计算1~n的SG函数值步骤如下：

1、使用 数组f 将 可改变当前状态 的方式记录下来。

2、然后我们使用 另一个数组 将当前状态x 的后继状态标记。

3、最后模拟mex运算，也就是我们在标记值中 搜索 未被标记值 的最小值，将其赋值给SG(x)。

4、我们不断的重复 2 - 3 的步骤，就完成了 计算1~n 的函数值。

//f[N]:可改变当前状态的方式，N为方式的种类，f[N]要在getSG之前先预处理
//SG[]:0~n的SG函数值
//S[]:为x后继状态的集合
int f[N],SG[maxn],S[maxn];
void  getSG(int n)
{
   
    int i,j;
    memset(SG,0,sizeof(SG));
    //因为SG[0]始终等于0，所以i从1开始
    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;  //将后继状态的SG函数值进行标记
        for(j = 0;; j++) 
            if(!S[j])
            {
      //查询当前后继状态SG值中最小的非零值  
                SG[i] = j;
                break;
           }
    }
    return;
}

二、kiki和cici抓牌：
----总共n张牌
----双方轮流抓
----每人每次抓的牌的个数只能是2的次幂（1，2，4，8，16……）
----最后抓完牌的人胜kiki先抓。
n   0  1  2   3   4   5   6   7    8    9    10

2ⁿ  1  2  4   8   16  32   64  128   256   512   1024

sum  1  3  7  15  31  63  127  255  511  1023  2047

发现：当牌数为3，15，63，255，1023张牌时cici赢。
大胆猜测，当牌数为3的倍数时cici赢。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<algorithm>
using namespace std;
int x[12],SG[1050];
bool vis[1050];
void init(void)
{
   
    for(int i=0;i<11;i++)
        x[i]=1<<i;
    SG[0]=0;

    for(int i=1;i<1002;++i)
    {
   
        memset(vis,0,sizeof(vis));

        for(int j=0;x[j]<=i;++j)
        {
   
            vis[SG[i-x[j]]]=true;
        }
        for(int j=