• 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[N],sg[N]; 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[n]^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("%d%d%d",&m,&n,&p)!=EOF)
        {
            if(m==0 && n==0 && p==0)
                break;
            x= sg[m]^sg[n]^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[N];
    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;
    }
  • 相关阅读:
    HTTP 缓存
    css样式重置方案 -解决浏览器差异
    前端 网址收集
    最全前端资源汇集
    【收集】JAVA多文件 上传文件接口代码 -兼容app
    前端编码规范(4)—— CSS 和 Sass (SCSS) 规范
    前端编码风格规范(3)—— JavaScript 规范
    前端编码规范(2)—— HTML 规范
    前端编码规范(1)—— 一般规范
    【转载】jQuery插件开发精品教程,让你的jQuery提升一个台阶
  • 原文地址:https://www.cnblogs.com/zn505119020/p/3608051.html
Copyright © 2020-2023  润新知