Book--博弈论浅结

2014-07-11 13:56:42

开门见山吧，巴什博弈不废话，直接找规律， 威佐夫博弈要记住那个公式，还有拓展（因为可能要求求出怎么“取数”），另外有空看一下公式的数学证明。

重点放在一般性博弈！（NIM博弈的n堆拓展及其他各式各样的博弈）
注：这一切建立在Impartial Game（公平游戏）的基础上。
1：PN图的构建
P（previous）：必败状态（可理解为前状态面对者胜）
N（next）：必胜状态（可理解为下一个状态面对者胜，其实就是当前面对者胜）
 
规律1：该状态为必败状态，当且仅当所有后继都是必胜状态。
规律2：该状态为必胜状态，当且仅当至少一个后继时必败状态。

类似的我们可以推出关于当前状态与其前驱状态的关系。
规律1：该状态为必败状态，当且仅当所有前驱是必胜状态。
规律2：该状态为必胜状态，当且仅当至少一个前驱为必败状态。
（前驱规律有点难，可以根据后继推前驱）
 
特例：没有后继状态（即终态）为必败状态。
 
所以，可以根据终态为P
2：SG函数的运用 
首先，看了佳哥的大白，提供些理论基础。
SG函数需要Sprague-Grundy定理（SG定理）的理论支持。假设这样一个类nim游戏，n堆火柴，每堆有num[ i ]根火柴，可以把这个游戏拆成n个游戏，每个游戏为：有一堆火柴（设为总游戏中的第k堆），每次一个游戏者可以拿至少一个，至多全部，无法拿者输，两个游戏者轮流取。恩恩，建了这样一个问题模型，SG定理：游戏和的SG函数等于各个子游戏SG函数的Nim和。这样，可以用分治的思想简化问题。（所以，Nim中的Bouton定理（即所有数nim和 ？= 0 的判定定理）可以看做SG定理在Nim游戏中的直接应用，因为单堆Nim游戏SG函数为SG（x） = x ）

SG函数的难点就在于找必败（必胜状态）然后和单堆nim思路建立联系，或者直接模拟sg函数过程。
主要有两种模拟SG函数的过程：（总结自hdu 1848）
 1：普通直接模拟
#define MAXN 1000
int sg[MAXN + 5];
//num[ 1 , 2 ....] :可以取走的石子个数
//而used数组用于记录后继状态的sg值存在与否
//count：num数组中有效数字总数 

void SG(int x)

{
    memset(sg , 0 , sizeof(sg));

    for(int i = 1; i <= x; i++)

    {

        bool used[MAXN + 5] = {0};

        for(int j = 1; j <= count; j++)

        {

            if(i - num[ j ] >= 0)

                used[ sg [ i - num[ j ] ] ] = 1;

        }

        for(int j = 0; j <= i; j++)

        {

            if(used[j] == 0)

            {

                sg[i] = j;

                break;

            }

        }

    }

}
2：用dfs进行优化

int SG_dfs(int x)

{

   if(sg[x] != -1)

        return sg[x];

    bool used[MAXN + 5] = {0};

    for(int i = 1; i <= count; i++)

    {

        if(x >= num[ i ])

        {

            sg[x - num[i]] = SG_dfs(x - num[i]);

            used[ sg [ x - num[ i ] ] ] = 1;

        }

    }

    for(int i = 0; i <= x; i++)//i <= x可有可无，但为了安全，还是加上

    {

        if(used[i] == 0)

        {

            return sg[x] = i;

        }

    }

}

3：FIB博弈 

引用：http://blog.csdn.net/dgq8211/article/details/7602807

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

1)先手不能在第一次把所有的石子取完；

2)之后每次可以取的石子数介于1到对手刚取的石子数的2倍之间（包含1和对手刚取的石子数的2倍）。

约定取走最后一个石子的人为赢家，求必败态。

这个和之前的Wythoff’s Game 和取石子游戏 有一个很大的不同点，就是游戏规则的动态化。之前的规则中，每次可以取的石子的策略集合是基本固定的，但是这次有规则2：一方每次可以取的石子数依赖于对手刚才取的石子数。

这个游戏叫做Fibonacci Nim，肯定和Fibonacci数列：f[n]：1,2,3,5,8,13,21,34,55,89,… 有密切的关系。如果试验一番之后，可以猜测：先手胜当且仅当n不是Fibonacci数。换句话说，必败态构成Fibonacci数列。

就像“Wythoff博弈”需要“Beatty定理”来帮忙一样，这里需要借助“Zeckendorf定理”（齐肯多夫定理）：任何正整数可以表示为若干个不连续的Fibonacci数之和。

先看看FIB数列的必败证明：

 

1、当i=2时，先手只能取1颗，显然必败，结论成立。

2、假设当i<=k时，结论成立。

     则当i=k+1时，f[i] = f[k]+f[k-1]。

     则我们可以把这一堆石子看成两堆，简称k堆和k-1堆。

    （一定可以看成两堆，因为假如先手第一次取的石子数大于或等于f[k-1]，则后手可以直接取完f[k]，因为f[k] < 2*f[k-1]）

     对于k-1堆，由假设可知，不论先手怎样取，后手总能取到最后一颗。下面我们分析一下后手最后取的石子数x的情况。

     如果先手第一次取的石子数y>=f[k-1]/3，则这小堆所剩的石子数小于2y，即后手可以直接取完，此时x=f[k-1]-y，则x<=2/3*f[k-1]。

     我们来比较一下2/3*f[k-1]与1/2*f[k]的大小。即4*f[k-1]与3*f[k]的大小，由数学归纳法不难得出，后者大。

     所以我们得到，x<1/2*f[k]。

     即后手取完k-1堆后，先手不能一下取完k堆，所以游戏规则没有改变，则由假设可知，对于k堆，后手仍能取到最后一颗，所以后手必胜。

     即i=k+1时，结论依然成立。

对于不是FIB数，首先进行分解。

 

分解的时候，要取尽量大的Fibonacci数。

比如分解85：85在55和89之间，于是可以写成85=55+30，然后继续分解30,30在21和34之间，所以可以写成30=21+9，

依此类推，最后分解成85=55+21+8+1。

则我们可以把n写成  n = f[a1]+f[a2]+……+f[ap]。（a1>a2>……>ap）

我们令先手先取完f[ap]，即最小的这一堆。由于各个f之间不连续，则a(p-1) > ap  + 1，则有f[a(p-1)] > 2*f[ap]。即后手只能取f[a(p-1)]这一堆，且不能一次取完。

此时后手相当于面临这个子游戏（只有f[a(p-1)]这一堆石子，且后手先取）的必败态，即先手一定可以取到这一堆的最后一颗石子。

同理可知，对于以后的每一堆，先手都可以取到这一堆的最后一颗石子，从而获得游戏的胜利。

例:HDU 2516 

明显的FIB博弈模型

 

 

[cpp]  view plain copy

 

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<algorithm>  
5. #include<cmath>  
6. #include<vector>  
7. #include<string>  
8. #include<map>  
9. #define LL long long  
10. #define N 1000000  
11. #define inf 1<<20  
12. using namespace std;  
13. int fib[50];  
14. int main(){  
15.     fib[0]=1;fib[1]=2;  
16.     for(int i=2;i<45;i++)  
17.         fib[i]=fib[i-1]+fib[i-2];  
18.     int n;  
19.     while(scanf("%d",&n)!=EOF&&n){  
20.         int i=0;  
21.         for(i=0;i<45;i++)  
22.             if(fib[i]==n)  
23.                 break;  
24.         if(i<45)  
25.             puts("Second win");  
26.         else  
27.             puts("First win");  
28.     }  
29.     return 0;  
30. }  

 

转载于:https://www.cnblogs.com/naturepengchen/articles/3837643.html