博弈基础小结

巴什博弈

一堆n个物品，两个人轮流取1~m个，最后一个取光的人胜利

if(n%(m+1)) return false;
else return true;

wythoff博弈

两堆各若干个物品，两人轮流从一堆中取走至少一个，或者从两堆中取走相同数量的物品，最后一个取光的人胜利

差值 * 黄金分割比 == 最小值时后手赢，否则先手赢

double r = (sqrt(5.0)+1) / 2;
int d = abs(a-b) * r;
if( d != min(a,b) ) return true;
else return false;

尼姆博弈

n堆物品，两人轮流取至少一个，最后一个取光的人胜利

int res = 0;
for(int i=1;i<=n;i++){
    res = res ^ a[i];
}
if(res) return true;
else return false;

SG函数

hdu1848，斐波那契堆

#include <iostream>
#include <string.h>
#define MAXN 3010
using namespace std;

int f[MAXN], sg[MAXN];

void init(){//得到1000以内的fibonacci数列
    f[1]=1;
    f[2]=2;
    for(int i=3; ; i++){
        f[i]=f[i-1]+f[i-2];
        if(f[i]>1000){
            break;
        }
    }
}

void get_sg(){//sg函数打表
    for(int i=1; i<=1000; i++){
        int vis[MAXN];
        memset(vis, 0, sizeof(vis));
        for(int j=1; f[j]<=i; j++){//找到当前节点能到达的点
            vis[sg[i-f[j]]]=1;
        }
        for(int j=0; j<=1000; j++){//求mex函数
            if(!vis[j]){
                sg[i]=j;
                break;
            }
        }
    }
}

int main(void){
    init();
    get_sg();
    int n, m, p;
    while(cin >> n >> m >> p){
        if(n+m+p==0){
            break;
        }
        if(sg[n]^sg[m]^sg[p]){//sg函数性质
            cout << "Fibo" << endl;
        }else{
            cout << "Nacci" << endl;
        }
    }
    return 0;
}

hdu1847，二的幂次

#include<bits/stdc++.h>
using namespace std;


const int maxn = 1010;
int a[20];
int sg[maxn+5];
int n;
int vis[maxn+5];

//sg[1] == 0 //必胜局
//sg[2] == 0 //必胜局 

void getSg(){
    memset(sg,0,sizeof(sg));
    for(int i=1;i<=maxn;i++){
        //寻找每一个i的sg值 
        memset(vis,0,sizeof(vis));
        for(int j=0;j<11;j++){ //枚举可以拿的数量("能拿"说明比当前拥有的数量i小) 
            int temp = i - a[j];
            if(temp < 0 )break;
            vis[sg[temp]] = 1;//可以由temp这个局面推出来
        }
        for(int j=0;j<maxn;j++){
            if(vis[j] == 0){
                sg[i] = j;//sg值为 mex集合中最小的值 
                break;
            }
        }
    }
}


int main(){
    a[0] = 1;
    for(int i=1;i<11;i++){
        a[i] = a[i-1]*2;//可以拿的数量  打表 
    }
    getSg();
    int n;
    while(cin>>n){
        if(sg[n]) puts("Kiki");
        else puts("Cici");
    }

    return 0;
} 

记忆化搜索的递归写法：

memset(sg,-1,sizeof(sg)); 
int mex(int x){
    if(sg[x] != -1) return sg[x];
    bool vis[1200];
    memset(vis,false,sizeof(vis));
    for(int i=0;i<11;i++){
        int temp = x - a[i];
        if(temp < 0) break;
        sg[temp] = mex(temp); //mex:mex操作的含义找到集合中最小的元素 
        vis[sg[temp]] = true; //标记为集合中有的 
    }
    for(int i=0;;i++){
        if(!vis[i]){
            sg[x] = i;
            break;
        }
    }
    return sg[x];
}

转载于:https://www.cnblogs.com/fisherss/p/10809951.html