数学—博弈

1.总述

 P-position为必败态，N-position为必胜态 能到必败态的状态为必胜态，只能到必胜态的状态为必败态。

做题思路：①手动或机器打表找规律 ②打SG表（ICG类型）③记忆化搜索（状态数有限）

注意：不要抱有记忆化搜索会少搜一些状态的侥幸心理

2.巴什博弈

问题模型：只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个，最后取光者得胜。

模型归纳：一堆n个物品，每次取一堆中的有限个，游戏次数有限。

思路：设出最后的状态为N态或P态，由N、P态之间转换关系顺推或倒推，最后求出所求状态。

例题：

1.悼念512汶川大地震遇难同胞——选拔志愿者 HDU - 2188

#include<bits/stdc++.h>

using namespace std;

/*

由题意可设n为P态，则n-1，n-2，...，n-m均为N态，n-m-1为P态

由此可观察出，当 n是m+1的倍数时，则可推出0是P态，否则为N态 

*/

int main()

{

    int Case;

    scanf("%d",&Case);

    for(int o=1;o<=Case;o++)

    {

        int n,m;

        scanf("%d%d",&n,&m);

        if(n%(m+1)==0)printf("Rabbit\n");

        else printf("Grass\n");    

    } 

    return 0;

}

3.威佐夫博弈

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

模型归纳：两堆若干个物品，每次取一堆中的若干个或两堆中的相同个，游戏次数有限。

思路：奇异状态必败，否则必胜。

关于奇异状态：https://blog.csdn.net/qq_41311604/article/details/79980882

检验威佐夫博弈模型的一个小程序：

#include<bits/stdc++.h>
using namespace std;
//利用n^2的时间可以初始化出前n组奇异局势 
int Mark[100005]={0};
int main()
{
    for(int i=1;i<=100;i++)
    {
        int tmp; 
        for(int j=0;j<=i*2;j++)
        {
            if(!Mark[j])
            {
                tmp=j;
                Mark[j]=1;
                break;
            }
        }
        Mark[tmp+i-1]=1; 
        printf("第%d个奇异局势:a为%d b为%d ",i,tmp,tmp+i-1);
        printf("a的1.618倍为%.5lf 差值的1.618倍为%.5lf\n",(sqrt(5)+1)/2*tmp,(sqrt(5)+1)/2*(i-1)); 
    }
    return 0;
}

例题：

1.取石子游戏 HDU - 1527

#include<bits/stdc++.h>

using namespace std;

//如果差值的1.618倍（取下整）等于a则为奇异局势

//理解：我们已知奇异局势差值的1.618倍再取下整为a，设其为c，那么当a、b同时加减，c与a一定会产生差值

//因此，非奇异局势一定不会有这种性质，即这个性质是充要的

//同理，根据黄金分割的性质，a的1.618倍还等于b（但要取上整） 

int main()

{

    int a,b;

    while(scanf("%d%d",&a,&b)!=EOF)

    {

        if(a>b)swap(a,b);

        //利用差值的1.618倍： 

        //if(a==((int)((b-a)*(sqrt(5)+1)/2)))printf("0\n"); 

        //else printf("1\n");

        //利用a的1.618倍： 

        if(((int)((sqrt(5)+1)*a/2))+1==b)printf("0\n"); 

        else printf("1\n");

    }

    return 0;

}

4.尼姆博弈

问题模型：有若干堆石子，每堆石子的数量都是有限的，合法的移动是“选择一堆石子并拿走若干颗（不能不拿）”，如果轮到某个人时所有的石子堆都已经被拿空了，则判负（因为他此刻没有任何合法的移动）。

模型归纳：若干堆若干个物品，每次取一堆中的若干个，游戏次数有限

思路：所有游戏状态的异或为0为必败态，否则为必胜态

证明（对总述中的三个命题）：

• 第一个命题显然，terminal position只有一个，就是全0，异或仍然是0。
• 第二个命题，对于某个局面(a1,a2,...,an)，若a1^a2^...^an<>0，一定存在某个合法的移动，将ai改变成ai'后满足a1^a2^...^ai'^...^an=0。不妨设a1^a2^...^an=k，则一定存在某个ai，它的二进制表示在k的最高位上是1（否则k的最高位那个1是怎么得到的）。这时ai^k<ai一定成立。则我们可以将ai改变成ai'=ai^k，此时a1^a2^...^ai'^...^an=a1^a2^...^an^k=0。
• 第三个命题，对于某个局面(a1,a2,...,an)，若a1^a2^...^an=0，一定不存在某个合法的移动，将ai改变成ai'后满足a1^a2^...^ai'^...^an=0。因为异或运算满足消去率，由a1^a2^...^an=a1^a2^...^ai'^...^an可以得到ai=ai'。所以将ai改变成ai'不是一个合法的移动。证毕。 

例题：

1.Rabbit and Grass

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int m;
    while(1)
    {
        scanf("%d",&m);
        if(m==0)break;
        int tmp1,tmp2=0; 
        while(m--)
        {
            scanf("%d",&tmp1);
            tmp2^=tmp1;
        }
        if(tmp2)puts("Rabbit Win!");
        else puts("Grass Win!");
    }
    return 0;
}

 

5.Fibonacci博弈

问题模型：

有一堆个数为n的石子，游戏双方轮流取石子，满足： 

• （1）先手不能在第一次把所有的石子取完； 
• （2）之后每次可以取的石子数介于1到对手刚取的石子数的2倍之间（包含1和对手刚取的石子数的2倍）。 
• 约定取走最后一个石子的人为赢家。

模型归纳：一堆若干个物品，每次取区间内的个数，游戏次数有限

思路：当n为Fibonacci数时，先手必败。即存在先手的必败态当且仅当石头个数为Fibonacci数。（打表找规律）

证明：https://blog.csdn.net/dgq8211/article/details/7602807

 

6.公平组合博弈（Impartial Combinatorial Games - ICG）

问题模型：

• 定义：
• （1）两人参与。
• （2）游戏局面的状态集合是有限。
• （3）对于同一个局面，两个游戏者的可操作集合完全相同
• （4）游戏者轮流进行游戏。
• （5）当无法进行操作时游戏结束，此时不能进行操作的一方算输。
• （6）无论游戏如何进行，总可以在有限步数之内结束。

模型归纳：若干个游戏若干种状态，每次改变一个游戏的状态，游戏次数有限

思路：

1. 将游戏对应一个有向无环图
2. mex运算：取出不存在于目标集合中的最小非负整数
3. Sprague-Garundy函数g：g(x)=mex{ g(y) | y是x的后继 }
4. 将SG值看成Nim中的石子堆，则ICG的必胜策略对应Nim的必胜策略

得到sg函数的模板：

void Getsg(int n)//n±íʾ×ÓÓÎÏ·"ʯ×Ó"¸öÊýÉÏÏÞ 
{
    memset(sg,0,sizeof(sg));
    for(int i=1;i<=n;i++)
    {
        memset(Mark,0,sizeof(Mark));
        for(int j=1;f[j]<=i;j++)Mark[sg[i-f[j]]]=1;//f[i]ΪµÚiÖÖÄÜ×ߵIJ½Êý 
        for(int j=0;j<=n;j++)//ÇóÄܵ½´ïµÄ״̬ÖеÄ×îС·Ç¸ºÕûÊý̬
        {
            if(!Mark[j])
            {
                sg[i]=j;
                break;
            }
        }
    }
} 

例题：

1.Fibonacci again and again

因为是公平组合游戏，且要求的只是判断状态，所以直接打sg表就好

#include<bits/stdc++.h>
using namespace std;
int f[20],Mark[1005],sg[1005]={0};
void Init()
{
    f[0]=1;f[1]=1;
    for(int i=2;i<=16;i++)f[i]=f[i-1]+f[i-2];//µÃµ½ì³²¨ÄÇÆõÊýÁв»´óÓÚ1000µÄÏî 
    
    for(int i=1;i<=1000;i++)//µÃµ½sgº¯Êý 
    {
        memset(Mark,0,sizeof(Mark));
        for(int j=1;f[j]<=i;j++)Mark[sg[i-f[j]]]=1;
        for(int j=0;j<=1000;j++)//ÇóÄܵ½´ïµÄ״̬ÖеÄ×îС·Ç¸ºÕûÊý̬
        {
            if(!Mark[j])
            {
                sg[i]=j;
                break;
            }
        } 
    }
}
void Solve()
{
    int n,m,p;
    while(cin>>n>>m>>p)
    {
        if(n==0&&m==0&&p==0)break;
        if(sg[n]^sg[m]^sg[p])puts("Fibo");
        else puts("Nacci");
    }
}
int main()
{
    Init();
    Solve();
    return 0;
}

7.反尼姆博弈，反公平组合博弈

问题模型：全为0为胜态，其余与之前内容相同

模型归纳：

• 先手必胜当且仅当：
• （ 1）所有堆的石子数都为 1 且游戏的 SG 值为 0；
• （ 2）有些堆的石子数大于 1 且游戏的 SG 值不为 0。
• 或者
• （1）游戏的 SG 函数不为 0 且游戏中某个单一游戏的 SG 函数大于 1；
• （2）游戏的 SG 函数为 0 且游戏中没有单一游戏的 SG 函数大于 1。

题目

1.kiki's game HDU - 2147

手动画表找规律：

#include<bits/stdc++.h>
/*
思路：画图找规律，发现行数和列数均为奇数的话必败 
*/
int main()
{
    int n,m;
    while(1)
    {
        scanf("%d%d",&n,&m);
        if(n==0&&m==0)break;
        if(n&1 && m&1)puts("What a pity!");
        else puts("Wonderful!");
    } 
    return 0;
}

2.Good Luck in CET-4 Everybody! HDU - 1847

a.记忆化搜索：

#include<bits/stdc++.h>
using namespace std;
/*
思路：根据博弈原理递推即可，此代码用记忆化搜索实现
注意：1.用什么分别表示没有访问过、负态、胜态 
时间复杂度：O（1000）空间复杂度：O（1000） 
*/
int f[1005]={0};
int dfs(int n)
{
    if(f[n])return f[n];
    if(n==0)return f[n]=-1;
    
    for(int i=0;n-(1<<i)>=0;i++)
    {
        if(dfs(n-(1<<i))==-1)return f[n]=1;
    }
    return f[n]=-1;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(dfs(n)==1)puts("Kiki");
        else puts("Cici");
    } 
    return 0;
}

 b.转化为二进制（错误的做法，因为4既可以看作100也可以看作10+10）

3.Being a Good Boy in Spring Festival

比较新的一道题，求的是一般的nim游戏，先手必胜的第一步走法的方案数

考察的是对nim博弈模型的理解

考虑由必胜态到必败态的转移时，我们是找一个数变小，然后让异或和为0，为此只需要先求出原来的异或和，找到异或和的最高位是哪一位，那么有这一位的子游戏就是能够作为必胜到必败转移策略的子游戏（且只有这种情况），证明：

1. 有这一位的话可以把这一位取反，然后较小的位也对应取反，这样可以使新异或和为0并且这样得到的新子游戏是较小的
2. 若没有这一位的话，为了消掉异或和中的这一位，就必须向高位借位，这样会使异或和产生新的高位，证毕

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,Xor,ans,pos,a[105]={0};
Ret:
    Xor=0,ans=0,pos=-1;
    scanf("%d",&n);
    if(n==0)goto End;
    for(int i=1;i<=n;i++)scanf("%d",&a[i]),Xor^=a[i];
    for(int i=20;i>=0;i--)if((1<<i)&Xor){pos=i;break;}
    if(pos!=-1)
    for(int i=1;i<=n;i++)if(a[i]&(1<<pos))ans++;
    cout<<ans<<endl;
    goto Ret;
End:
    return 0;
}
/*
1   
10
11          3
100
101         5
110
111         7
1000
1001        9
1010
1011        11
*/

4.Digital Deletions

不属于归纳出的任何一种模型，且状态数较少（100w），因此考虑用记忆化搜索

5.萌萌的糖果博弈