博弈论(Bash博弈、Nim博弈、SG函数、组合博弈)

最新推荐文章于 2024-03-11 22:46:53 发布
最新推荐文章于 2024-03-11 22:46:53 发布
阅读量1.1k 收藏 6
点赞数 2
分类专栏： 算法 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40342400/article/details/127631866
版权

组合博弈入门

一、博弈论三条性质：

  • 终结点为P点

  • P点只能到N点

  • N点至少有一种途径到P点

N：必胜态 P：必败态

  

1、引导题

1846 Brave Game

题目大意：
n个石子两人轮流取1~m个，最后取空的胜利


n：23  m：2
0：P      //终结点
1：N
2：N
3：P
4：N
5：N
6：P

结论： x % (m + 1) == 0 则为P点

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int t, n, m;
    cin >> t;
    while (t--) {
        cin >> n >> m;
        cout << (n % (m + 1) ? "first" : "second") << endl;
    }
    return 0;
}

 

2、引导题

1847 Good Luck in CET-4 Everybody!

题目大意：
n张纸牌两人轮流取2的幂次(1, 2, 4, 8, 16……),最后取空的胜利

同理上一题取石子
0 1 2 3 4 5 6 7 8 9 10 11 12 13
P N N P N N P N N P N  N  P  N
结论： n % 3 == 0 则为P点

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int n;
    while (cin >> n) {
        cout << ((n % 3) ? "Kiki" : "Cici") << endl;
    }
    return 0;
}

  

  

二、NIM博弈

定理： 如果先手必胜，则有 A 1   x o r   A 2   x o r   . . .   A n   ≠   0 A_1\ xor \ A_2\ xor\ ...\ A_n\ \ne\ 0 A1​ xor A2​ xor ... An​ = 0

  就是控0，所有堆都为空时异或为0。只要还剩石子，并且异或为0，那么至少还有两堆，或者说一次必取不完局面。就把这种局面一直扔给对手，使自己保证永远不败状态，此时无论对手怎么取，异或都不为0。

27:	  11011  num[0]  
8:    01000  num[1]
20:   10100  num[2]
13:   01101  num[3]
      ---- ^
10:   01010  sum

nim[i] > (nim[i] ^ sum) 为可选方案  注意：运算符优先级
nim[i] = nim[i] ^ sum 为具体调整方案

  

1、先手状态判定

1849 Rabbit and Grass

题目大意：
n堆石子，两人轮流选一堆取走任意个，最后取空的胜利，问先手必赢还是必输

解题思路：NIM博弈

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int n;
    while (cin >> n && n) {
        int Xor = 0, x;
        while (n--) {
            cin >> x;
            Xor ^= x;
        }
        cout << (Xor ? "Rabbit Win!" : "Grass Win!") << endl;
    }
    return 0;
}

  

2、先手必胜第一手方案数

1850 Being a Good Boy in Spring Festival

题目大意：
nim博弈如果先手必胜的话，那么输出第一步用多少种选择。反之先手必败输出0

#include <iostream>
#include <cstdio>

using namespace std;

#define N 100

int nim[N +  10];

int main() {
    int n;
    while (scanf("%d", &n) && n) {
        int sum = 0, ans = 0;
        for (int i = 0; i < n; ++i) {
            scanf("%d", nim + i);
            sum ^= nim[i];
        }
        for (int i = 0; i < n; ++i) {
            if (nim[i] > (nim[i] ^ sum))  ++ans;
            //nim[i] = nim[i] ^ sum 为具体调整方案
        }
        printf("%d\n", ans);
    }
    return 0;
}

  

  

  

三、SG函数

有向图游戏

​ 给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。
​ **任何一个公平组合游戏都可以转化为有向图游戏。**具体方法是,把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。

Mex运算

​ 设 S S S​​​ 表示一个非负整数集合。定义 M e x ( S ) Mex(S) Mex(S)​ 为求出不属于集合 S S S​ 的最小非负整数的运算。

SG函数

​ 在有向图游戏中，对于每个节点 x x x , 设从 x x x 出发共有 k k k 条有向边，分别到达节点 y 1 , y 2 , . . . , y k y_1,y_2,...,y_k y1​,y2​,...,yk​，定义 S G ( x ) SG(x) SG(x)为 x x x 的后继节点 y 1 , y 2 , . . . , y k y_1,y_2,...,y_k y1​,y2​,...,yk​ 的 S G SG SG函数值构成的集合再执行$Mex\ ​运算的结果，即 ​运算的结果，即 ​运算的结果，即SG(x)=Mex({SG(y_1),SG(y_2),…,SG(y_k)})$​

​ 特别的，整个有向图游戏 G G G​​​ 的 S G SG SG 函数值被定义为有向图游戏起点 s s s 的 S G SG SG 函数值，即 S G ( G ) = S G ( s ) SG(G) = SG(s) SG(G)=SG(s)​

​ 有向图游戏的和：设 G 1 , G 2 , . . . , G m G_1, G2, ... ,G_m G1​,G2,...,Gm​​是 m m m​ 个有向图游戏。定义有向图游戏 G G G​，它的行动规则是任选某个有向图游戏 G i G_i Gi​​，并在 G i G_i Gi​​上行动一步。 G G G​ 被称为有向图游戏 G 1 , G 2 , … , G m G_1,G_2,…,G_m G1​,G2​,…,Gm​​ 的和

​ 有向图游戏的和的 S G SG SG​​函数值等于它包含的各个子游戏 S G SG SG​函数值的异或和，即: S G ( G ) = S G ( G 1 )   x o r   S G ( G 2 )   x o r   . . .   x o r   S G ( G m ) SG(G)= SG(G_1) \ xor\ SG(G_2) \ xor\ ...\ xor\ SG(G_m) SG(G)=SG(G1​) xor SG(G2​) xor ... xor SG(Gm​)​

​ 定理

​ 有向图游戏的某个局面必胜，当且仅当该局面对应节点的 S G SG SG​​函数值大于 0 0 0

​ 有向图游戏的某个局面必败，当且仅当该局面对应节点的 S G SG SG​函数值等于 0 0 0​

​ 我们不再详细证明该定理。读者可以这样理解:
​ 在一个没有出边的节点上，棋子不能移动，它的 S G SG SG​​​​​​值为 0 0 0​​​​​​，对应必败局面。若一个节点的某个后继节点 S G SG SG​​​​​​值为 0 0 0​​​​​​，在$\ Mex\ ​​​​​​运算后，该节点的 ​​​​​​运算后，该节点的 ​​​​​​运算后，该节点的SG$​​​​​​值大于 0 0 0​​​​​​.这等价于，若一个局面的后继局面中存在必败局面，则当前局面为必胜局面。
​ 若一个节点的后继节点 S G SG SG​​​​值均不为 0 0 0​​​，在$\ Mex\ ​运算后，该节点的 ​运算后，该节点的 ​运算后，该节点的SG$​值为 0 0 0。这等价于，若一个局面的后继局面全部为必胜局面，则当前局面为必败局面。
  

1、多堆取石子

1848 Fibonacci again and again

题目大意：
三堆石子，两人轮流取f个，最后取空的胜利
f[1] = 1, f[2] = 2, f[3] = 3, f[4] = 5, ... , f[n] = f[n - 1] + f[n - 2]

解题思路：SG函数

在这里插入图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 1000

int SG[N + 10], flag[N + 10], fib[N];

void Get_Fib() {
    fib[1] = 1;
    fib[2] = 2;
    for (int i = 3; fib[i - 1] < N; ++i)  fib[i] = fib[i - 1] + fib[i - 2];
    return ;
}

void Get_SG() {
    for (int i = 1; i <= N; ++i) {
        memset(flag, 0, sizeof(flag));
        for (int j = 1; i - fib[j] >= 0; ++j)  flag[SG[i - fib[j]]] = 1;
        int ind = 0;
        while (flag[ind])  ++ind;
        SG[i] = ind;
    }
    return ;
}

int main() {
    Get_Fib();
    Get_SG();
    int m, n, p;
    while(scanf("%d%d%d", &m, &n, &p) && m && n && p) {
        printf("%s\n", SG[m] ^ SG[n] ^ SG[p] ? "Fibo" : "Nacci");
    }
    return 0;
}

  

2、拍卖会

2149 Public Sale

题目大意：
底价为0，轮流加价1~m，率先加到不小于n的胜利。依次输出先手必胜的情况第一次可以叫的价钱，如果先手必败输出none

解题思路：
以终点n作为博弈起点，倒序求SG值
SG yyds！

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 1100

int SG[N + 10], flag[N + 10];

void Get_SG(int n, int m) {
    for (int i = n; i > 0; --i) {
        memset(flag, 0, sizeof(flag));
        for (int j = 1; j <= m && i + j <= n; ++j) {
            flag[SG[i + j]] = 1;
        }
        for (int j = 0; ; ++j) {
            if (flag[j] == 0) {
                SG[i] = j;
                break;
            }
        }
    }
    return ;
}

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        if (m >= n) {
            for (int i = n; i <= m; ++i) {
                if (i - n)  putchar(' ');
                printf("%d", i);
            }
            putchar('\n');
            continue;
        }
        Get_SG(n, m);
        bool is = true;
        for (int i = 1; i <= m; ++i) {
            if (SG[i])  continue;
            if (!is)  putchar(' ');
            printf("%d", i);
            is = false;
        }
        if (is)  printf("none\n");
        else  putchar('\n');
    }
    return 0;
}

  

3、志愿者选拔

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

题目大意：
低价为0，轮流加价1~m，率先加到不小于n的胜利。先手必胜输出Grass，反之Rabbit

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 10000
#define M 10        //注意这里可以节约空间花销，m<=10,一个点最多十个后继，SG值不可能大于等于10

int SG[N + 10], flag[M + 10];

void Get_SG(int n, int m) {
    for (int i = n; i > 0; --i) {
        memset(flag, 0, sizeof(flag));
        for (int j = 1; j <= m && i + j <= n; ++j) {
            flag[SG[i + j]] = 1;
        }
        for (int j = 0; ; ++j) {
            if (flag[j])  continue;
            SG[i] = j;
            break;
        }
    }
    return ;
}

int main() {
    int t, n, m;
    cin >> t;
    while (t--) {
        scanf("%d%d", &n, &m);
        if (m >= n)  printf("Grass\n");
        else {
            Get_SG(n, m);
            bool is = 0;
            for (int i = 1; i <= m; ++i) {
                if (SG[i])  continue;
                is = 1;
                break;
            }
            printf("%s\n", is ? "Grass" : "Rabbit");
        }
    }
    return 0;
}

  

4、组合博弈

1536 S-Nim

1944 S-Nim

题目大意：
5 1 2 3 4 5   //5种取子规则
3             //3次询问
2 5 12        //第一次 2堆石子 分别5和12块石子
3 2 4 7		  //第二次
4 2 3 7 12    //第三次
0			  //输入0结束

记忆化搜索SG值，只计算用到的SG值，没有用到的SG值不计算，减少了部分时间开销

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

#define N 10000
#define M 100

int vis[M + 5], SG[N + 5];   //vis取子规则 

int Get_SG(int x, int &k) {
    if (~SG[x])  return SG[x];
    int flag[M + 5] = {0};
    for (int i = 1; i <= k && x - vis[i] >= 0; ++i) {
        flag[Get_SG(x - vis[i], k)] = 1;
    }
    int ind = 0;
    while (flag[ind])  ++ind;
    return SG[x] = ind;
}

int main() {
    int k, t;
    while (scanf("%d", &k) && k) {
        memset(SG, -1, sizeof(SG));
        SG[0] = 0;
        for (int i = 1; i <= k; ++i)  scanf("%d", vis + i);
        sort(vis + 1, vis + k + 1);    //取子规则需提前排序
        scanf("%d", &t);
        while (t--) {
            int n, Xor = 0;
            scanf("%d", &n);
            for (int i = 1, x; i <= n; ++i) {
                scanf("%d", &x);
                Xor ^= Get_SG(x, k);
            }
            printf("%c", Xor ? 'W' : 'L');
        }
        putchar('\n');
    }
    return 0;
}
Lu Zelin
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博弈论试题小结
04-15
博弈论经典问题，巴什博奕（Bash Game），威佐夫博奕（Wythoff Game），尼姆博奕（Nimm Game）等
关于bash函数你可能不知道的一些事情（译）
01-20
关于bash函数，这里有一些您不知道的东西。通常当你写一个函数时，你会这样做: function name () { ... } 不是吗?我知道你会这么做，因为这是所有人写函数的方式。这就是我要说的。在bash中 {…} 并不像在JavaScript或c中那样意味着“函数的主体”或“函数的范围”，它实际上是一个复合命令。你可以做各种稀奇古怪的事情，比如: function fileExists () [[ -f $1 ]] 不需要那些花括号!者你可以这样做: function isEven () (( $1 % 2 == 0 )) 这个函数是一个算术计算式。或者你可以这样做: fu
bash写的字符串常用函数
04-23
bash写的字符串常用函数，这个可以看看。资源分就免了
shell:Bash Shell脚本和函数库
03-08
Bash Shell脚本和功能 概述 这是实用程序脚本和帮助程序功能的集合。 您可以在bin/目录中找到脚本，并在lib/ dir中找到函数库。 有关详细信息，请检查文档。 用法 大多数脚本使用库中的函数，因此它们需要在脚本内部获取源才能使用。 为此，有sourcer 。 它所做的只是包括lib目录中的每个库文件。 因此，如果您需要这些库，那么您所要做的就是包括（来源） sourcer脚本，然后它就完成了工作。 为了使其正常工作，它使用环境变量（ DIR_SHELL_LIB ）获取lib目录的路径。 . /path/to/sourcer 或者，您可以在采购源sourcer时设置此环境sourcer DIR_SHELL_LIB=/path/to/lib/dir . sourcer 提示：您可以将sourcer放在.bashrc ，以便在命令行上可以使用这些功能。
Matlab|计及需求响应和电能交互的多主体综合能源系统主从博弈优化调度策略
superone89的博客
03-11 1006
下层采用混合整数规划算法求解出三个园区、配电网、储能电站、集中型风电场间的最优调度策略，下层程序采用matlab+cplex求解(也可替换为gurobi)，程序注释清楚，方便学习！
常见的博弈论专题详解（附有例题）
m0_73557680的博客
05-22 1596
尼姆博弈，威佐夫博弈，巴什博弈
博弈论——巴什博弈（C++）
小天狼星_布莱克 的博客
06-04 1236
有一种很有意思的游戏，就是有物体若干堆，可以是火柴棍或是围棋子等等均可。两个人轮流从堆中取物体若干，规定最后取光物体者取胜。这是我国民间很古老的一个游戏，别看这游戏极其简单，却蕴含着深刻的数学原理。下面我们来分析一下要如何才能够取胜。
数学知识——博弈论（巴什博奕、尼姆博奕、威佐夫博奕）思路及例题
热门推荐
WSY444的博客
06-23 4万+
争先恐后地博弈
博弈论
还我笑颜
11-08 828
转载：点击查看链接 序：博弈是信息学和数学试题中常会出现的一种类型，算法灵活多变是其最大特点，而其中有一类试题更是完全无法用常见的博弈树来进行解答。 寻找必败态即为针对此类试题给出一种解题思路。 此类问题一般有如下特点：     1、博弈模型为两人轮流决策的非合作博弈。即两人轮流进行决策，并且两人都使用最优策略来获取胜利。     2、博弈是有限的。即无论两人怎样决策，都会在有限步后决出胜...
博弈论-Bash博弈
weixin_45925735的博客
01-15 223
首先谈一下最简单的Bash博弈。Bash博弈是这样的：两个人，n个物品，每个人每次都可以取走1-m个物品，取走最后一个物品的人胜利。问先手在什么条件下必胜。 #include <bits/stdc++.h> #define ll long long #define inf 0x3f3f3f3f #define fi first #define se second #define endl '\n' #define IOS std::ios::sync_with_stdio(false),cin.
hdu 1846
Tdreamge的专栏
03-13 524
）巴什博奕（Bash Game）：只有一堆n个物品，两个人轮流从这堆物品中取物，规 定每次至少取一个，最多取m个。最后取光者得胜。     显然，如果n=m+1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个， 后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则：如果 n=（m+1）r+s，（r为任意自然数，s≤m),那么先取者要拿走s个物品，如果后取者拿走
C语言实现极小极大搜索算法五子棋
qq_44671353的博客
02-23 6383
C语言实现极小极大搜索算法五子棋极小极大算法α-β剪枝棋子生成局面分数评估程序代码 本人只是一名大二学生，技术有限，代码比较乱，希望指正，这也是我第一次写博客，排版也不好，见谅。 极小极大算法 不管是什么棋类，看似很复杂，但都可以把每一种走法列出来，列出来后，你就可以发现，它就是一颗博弈树。所以我们可以用极小极大搜索算法来实现五子棋。 极小极大算法博弈树的生成，每一层分为MAX层或MIN层，如图（...
AtCoder Grand Contest
weixin_34159110的博客
08-09 512
一句话题解 QwQ主要是因为这篇文章写的有点长……有时候要找某一个题可能不是很好找，所以写了这个东西。 具体的题意、题解和代码可以再往下翻。_(:з」∠)_ AGC 001 C：枚举中点/中边。 D：构造。 E：根据组合数意义转为$DP$。 F：拓扑排序，线段树优化连边。 AGC 002 C：水题，看是否有a[i]+a[i+1]>=k。 D：并查集上倍增，二分答案。 E...
bash 博弈
weixin_30498807的博客
04-24 90
转载并修改自： http://www.cnblogs.com/wulangzhou/archive/2013/03/14/2959660.html 简单的取拿游戏一堆石子（或者其它的什么东西），下面是简单的取拿游戏规则：两名玩家，称为 I 和 II；有一堆石子，一共 21 个；一次移动操作包括取走 1 个，2 个，或者 3 个石子，至少得取走 1 个，至多取走 3 个。玩家 I 先开始，交替取...
【bzoj 1982】Moving Pebbles（博弈论）
zP1nG
12-08 258
传送门biu~ 可以发现，当n为偶数，且将石子数相同的堆两两配对可以配成n/2对 时先手必败，因为后手可以对另一个堆做先手同样的事情。 其它情况先手都可以一步把状态变为先手必败。 如果初始有奇数堆石子，那么先手可以将最小的堆和第二小的堆配对，第三小的堆和第四小的堆配对，…，然后用最大的堆填补差值，显然一定能填补上； 如果初始有偶数堆石子，那么先手可以将最大的堆和最小的堆配对，第二小的堆和第
很有意思的博弈论
peizhiinfo
07-27 660
一．巴什博奕（BashGame）： 首先我们来玩一个比较古老的报数游戏。A和B一起报数，每个人每次最少报一个,最多报4个。轮流报数,看谁先报到30. 如果不知道巴什博弈的可能会觉得这个是个有运气成分的问题，但是如果知道的人一定知道怎样一定可以赢。 比如A先报数的话,那么B一定可以赢(这里假定B知道怎么正确的报数) B可以这样报数,每次报5-k(A)个数,其中k(A)是A报数的个数这样的话没一次 两...
Bash博弈
碳碳双键的博客
01-16 261
例题：有一堆n个石子。AB两人轮流拿石子，且A先拿。如果某人没有石子可以拿则他输。每个人能拿的石子最少为1，最多为k。假设A和B都很聪明且不会有失误，请问谁能赢。 这是Bash博弈中的最基础的模型。 因为每次拿的石子数的取值区间都在 $ [1,n] $之间，所以我们可以考虑将每一轮取走的总石子数控制在（n+1）个，此时无论对面每次拿走多少我都可以把局势扳回到取走之前的样子。 然后事情就变得...
简单BashGame博弈 初尝试
Wasdns
05-03 412
今天接触了一种最基础的博弈论-BashGame。 假设一个石子堆有n个石子，每次最多只能取m个，zzx和whl两位大神准备进行竞赛，两位大神每一步走的都是最优的。zzx大神先开始，最后把石子取完的人获胜，作为旁观者的你能不能告诉我们，是zzx大神赢了，还是whl大神赢了？
巴什博弈python代码
最新发布
03-25
巴什博弈是一种经典的博弈论问题，它是一个二人游戏，由两个玩家轮流取走一定数量的物品，规定每次只能取走1到m个物品，最后取光物品的玩家获胜。下面是一个简单的巴什博弈的Python代码示例： ```python def bash_game(n, m): if n % (m+1) == 0: return "后手获胜" else: return "先手获胜" # 示例：先手玩家取走3个物品，每次最多取走4个物品 print(bash_game(10, 4)) ``` 在上面的代码中，`n`表示初始物品数量，`m`表示每次最多可以取走的物品数量。`bash_game`函数根据巴什博弈的规则判断最后哪个玩家获胜。如果初始物品数量 `n` 对 `(m+1)` 取余等于0，则表示后手玩家获胜；否则表示先手玩家获胜。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值