算法笔记--博弈

最新推荐文章于 2025-07-05 17:13:46 发布
原创 最新推荐文章于 2025-07-05 17:13:46 发布 · 293 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

（一）巴什博奕（Bash Game）：只有一堆n个物品，两个人轮流从这堆物品中取物，规
定每次至少取一个，最多取m个。最后取光者得胜。
n=（m+1）r+s

（二）威佐夫博奕（Wythoff Game）：有两堆各若干个物品，两个人轮流从某一堆或同
时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。
奇异局势（先手输）。前几个奇异局势是：（0，0）、（1，2）、（3，5）、（4，7）、（6，
10）、（8，13）、（9，15）、（11，18）、（12，20）
ak =[k（1+√5）/2]，bk= ak + k （k=0，1，2，…,n 方括号表示取整函数)

if(n<m) swap(n,m);
int k=n-m;
n=(int)(k*(1+sqrt(5))/2.0);
if(n==m) printf("0\n");
else printf("1\n");

（三）尼姆博奕（Nimm Game）：有三堆各若干个物品，两个人轮流从某一堆取任意多的
物品，规定每次至少取一个，多者不限，最后取光者得胜。

取完胜

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main(){
    int n;
    int a[22];
    while(scanf("%d",&n)!=EOF){
        int out=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
             out^=a[i];
        }
        if(out==0) printf("No\n");
        else printf("Yes\n");
    }
    return 0;
}

取完负

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>

using namespace std;

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        int ans=0;
        int flag=0;
        for(int i=0;i<n;i++){
            int x;
            scanf("%d",&x);
            ans^=x;
            if(x>1) flag=1;
        }
        if((ans&&!flag)||(!ans&&flag)) printf("Brother\n");
        else printf("John\n");
    }
    return 0;
}

（四）SG博奕（通用）
我们把整个博弈过程抽象为有向无环图
mex求最小非负整数mex{} = 0,mex{0,1,2,4} = 3,mex{1,2,4} = 0
sg[x] =mex{sg[y]|y是x的后继}//就是石头变少的继
这样sg就满足几个性质

  1. sg[x] == 0时，它的后继都不为零

  2. sg[x] != 0时，它的后继一定有为零的

  3. 当x点没有出边时，sg[x] == 0

这三个性质恰好与P-positon（先手必败）的性质相同：
（1）.无法进行任何移动的局面（也就是terminal position）是P-position；
（2）.可以移动到P-position的局面是N-position；
（3）.所有移动都导致N-position的局面是P-position。
由此可知：sg[x] == 0,x就是p-position

eg-hdu3980
一个圆环N个数，每次每个人只能给连续的M个数抹漆，最后不能抹的就算输
比如（5,2） +++++，
当前边空0个时子游戏为（0,2）（3,2）
当前边空1个时子游戏有（1,2）（2,2）
当前边空2个时子游戏有（2,2）（1,2）
当前边空3个时子游戏有（3,2）（0,2）

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<queue>
#include<vector>
#include<map>
#include<stack>
#include<set>
using namespace std;
typedef long long LL;
int SG[1005];

int getSG(int n,int m){
    if(n<m) return SG[n]=0;
    if(SG[n]!=-1) return SG[n];
    bool visit[1005];// //下边递归了。。不要放全局去。。。

    memset(visit,false,sizeof(visit));
    for(int i=0;i<=n-m;i++){
        visit[getSG(i,m)^getSG(n-m-i,m)]=true;
    }
    for(int i=0;;i++){
        if(visit[i]==false){
            SG[n]=i;
            break;
        }
    }
    return SG[n];
}
int main(){
    int t;
    scanf("%d",&t);
    for(int test=1;test<=t;test++){
        int n,m;
        scanf("%d %d",&n,&m);
        memset(SG,-1,sizeof(SG));
        printf("Case #%d: ",test);
        if(n<m||getSG(n-m,m)) printf("abcdxyzk\n");
        else printf("aekdycoin\n");
    }
    return 0;
}

eg-hdu5724
给一个n*20的棋盘，先给出了一堆棋子的位置，两个人轮流着进行操作。
操作：可以将棋子移到右边的第一个空位上，（不能多隔空位）
11100之后的状态可以有。11010,10110,01110.
假如直接将这种状态看成一个数（20位，不大），所以直接状压预处理出所有状态的SG，然后N行直接多问题SG亦或。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
bool SG[2000004];
int a[24];
bool visit[24];

int pow2[22];

inline void getp(){
    pow2[0]=1;
    pow2[1]=2;
    for(int i=2;i<=20;i++) pow2[i]=pow2[i-1]*2;
}
inline void geta(int x){
    int cnt=20;
    memset(a,0,sizeof(a));
    while(x){
        a[cnt--]=x%2;
        x=x/2;
    }
}
inline int getnew(int x,int i,int j){
    return x-pow2[i-1]+pow2[j-1];
}

void getSG(){
    memset(SG,0,sizeof(SG));
    int zhuang=(1<<20)-1;
    for(int i=1;i<=zhuang;i++){
        geta(i);
        memset(visit,0,sizeof(visit));
        int k=21;
        for(int j=20;j>=1;j--){
            if(a[j]==0){
                k=j;
                continue;
            }
            if(k==21) continue;
            visit[SG[getnew(i,21-j,21-k)]]=true;
        }
        for(int j=0;;j++){
            if(visit[j]==false){
                SG[i]=j;
                break;
            }
        }
    }
}
int main(){
    getp();
    getSG();
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        int out=0;
        scanf("%d",&n);
        while(n--){
            int pp=0,w,c;
            scanf("%d",&c);
            while(c--){
                scanf("%d",&w);
                pp+=pow2[20-w];
            }
            out^=SG[pp];
        }
        if(out) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

eg–hdu5795
两个人轮流从n堆石子里取走任意个（至少一个），或则不拿走石子，但是讲石子分成3堆。每堆至少为一个。最后没有石子去的人输。对于如果没有第二种分石子情况就是nim博弈，但是加了第二种状态后就不是了。因此对于每一堆石子都因该有一个SG值，因此直接对一堆石子打表SG然后找下规律就可以发现。当x%8==0 sg=x-1,当x%8==7 sg=x+1,其他的sg=x。所以所有堆sg亦或就是答案。

#include<cstdio>
#include<cstring>
using namespace std;

int SG[10006];
int getSG(int x){  //针对于一堆而言
    if(SG[x]!=-1) return SG[x];
    if(x==0) return 0; //0个可以输
    if(x==1) return 1; //1个可以赢

    int visit[10006];
    memset(visit,0,sizeof(visit));

    for(int i=0;i<x;i++) visit[getSG(i)]=1; //当成一堆时的可到状态

    for(int i=1;i<x;i++){  //分成3堆
        for(int j=i;j<x;j++){
            for(int k=j;k<x;k++){
                if(i+j+k==x){ //子问题的亦或是可到状态
                    visit[getSG(i)^getSG(j)^getSG(k)]=1;
                }
            }
        }
    }

    for(int i=0;;i++){
        if(visit[i]==0){
            return i;
        }
    }
}
int n;
int x;
int main(){
    /*
    memset(SG,-1,sizeof(SG));
    for(int i=1;i<100;i++){
        SG[i]=getSG(i);
        printf("%2d:%d\n",i,SG[i]);
    }*/

    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        int ans=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&x);
            if(x%8==0) ans^=(x-1);
            else if(x%8==7) ans^=(x+1);
            else ans^=x;
        }
        if(ans) printf("First player wins.\n");
        else printf("Second player wins.\n");
    }
    return 0;
}

eg–hdu4111

题意：有一堆的数字，两种操作：1：将某一个数值减1、2：将两个数字合并
解法：SG[i][j]表示有i个石子数为1的堆数，其它堆合并再取完的步数为j。直接SG扫就好了。。。
有几个地方重点说一下，我最开始也是没理解，后来懂了。。
（1）if(one>=1&&!getSG(one-1,sumstep)) return SG[one][sumstep]=1;
比赛时和菊苣手动模拟了一下，其实每一种状态，不管是怎样合并或取数只要子状态里出现了先手必输的状态，因此该状态可以转移到让对手必输，所以自己必赢。。。（也就只有这个点比赛时发现了）
(2) if(one>=1&&sumstep>=1&&!getSG(one-1,sumstep+1)) return SG[one][sumstep]=1;
将一个1合并到非1的上去，其他的操作步数为什么时+1，而不是2（合并+去掉），因为+2其实就是他本身的等价状态并不是子状态。+1（去掉）才是子状态。同理类推第四种情况的时候。

#include<bits/stdc++.h>
using namespace std;
int SG[55][55000];
//SG[i][j]表示有i个石子数为1的堆数，其它堆合并再取完的步数为j。
//若值为1则先取者胜，为0为先取者输
int getSG(int one,int sumstep){
    if(SG[one][sumstep]!=-1) return SG[one][sumstep];
    //没有1的时候就是各取一个
    if(one==0&&sumstep%2==1) return SG[one][sumstep]=1;
    else if(one==0&&sumstep%2==0) return SG[one][sumstep]=0;
    //当其他的步数为1时，
    if(sumstep==1) return SG[one][sumstep]=getSG(one+1,0);

    //只要找到一种是输的其他状态。那他就能赢
    SG[one][sumstep]=0;
    //1的个数去掉一个
    if(one>=1&&!getSG(one-1,sumstep)) return SG[one][sumstep]=1;
    //非1的个数去掉一个
    if(sumstep>=1&&!getSG(one,sumstep-1)) return SG[one][sumstep]=1;
    //将1的合并到非1的上去
    if(one>=1&&sumstep>=1&&!getSG(one-1,sumstep+1)) return SG[one][sumstep]=1;
    //将两个1的合并
    if(one>=2){
        //非1的为0，相当于将一个1加到另一个1上，
        if(sumstep==0&&!getSG(one-2,sumstep+2)) return SG[one][sumstep]=1;
         //非1的为0，相当于将两个1加到非1上，
        else if(sumstep!=0&&!getSG(one-2,sumstep+3)) return SG[one][sumstep]=1;
    }
    return SG[one][sumstep];
}

int main(){
    int t;
    scanf("%d",&t);
    memset(SG,-1,sizeof(SG));
    for(int cas=1;cas<=t;cas++){
        int n;
        int one=0,sumstep=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            if(x==1) one++;
            else sumstep+=x+1;//合并，去掉
        }
        if(sumstep) sumstep--; //合并为p-1次，
        if(getSG(one,sumstep)) printf("Case #%d: Alice\n",cas);
        else printf("Case #%d: Bob\n",cas);
    }
    return 0;
}

SG 模板写法
#include<bits/stdc++.h>
using namespace std;
int SG[55][55000];
int getSG(int one,int sumstep){
    if(SG[one][sumstep]!=-1) return SG[one][sumstep];
    if(one==0&&sumstep%2==1) return SG[one][sumstep]=1;
    else if(one==0&&sumstep%2==0) return SG[one][sumstep]=0;

    if(sumstep==1) return SG[one][sumstep]=getSG(one+1,0);

    //SG[one][sumstep]=0;
    bool visit[2];
    memset(visit,false,sizeof(visit));

    if(one>=1) visit[!getSG(one-1,sumstep)]=true;
    if(sumstep>=1)visit[!getSG(one,sumstep-1)]=true;
    if(one>=1&&sumstep>=1) visit[!getSG(one-1,sumstep+1)]=true;
    if(one>=2){
        if(sumstep==0) visit[!getSG(one-2,sumstep+2)]=true;
        else visit[!getSG(one-2,sumstep+3)]=true;
    }
    if(visit[1]==true) return SG[one][sumstep]=1;//推出来的
    else return SG[one][sumstep]=0;
}

int main(){
    int t;
    scanf("%d",&t);
    memset(SG,-1,sizeof(SG));
    for(int cas=1;cas<=t;cas++){
        int n;
        int one=0,sumstep=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            if(x==1) one++;
            else sumstep+=x+1;//合并，去掉
        }
        if(sumstep) sumstep--; //合并为p-1次，
        if(getSG(one,sumstep)) printf("Case #%d: Alice\n",cas);
        else printf("Case #%d: Bob\n",cas);
    }
    return 0;
}
数据结构与算法学习笔记----博弈论
weixin_60278491的博客
02-06 1306
@@ author: 明月清了个风ps⭐️包含了博弈论中的两种问题Nim游戏和SG函数，一共四道例题，给出了具体公式的证明过程。
算法博弈论笔记 - 3 梅尔森的引理
sonetto的博客
09-25 1416
算法博弈论笔记 - 3 梅尔森的引理 因为感觉看英文教材比较不好理解，所以打算把重点记下来。 维氏拍卖作为一个好的拍卖(Awesome Auctions)，具有3个保证 [强动机保证] DSIC (Dominant Strategy Incentive Compatible). 即真实的竞价是优势策略，并且永远不会导致负的效益。 追求DSIC的理由有两个： 投标人只需要很轻易地投出对于他们来说最具有优势的价格； 如果所有投标人都按照优势策略的价格进行投标，那么我们能够很自信地预测拍卖的结果。 [
威佐夫博奕
SHUI
07-31 894
威佐夫博奕
四种博弈总结
YOUNG的博客
10-28 3284
1.巴什博弈 题目大意： 1、 本游戏是一个二人游戏; 2、 有一堆石子一共有n个； 3、 两人轮流进行; 4、 每走一步可以取走1…m个石子； 5、 最先取光石子的一方为胜； 显然如果n=m+1,最多只能取m个石子，所以不管先取者拿走多少个石子，后取者必能取光，后取者胜利。所以如果n%(m+1)==0，后取者胜利，反之先取者胜利。 [题目链接 HDU 2846](http:...
【算法设计与分析】三个博弈论算法分析
热门推荐
精灵的博客
02-01 1万+
主要讨论三个比较常见的博弈游戏 Bash Game,Nim Game和Wythoff Game，较为领人惊叹的是，他们最后都是通过数论或者自然数性质完美解决： Bash    Game:同余理论 Nim      Game:异或理论 Wythoff Game:黄金分割 （1）Bash Game：一堆n个物品，两人轮流取，每次取1至m个，最后取完者胜           比如10个物品，
算法笔记-博弈论
2301_80105412的博客
04-14 400
4.14 初稿。
笔记---简单博弈论
2302_79440616的博客
02-04 981
满足一下几个特征：1.两名玩家交替行动。2.在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关。3.不能行动的玩家判为失败如果满足以上特征，那么就是一个公平组合游戏另一种游戏叫做有向图游戏：给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子，两名玩家交替的把这枚棋子沿有向边进行移动，每次可以一定一步，最终无法移动的人判为失败给定n堆石子，两位玩家轮流操作，每次操作可以从任意一堆石子中拿走任意数量的石子（可以拿完，但不能不拿），最后无法进行操作的人视为失败。
算法笔记：博弈问题
GANIT的博客
06-06 517
先找到XOR最高位1（即前面的所有位都为0），找所有堆数量的二进制位包含这位1（至少有一个，因为是奇数），将除这个数的其余均XOR，结果一定<这个数（设该位1为第x位，那么XOR结果前x位都为0，而这个数第x位为1），因此通过调整这个数，可以使得（这个数）XOR（其余数XOR结果）==0。=0，那么我一定可以通过玩一个小ICG游戏，使得总XOR值==0，即将敌方掉入必输局面（XOR==0，即SG总（x）== 0）。还是有必败点SG（0）== 0，设SG（x）== 0，表示当前局面必败；
博弈论基础-笔记
ysa051030的博客
07-05 673
1-3区间，先手比较了一下，如果取10，那么就是把1-2区间给对方差0，最后差10，取1把2-3区间给对方，显然2-3区间差-9，最后-8，取前者。首先，我们发现手里就1个，输，2个，分成11，必赢，3个，只能分成12，对方会选2，4显然分13，5显然必输。这时候，你发现，5-3，不论怎么取，你都会把刚才那些比5-3小的给对方，然后对方反手给你2-1。不确定，但是确实卡住了。-4呢，5-4，你发现可以变成2-1，6-4，你发现可以变成5-3。然后1-4区间，如果取1，把24给对方，差-(-8)，最后差9。
算法笔记-哈希算法1
java程序员笔记
12-22 687
什么是哈希算法 将任意长度的二进制值串映射为固定长度的二进制值串，这个映射规则就是哈希算法，映射得到的值就叫哈希值。 设计一个优秀的哈希算法，需要注意以下几点： 1：从哈希值不能反向推导出原始数据，所以哈希算法也叫单项哈希算法。 2：对输入数据非常敏感，哪怕原始数据修改了 1 个 Bit，最后得到得哈希值也不一样。 3：散列冲突的概率要小，对于不同的原始数据，得到的哈希值相同的概率要小。 4：哈希...
vrp综述摘要笔记-04101
08-03
此外，源自其他优化领域的方法（例如超启发式算法、基于蒙特卡洛模拟的方法、根植于博弈论和双层优化的 Stackelberg 游戏算法，以及受认知启发的方法）最近进入 VRP 领域，并成为传统技术的可行替代方案。...
精选资源
蓝桥杯常用C++STL函数笔记-两点水.pdf
11-19
在C++编程中，STL（Standard Template Library，标准模板库）是一套强大的工具，它提供了许多高效的数据结构和算法。在蓝桥杯等编程竞赛或项目开发中，熟悉并熟练运用STL能够显著提高代码的效率和可读性。本笔记主要...
算法博弈论笔记 - 4 算法机制设计
sonetto的博客
09-30 1350
本节通过运用梅尔森的引理，在单一参数环境下设计对于背包问题的DSIC机制。 定义问题 在背包问题中，每位投标人iii都公开地有一个需要投标的size wisize \text{ }w_isize wi​表示大小，以及对于大小的一个私有的估价。设拍卖的容量为WWW，可行集合XXX是由0-1的集合(x1,…,xn)(x_1,\ldots,x_n)(x1​,…,xn​)组成，并且∑i=1nwixi<=W\sum _{i=1}^n w_ix_i <= W∑i=1n​wi​xi​&l.
CNN-BiLSTM 癫痫预测 理学学士论文项目.zip
12-29
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
【移动应用分析】微信抖音支付宝高德地图使用痛点与优化策略：四款国民级APP生态变现模式及用户体验提升方案研究
最新发布
12-29
【移动应用分析】微信抖音支付宝高德地图使用痛点与优化策略：四款国民级APP生态变现模式及用户体验提升方案研究
【多变量输入超前多步预测】基于CNN-BiLSTM的光伏功率预测研究（Matlab代码实现）
12-29
【多变量输入超前多步预测】基于CNN-BiLSTM的光伏功率预测研究（Matlab代码实现）内容概要：本文介绍了基于CNN-BiLSTM模型的多变量输入超前多步光伏功率预测方法，并提供了Matlab代码实现。该研究结合卷积神经网络（CNN）强大的特征提取能力与双向长短期记忆网络（BiLSTM）对时间序列前后依赖关系的捕捉能力，构建了一个高效的深度学习预测模型。模型输入包含多个影响光伏发电的气象与环境变量，能够实现对未来多个时间步长的光伏功率进行精确预测，适用于复杂多变的实际应用场景。文中详细阐述了数据预处理、模型结构设计、训练流程及实验验证过程，展示了该方法相较于传统模型在预测精度和稳定性方面的优势。; 适合人群：具备一定机器学习和深度学习基础，熟悉Matlab编程，从事新能源预测、电力系统分析或相关领域研究的研发人员与高校研究生。; 使用场景及目标：①应用于光伏电站功率预测系统，提升电网调度的准确性与稳定性；②为可再生能源并网管理、能量存储规划及电力市场交易提供可靠的数据支持；③作为深度学习在时间序列多步预测中的典型案例，用于科研复现与教学参考。; 阅读建议：建议读者结合提供的Matlab代码进行实践操作，重点关注数据归一化、CNN特征提取层设计、BiLSTM时序建模及多步预测策略的实现细节，同时可尝试引入更多外部变量或优化网络结构以进一步提升预测性能。
TrendLens慧瞰是一款基于深度学习的财经信息实时分析系统_该系统专注于对股票市场动态大宗商品价格波动金融科技政策演变宏观经济指标发布行业研报深度解析公司财报关键.zip
12-29
TrendLens慧瞰是一款基于深度学习的财经信息实时分析系统_该系统专注于对股票市场动态大宗商品价格波动金融科技政策演变宏观经济指标发布行业研报深度解析公司财报关键.zip
若依框架集成达梦数据库执行脚本
12-29
若依框架集成达梦数据库执行脚本
多源信息择源重用框架.rar
12-29
用以实现实时操作系统下的数据择源。满足信息类软件数据择源需求。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值