博弈论

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

• n%(m + 1) == 0时，先手败，否则先手胜。

•巴什博弈的一般情况见HDU-2897

<抽象模型，有些要找规律>

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

• 求解：
  ak =[k（1+√5）/2]，bk= ak + k （k=0，1，2，…,n 方括号表示取整函数)

（ak,bk)是奇异局势，当A面对奇异局势是必输

<熟记公式>

3.尼姆博弈

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

•  若a ^ b ^ c == 0，则(a, b, c)是必败态

4.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函数值是它的所有子游戏的SG函数值的异或。（0必败）

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;

        }

    }

}

5.PN图的构建

P（previous）：必败状态
N（next）：必胜状态
特点1 ：该状态为必败状态，当且仅当所有后继都是必胜状态。
特点1 ：该状态为必胜状态，当且仅当至少一个后继时必败状态。
特例：没有后继状态（即终态）为必败状态。
所以，可以根据终态为P

例如：HDU-2147

PN图构建代码为：

#include <bits/stdc++.h>
using namespace std;
bool ma[2001][2001];//1 P 0 N;
int main(){
       int i,j,k;
       ma[1][1]=1;
       for(i=2;i<=2000;i++)
       {
              if(ma[i-1][1])
                     ma[i][1]=0;
              else ma[i][1]=1;
              for(j=2;j<i;j++){
                     if(!ma[i][j-1]&&!ma[i-1][j-1]&&!ma[i-1][j])
                            ma[i][j]=1;
                     else ma[i][j]=0;
              }
              if(ma[1][i-1])
                     ma[1][i]=0;
              else ma[1][i]=1;
              for(j=2;j<i;j++){
                     if(!ma[j-1][i]&&!ma[j-1][i-1]&&!ma[j][i-1])
                            ma[j][i]=1;
                     else ma[j][i]=0;
              }
              if(!ma[i][i-1]&&!ma[i-1][i-1]&&!ma[i-1][i])
                     ma[i][i]=1;
              else ma[i][i]=0;
       }
       int M,N;
       for(i=1;i<=10;i++){
              for(j=1;j<=10;j++)
                     printf("%c ",ma[i][j]?'P':'N');
              printf("\n");
       }
       while(scanf("%d%d",&M,&N)&&M&&N){
              if(ma[M][N]) printf("What a pity!\n");
              else printf("Wonderful!\n");
       }
       return 0;
}

<不同题目有不同的构建代码，但都按照PN图两个特点来实现>

<部分题目手动画PN图很方便~>

6.FIB博弈 

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

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

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

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

斐波那契博弈有一个非常重要的性质：

先手必败，当且仅当石子数为斐波那契数：

（图截自360百科）

先看看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 <此题可手动画出PN图发现规律>

明显的FIB博弈

#include<iostream> 

#include<cstdio> 

#include<cstring> 

#include<algorithm> 

#include<cmath> 

#include<vector> 

#include<string> 

#include<map> 

#define LL long long 

#define N 1000000 

#define inf 1<<20 

using namespace std; 

int fib[50]; 

int main(){  

   fib[0]=1;fib[1]=2;  

   for(int i=2;i<45;i++)  

       fib[i]=fib[i-1]+fib[i-2];  

   int n;  

   while(scanf("%d",&n)!=EOF&&n){  

       int i=0;  

       for(i=0;i<45;i++)  

           if(fib[i]==n)  

               break;  

       if(i<45)  

           puts("Second win");  

       else  

           puts("First win");  

   }  

   return 0; 

}  

引用：https://www.cnblogs.com/naturepengchen/articles/3837643.html

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