zoukankan      html  css  js  c++  java
  • SG 大法(Sprague-Grundy函数)

    SG函数的定义:

    g(x) = mex ( sg(y) |y是x的后继结点 )

    其中mex(x)(x是一个自然是集合)函数是x关于自然数集合的补集中的最小值,比如x={0,1,2,4,6} 则mex(x)=3;

    什么是后继结点?

    所谓后继结点就是当前结点经过一个操作可以变成的状态。比如对于取4石子游戏,假如每次可以取的数目是1,2,4,当前的石子数目也就是当前状态是5,那么5的后继结点就是{5-1, 5-2, 5-4}={4,3,1};

    如果5的三个后继结点的SG函数值分别为0,1,3,那么5的SG值就是集合{0,1,3}的补集的最小元素,也就是2。

    关于整个游戏的sg值之和sum,定义sum=sg1 ^ sg2 ^ sg3 ^ ……sgn.  其中^表示按位异或运算。

    结论:一个游戏的初始局面是必败态当且仅当sum=0。


    插一段大神的论文


    上一期的文章里我们仔细研究了Nim游戏,并且了解了找出必胜策略的方法。但如果把Nim的规则略加改变,你还能很快找出必胜策略吗?比如说:有n堆石子,每次可以从第1堆石子里取1颗、2颗或3颗,可以从第2堆石子里取奇数颗,可以从第3堆及以后石子里取任意颗……这时看上去问题复杂了很多,但相信你如果掌握了本节的内容,类似的千变万化的问题都是不成问题的。
    现在我们来研究一个看上去似乎更为一般的游戏:给定一个有向无环图和一个起始顶点上的一枚棋子,两名选手交替的将这枚棋子沿有向边进行移动,无法移动者判负。事实上,这个游戏可以认为是所有Impartial Combinatorial Games的抽象模型。也就是说,任何一个ICG都可以通过把每个局面看成一个顶点,对每个局面和它的子局面连一条有向边来抽象成这个“有向图游戏”。下面我们就在有向无环图的顶点上定义Sprague-Garundy函数。

    首先定义mex(minimal excludant)运算,这是施加于一个集合的运算,表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。

    对于一个给定的有向无环图,定义关于图的每个顶点的Sprague-Garundy函数g如下:g(x)=mex{ g(y) | y是x的后继 }。

    来看一下SG函数的性质。首先,所有的terminal position所对应的顶点,也就是没有出边的顶点,其SG值为0,因为它的后继集合是空集。然后对于一个g(x)=0的顶点x,它的所有后继y都满足g(y)!=0。对于一个g(x)!=0的顶点,必定存在一个后继y满足g(y)=0。

    以上这三句话表明,顶点x所代表的postion是P-position当且仅当g(x)=0(跟P-positioin/N-position的定义的那三句话是完全对应的)。我们通过计算有向无环图的每个顶点的SG值,就可以对每种局面找到必胜策略了。但SG函数的用途远没有这样简单。如果将有向图游戏变复杂一点,比如说,有向图上并不是只有一枚棋子,而是有n枚棋子,每次可以任选一颗进行移动,这时,怎样找到必胜策略呢?

    让我们再来考虑一下顶点的SG值的意义。当g(x)=k时,表明对于任意一个0<=i<k,都存在x的一个后继y满足g(y)=i。也就是说,当某枚棋子的SG值是k时,我们可以把它变成0、变成1、……、变成k-1,但绝对不能保持k不变。不知道你能不能根据这个联想到Nim游戏,Nim游戏的规则就是:每次选择一堆数量为k的石子,可以把它变成0、变成1、……、变成k-1,但绝对不能保持k不变。这表明,如果将n枚棋子所在的顶点的SG值看作n堆相应数量的石子,那么这个Nim游戏的每个必胜策略都对应于原来这n枚棋子的必胜策略!

    对于n个棋子,设它们对应的顶点的SG值分别为(a1,a2,...,an),再设局面(a1,a2,...,an)时的Nim游戏的一种必胜策略是把ai变成k,那么原游戏的一种必胜策略就是把第i枚棋子移动到一个SG值为k的顶点。这听上去有点过于神奇——怎么绕了一圈又回到Nim游戏上了。

    其实我们还是只要证明这种多棋子的有向图游戏的局面是P-position当且仅当所有棋子所在的位置的SG函数的异或为0。这个证明与上节的Bouton's Theorem几乎是完全相同的,只需要适当的改几个名词就行了。

    刚才,我为了使问题看上去更容易一些,认为n枚棋子是在一个有向图上移动。但如果不是在一个有向图上,而是每个棋子在一个有向图上,每次可以任选一个棋子(也就是任选一个有向图)进行移动,这样也不会给结论带来任何变化。

    所以我们可以定义有向图游戏的和(Sum of Graph Games):设G1、G2、……、Gn是n个有向图游戏,定义游戏G是G1、G2、……、Gn的和(Sum),游戏G的移动规则是:任选一个子游戏Gi并移动上面的棋子。Sprague-Grundy Theorem就是:g(G)=g(G1)^g(G2)^...^g(Gn)。也就是说,游戏的和的SG函数值是它的所有子游戏的SG函数值的异或。

    再考虑在本文一开头的一句话:任何一个ICG都可以抽象成一个有向图游戏。所以“SG函数”和“游戏的和”的概念就不是局限于有向图游戏。我们给每个ICG的每个position定义SG值,也可以定义n个ICG的和。所以说当我们面对由n个游戏组合成的一个游戏时,只需对于每个游戏找出求它的每个局面的SG值的方法,就可以把这些SG值全部看成Nim的石子堆,然后依照找Nim的必胜策略的方法来找这个游戏的必胜策略了!

    回到本文开头的问题。有n堆石子,每次可以从第1堆石子里取1颗、2颗或3颗,可以从第2堆石子里取奇数颗,可以从第3堆及以后石子里取任意颗……我们可以把它看作3个子游戏,第1个子游戏只有一堆石子,每次可以取1、2、3颗,很容易看出x颗石子的局面的SG值是x%4。第2个子游戏也是只有一堆石子,每次可以取奇数颗,经过简单的画图可以知道这个游戏有x颗石子时的SG值是x%2。第3个游戏有n-2堆石子,就是一个Nim游戏。对于原游戏的每个局面,把三个子游戏的SG值异或一下就得到了整个游戏的SG值,然后就可以根据这个SG值判断是否有必胜策略以及做出决策了。其实看作3个子游戏还是保守了些,干脆看作n个子游戏,其中第1、2个子游戏如上所述,第3个及以后的子游戏都是“1堆石子,每次取几颗都可以”,称为“任取石子游戏”,这个超简单的游戏有x颗石子的SG值显然就是x。其实,n堆石子的Nim游戏本身不就是n个“任取石子游戏”的和吗?

    所以,对于我们来说,SG函数与“游戏的和”的概念不是让我们去组合、制造稀奇古怪的游戏,而是把遇到的看上去有些复杂的游戏试图分成若干个子游戏,对于每个比原游戏简化很多的子游戏找出它的SG函数,然后全部异或起来就得到了原游戏的SG函数,就可以解决原游戏了。这种“分而治之”的思想在下一节介绍的“翻硬币游戏”中将被应用得淋漓尽致。还是敬请期待。


    SG打表模板

     1 //f[]  可以取走的石子数  从f[1]开始  f[]里的值要从小到大排序
     2 //sg[]   0~n的sg函数值  
     3 int f[maxn],sg[maxn],mex[maxn];  //maxn一个堆的大小
     4 int k ;  //k为集合的大小 
     5 void getsg(int n)  
     6 {  
     7     int i,j;  
     8     sg[0]=0;  
     9     for (i=1;i<=n;i++){  
    10         memset(mex,0,sizeof(mex));  
    11         j=1;  
    12         while (j<=k && i>=f[j]){   
    13             mex[sg[i-f[j]]]=1;  //i-f[j]  是 i的后继结点 
    14             j++;  
    15         }  
    16         j=0;  
    17         while (mex[j]) j++;  
    18         sg[i]=j;  
    19     }  
    20 }  

    HDU 1536  和 1944

    题意:
    首先输入K 表示一个集合的大小 之后输入集合 表示对于这对石子只能去这个集合中的元素的个数
    之后输入 一个m 表示接下来对于这个集合要进行m次询问
    之后m行 每行输入一个n 表示有n个堆 每堆有n1个石子 问这一行所表示的状态是赢还是输 如果赢输入W否则L

    Sample Input
    2 2 5 // 集合大小 集合里的数
    3 //询问次数
    2 5 12 // 多少堆 堆的大小
    3 2 4 7
    4 2 3 7 12
    5 1 2 3 4 5
    3
    2 5 12
    3 2 4 7
    4 2 3 7 12
    0

    Sample Output
    LWW //L为先手败
    WWL

     1 # include <iostream>
     2 # include <cstdio>
     3 # include <cmath>
     4 # include <cstring>
     5 # include <algorithm>
     6 using namespace std ;
     7 
     8 int f[110],sg[10010],mex[110];  
     9 int k ;  //k为集合的大小 
    10 void getsg(int H)  
    11 {  
    12     int i,j;  
    13     sg[0]=0;  
    14     for (i=1;i<H;i++){  
    15         memset(mex,0,sizeof(mex));  
    16         j=1;  
    17         while (j<=k && i>=f[j]){   
    18             mex[sg[i-f[j]]]=1;  
    19             j++;  
    20         }  
    21         j=0;  
    22         while (mex[j]) j++;  
    23         sg[i]=j;  
    24     }  
    25 }  
    26 
    27 int main ()
    28 {
    29 //    freopen("in.txt","r",stdin) ;
    30 
    31     while (scanf("%d" , &k) , k)
    32     {
    33         int i ;
    34         for (i = 1 ; i <= k ; i++)
    35         {
    36             scanf("%d" , &f[i]) ;
    37         }
    38         sort(f+1 , f+1+k) ;
    39         getsg(10010) ;
    40         int m ;
    41         scanf("%d" , &m) ;
    42         while (m--)
    43         {
    44             int n ;
    45             scanf("%d" , &n) ;
    46             int x ;
    47             int sum = 0 ;
    48             for (i = 1 ; i <= n ; i++)
    49             {
    50                 scanf("%d" , &x) ;
    51                 sum ^= sg[x] ;
    52             }
    53             if (sum == 0)
    54               printf("L") ;
    55             else
    56               printf("W") ;
    57         }
    58         printf("
    ") ;
    59     }
    60     
    61     return 0 ;
    62 }
    View Code

    HDU 1848

    1、 这是一个二人游戏;
    2、 一共有3堆石子,数量分别是m, n, p个;
    3、 两人轮流走;
    4、 每走一步可以选择任意一堆石子,然后取走f个;
    5、 f只能是菲波那契数列中的元素(即每次只能取1,2,3,5,8…等数量);
    6、 最先取光所有石子的人为胜者;

    假设双方都使用最优策略,请判断先手的人会赢还是后手的人会赢。
    如果先手的人能赢,请输出“Fibo”,否则请输出“Nacci”

    Sample Input
    1 1 1 // m n p
    1 4 1
    0 0 0

    Sample Output
    Fibo
    Nacci

    # include <iostream>
    # include <cstdio>
    # include <cmath>
    # include <cstring>
    # include <algorithm>
    using namespace std ;
    
    const int maxn = 1100 ;
    
    int f[maxn],sg[maxn],mex[maxn];  //maxn一个堆的大小
    int k ;  //k为集合的大小 
    void getsg(int n)  
    {  
        int i,j;  
        sg[0]=0;  
        for (i=1;i<=n;i++){  
            memset(mex,0,sizeof(mex));  
            j=1;  
            while (j<=k && i>=f[j]){   
                mex[sg[i-f[j]]]=1;  //i-f[j]  是 i的后继结点 
                j++;  
            }  
            j=0;  
            while (mex[j]) j++;  
            sg[i]=j;  
        }  
    }  
    
    
    int main ()
    {
        f[1] = 1 ;
        f[2] = 2 ;
        int i , n ,m , p ;
        for (i = 3 ; i <= 16 ; i++)
          f[i] = f[i - 1] + f[i - 2] ;
        k = 16 ;
        getsg(1010) ;
        
        while (scanf("%d %d %d" , &m , &n , &p) )
        {
            if (m == 0 && n == 0 && p == 0)
               break ;
            
            int sum = 0 ;
            sum = sg[m] ^ sg[n] ^ sg[p] ;
            if (sum == 0)
              printf("Nacci
    ") ;
            else
              printf("Fibo
    ") ;
        }
        
        return 0 ;
    }
    View Code

    HDU 1847 (如果找规律法不会 可以用SG)

     1 # include <iostream>
     2 # include <cstdio>
     3 # include <cmath>
     4 # include <cstring>
     5 # include <algorithm>
     6 using namespace std ;
     7 
     8 const int maxn = 1100 ;
     9 
    10 int f[maxn],sg[maxn],Hash[maxn];  
    11 void getsg(int n)  
    12 {  
    13     memset(sg,0,sizeof(sg));  
    14     for(int i=1;i<=n;i++)  
    15     {  
    16         memset(Hash,0,sizeof(Hash));  
    17         for(int j=1;f[j]<=i;j++)  
    18             Hash[sg[i-f[j]]]=1;  
    19         for(int j=0;j<=n;j++)  
    20         {  
    21             if(Hash[j]==0)  
    22             {  
    23                 sg[i]=j;  
    24                 break;  
    25             }  
    26         }  
    27     }  
    28 } 
    29 
    30 int main ()
    31 {
    32     int n ;
    33     f[1] = 1 ;
    34     int i ;
    35     for (i = 2 ; i <= 12 ; i++)
    36        f[i] = f[i-1] * 2 ;
    37     getsg(1000) ;
    38     while (scanf("%d" , &n) != EOF)
    39     {
    40         int sum = 0 ;
    41         sum ^= sg[n] ;
    42         if (sum == 0)
    43           printf("Cici
    ") ;
    44         else
    45           printf("Kiki
    ") ;
    46     }
    47     
    48     return 0 ;
    49 }
    View Code
  • 相关阅读:
    Expedition---POJ
    LIS的优化算法O(n log n)
    Super Jumping! Jumping! Jumping! ---HDU
    数据库连接判断
    android stuido控件
    sql查询语句
    c# 字符串操作
    windows操作
    C# sql操作
    datagridview
  • 原文地址:https://www.cnblogs.com/mengchunchen/p/4490771.html
Copyright © 2011-2022 走看看