zoukankan      html  css  js  c++  java
  • 博弈入门“芝士”准备~

    强烈推荐的一篇学博弈的博客~https://blog.csdn.net/sinat_40872274/article/details/84983258?utm_source=app

    自己再此基础上截取了比较简短的,可以拿来直接用的东西,所以要想仔细学一番的话请去看链接中大佬的博客吧^^^^

    (一).巴什博奕(Bash Game):

     解决问题类型:只有一堆n个物品,两个人轮流从这堆物品中取物,规定两个人轮流从这堆物品中取物,规定每次至少取一个,最多取m个。最后取光者胜(谁最后把全部都拿完了谁赢)

        解决问题方法:要给对手留下(m+1)的倍数,就能最后获胜!

        结论:1. if(n%(m+1)!=0) 则先手必赢

           2. if(n%(m+1)==0) 则后手必赢

      

     拓展:通用方法:P/N分析法

     P点:必败点,某完家位于此点,只要对方无失误,则必败;

     N点:必胜点,某玩家位于此点,只要自己无失误,则必胜;

     三个定理:

        1.所有终结点都是必败点;

        2.所有一步走到必败点P的就是N点;

        3.通过一步操作只能到N点的就是P点;

    (二).威佐夫博弈(Wythoff Game):

    解决问题类型:有两堆各若干个物品,两人轮流从某一堆或同时从两堆中取出同样多的物品,规定一次至少取一个,多者不限,最后取光者得胜。

    解决方法:我们用(ak,bk)(ak<=bk, k=0, 1, 2, ..., n)表示两堆物品的数量并称其为局势,当某玩家面对的是(0,0)时,那么他就输了,这种局势就叫奇异局势。面对此局势(奇异局势)的玩家就是必败的;

    如何找出所有的奇异局势?

    下面证明:根据下面的方法,可以构造出所有的必败态

         1.(0,0)是必败态;

         2.  第k个必败态的两个数相差为k(计(0,0)是第0个必败态)

         3.  已知前k个必败态,则最小的没出现过的正整数为第k+1个必败态的第一个数。

    举个栗子~

    (0,0),(1, 2),(3, 5), (4, 7)中含有{0, 1, 2, 3, 4, 5, 7},缺少一个6,所以下一个奇异局势的前一个数就是6.为(6,10);

    奇异局势的三条性质:

     1.任何自然数都包含在一个且仅有一个奇异局势中;

     2.任意操作都可以将奇异局势变为非奇异局势;

     3.采用适当的方法,可以将非奇异局势变为奇异局势;

     求奇异局势的公式:

     第一个值=(int)(差值*1.618)(1.618  = (1+sqrt(5))/2 )

     即ak=[k(1+sqrt(5))/2],bk=ak+k,(k=0,1,2,...,n方括号表示向下取整);

     结论:

      1.(int)( (bk-ak)  *  (1+sqrt(5))/2 ) != ak,先手必赢

      2.(int)( (bk-ak)  *  (1+sqrt(5))/2 ) == ak,后手必赢

    (三). 尼姆博弈(Nimm Game):

     解决问题类型:有n堆各若干个物品,两人中轮流从某一堆取任意多的物品,规定每次至少去一个,多者不限,最后取光者得胜。

     结论:

     1.a1 xor a2 xor a3 xor....xor an != 0    必胜态(a1, a2, ...,an分别表示每堆石子个数)

     2.a1 xor a2 xor a3 xor....xor an == 0  必败态

     Nim博弈的两个性质:

     1. 必败态只能转移到必胜态

     2. 必胜态总能转移到每个必败态

     

    (四). 斐波那契博弈(Fibonacci Nim):

    解决问题类型:有一堆个数为n的石子,游戏双方轮流取石子,满足:1)先手不能在第一次把所有的石子取完;2)之后每次可以取的石子数介于1到对手刚取的石子数的2倍之间(包含1和对手刚取的石子数的2倍)。取走最后一个石子的人为赢家

      结论:当n为Fibonacci数的时候,必败。

      f[i]:1,2,3,5,8,13,21,......

     (五).博弈的王道——SG函数和SG定理:

     SG函数:首先定义mex(minimal excludant)运算,这是施加于一个集合的运算,表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。 对于任意状态 x (玩家当前面临的石子个数), 定义 SG(x) = mex(S),其中 S 是 x 后继状态的SG函数值的集合。如 x 有三个后继状态分别为 SG(a),SG(b),SG(c),那么SG(x) = mex{SG(a),SG(b),SG(c)}。 这样 集合S 的终态必然是空集,所以SG函数的终态为 SG(x) = 0,当且仅当 x 为必败点P时。

      结论:

           1.当SG[x] = 0时,x为必败状态。

          2.当SG[x] > 0时,x为必胜状态。

     【实例】取石子问题

           有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 = 5时做样例分析:

        当玩家面对还有5个石子的状态时,他可取{1,3,4}个石子,那么5的后继状态集合就是{4,2,1}。

                           

     那么mex{SG[4],SG[2],SG[1]} =mex{2,0,1} = 3 ,可得出SG[5] = 3 > 0,为必胜态。

          以此类推.....

              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、然后我们使用 另一个数组S[] 将当前状态x 的后继状态标记。

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

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

            SG 定理就是:SG(G)=SG(G1)^SG(G2)^...^SG(Gn)。也就是说,原游戏的SG函数值是它的所有子游戏的SG函数值的异或。

         解题模型:

              1.把原游戏分解成多个独立的子游戏,则原游戏的SG函数值是它的所有子游戏的SG函数值的异或。

                 即SG(G)=SG(G1)^SG(G2)^...^Sg(Gn)。

              2.分别考虑每一个子游戏,计算其SG值。

                SG值的计算方法:(重点)

                 a.可选步数为1~m的连续整数,直接取模即可,SG(x) = x % (m+1)(Bash game)。

                 b.可选步数为任意步,SG(x) = x(Nim game)。

                 c.可选步数为一系列不连续的数,用模板计算。

        i.打表模板

    int f[N],SG[MAXN],S[MAXN];//f[] - 可改变当前状态 的方式   S[] - 当前状态的后继状态集合
    //打表
    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;//S[]数组来保存当前状态的后继状态集合
            for(j = 0;; j++) if(!S[j]) {//模拟mex运算
                    SG[i] = j;
                    break;
                }
        }
    }

         ii.深搜模板

     1 //注意 f数组要按从小到大排序 SG函数要初始化为-1 对于每个集合只需初始化1遍
     2 //n是集合f的大小 f[i]是定义的特殊取法规则的数组
     3 int f[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>=f[i])
    14         {
    15             SG_dfs(x-f[i]);
    16             vis[SG[x-f[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 }
    28  

             3.若SG(G)=SG(G1)^SG(G2)^...^Sg(Gn) > 0,局势为N,先手必胜,反之局势为P,先手必败。

        普遍优先使用打表法,只用在打表无法使用的时候再使用深搜。

  • 相关阅读:
    C#面试题
    深入浅出JSONP--解决ajax跨域问题
    vs切换当前编辑文件时自动定位目录树
    测试从应用到DB的准确的网络延迟
    MySQL死锁检测和回滚
    [磁盘空间]lsof处理文件恢复、句柄以及空间释放问题
    [硬件知识]OP(Over-provisioning)预留空间
    查看实例上面无主键的表
    mysql replace语句
    理解innodb buffer pool
  • 原文地址:https://www.cnblogs.com/wsy107316/p/11335732.html
Copyright © 2011-2022 走看看