博弈论之SG函数

已于 2022-08-16 19:57:25 修改
阅读量820 收藏 4
点赞数 1
分类专栏： 博弈论 文章标签： c++ 算法
于 2022-08-16 19:56:09 首次发布
;
本文链接：https://blog.csdn.net/m0_60630928/article/details/126372356
版权

Nim游戏基本定理： Nim博弈先手必胜，当且仅当 A 1 x o r A 2 x o r A 3 . . . x o r A n ≠ 0 A_1 xor A_2xor A_3...xor A_n\ne0 A1​xorA2​xorA3​...xorAn​=0

公平组合游戏ICG

  1. 两名玩家交替行动；
  2. 在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关；
  3. 不能行动的玩家判负。

有向图游戏 给定一个有向无环图，图中有一个唯一的起点，在起点上放一枚棋子，两名玩家交替的把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏，任何一个公平组合游戏都可以转化为有向图游戏。 有向图游戏的某个局面必胜，当且仅当该局面对应节点的SG函数值大于0； 有向图游戏的某个局面必败，当且仅当该局面对应节点的SG函数值等于0。

mex运算 设S表示一个非负整数集合。定义 m e x ( S ) mex(S) mex(S)为求出不属于集合S的最小非负整数的运算： m e x ( S ) = m i n mex(S)=min mex(S)=min ( x ) ( x (x)(x (x)(x ∈ \in ∈ N , x ,x ,x ∉ \notin ∈/ S)

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

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

891. Nim游戏

#include<bits/stdc++.h>
using namespace std;
int n,x,ans;

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>x;
		ans^=x;
	}
	if(ans) cout<<"Yes";
	else cout<<"No";
}

892. 台阶-Nim游戏

因为第一阶拿到地面要拿一次，第二阶拿两次，第三阶拿三次…所以可以看成第二阶有两堆石子，第三阶有三堆…偶数阶石子为偶数堆，异或为0；奇数阶异或后就是原本石子数目，所以可以把原本所有奇数阶的石子进行异或，得到的就是答案。

#include<bits/stdc++.h>
using namespace std;
int n,x,ans;

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>x;
		if(i%2) ans^=x;
	}
	if(ans) cout<<"Yes";
	else cout<<"No";
}

893. 集合-Nim游戏

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

int mem[10010],n,k,a[110],ans,box[10010][110];

int sg(int x)
{
    if(mem[x]!=-1) return mem[x];
    for(int i=1;i<=k;i++)
        if(a[i]<=x)  box[x][sg(x-a[i])]=1;//枚举集合内的数
    for(int i=0;;i++)
        if(!box[x][i]) return mem[x]=i;
}

int main()
{
    cin>>k;
    memset(mem,-1,sizeof mem);
    for(int i=1;i<=k;i++)
        cin>>a[i];
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        ans^=sg(x);
    }
    if(ans) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
    return 0;
}

894. 拆分-Nim游戏

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

int n,k,a[110],ans,maxn,mem[110],box[110][200];

int sg(int x)
{
    if(mem[x]!=-1) return mem[x];
    for(int i=0;i<x;i++)
        for(int j=0;j<=i;j++)//枚举更小的两个堆
            box[x][sg(i)^sg(j)]=1;
    for(int i=0;;i++)
        if(!box[x][i]) return mem[x]=i;
}

int main()
{
    cin>>n;
    memset(mem,-1,sizeof mem);
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        ans^=sg(a[i]);
    }
    if(ans) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
    return 0;
}

1319. 移棋子游戏

就是建有向图了。

#include<bits/stdc++.h>
using namespace std;
const int M=6010,N=2010;
int n,m,k,tot,ans,mem[N],box[N][2*N];
int head[N],ver[M],nex[M];

void add(int x,int y)
{
    ver[++tot]=y,nex[tot]=head[x],head[x]=tot;
}


int SG(int u)
{
    if (mem[u]!=-1) return mem[u];值已经被计算过了，直接返回
    set<int> S;     
    for (int i=head[u];i;i=nex[i])
        S.insert(SG(ver[i]));  
    for (int i=0;;i++)    
        if (!S.count(i)) 
            return mem[u]=i;
}


int main()
{
    cin>>n>>m>>k;
    memset(mem,-1,sizeof mem);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    for(int i=1;i<=k;i++)
    {
        int x;
        scanf("%d",&x);
        /*for(int j=head[i];j;j=nex[j])
            cout<<ver[j]<<' ';
        cout<<endl;*/
        ans^=SG(x);
        //cout<<"x:"<<x<<" sg(x):"<<sg(x)<<endl;
    }
    if(ans) cout<<"win";
    else cout<<"lose";
    return 0;
}

P2575 高手过招

状态压缩，在SG内转移状态

#include<bits/stdc++.h>
using namespace std;
int T,n,m,x;
int mem[1<<20];

int SG(int state)
{
	if(mem[state]!=-1) return mem[state];
	set<int>S;
	for(int i=0;i<20;i++) 
	{
		if((state>>i)&1)
		{
			for(int j=i-1;j>=0;j--)
			{
				if(!((state>>j)&1))
				{
					S.insert(SG(state^(1<<i)^(1<<j)));
					break;
				}
			}
		}
	}
	for(int i=0;;i++)
		if(S.count(i)==0)
		{
			//printf("SG(%d):%d\n",state,i);
			return mem[state]=i;
		}
}

int main()
{
	memset(mem,-1,sizeof mem);
	for(int i=1;i<=20;i++)
		mem[(1<<i)-1]=0;
	cin>>T;
	while(T--)
	{
		cin>>n;
		int ans=0;
		while(n--)
		{
			cin>>m;
			int state=0;
			for(int i=0;i<m;i++)
			{
				scanf("%d",&x);
				state|=(1<<(20-x));
			}
			ans^=SG(state);
		}
		if(ans) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

上面的有点慢，开氧气能卡过。试图预处理一下，结果MLE了。。。

#include<bits/stdc++.h>
#define lowbit(x) x&(-x)
using namespace std;
int T,n,m,x;
int mem[1<<20],nex[21],a[21],num[1<<20];

int SG(int state)
{
	if(mem[state]!=-1) return mem[state];
	set<int>S;
	int now=state,last=0;
	while(now)
	{
		int t=lowbit(now);
		if(nex[num[t]]!=-1)
			S.insert(SG(state^t^(1<<nex[num[t]])));
		now-=t;
	}
	/*for(int i=0;i<20;i++) 
	{
		if((state>>i)&1)
		{
			for(int j=i-1;j>=0;j--)
			{
				if(!((state>>j)&1))
				{
					S.insert(SG(state^(1<<i)^(1<<j)));
					break;
				}
			}
		}
	}*/
	for(int i=0;;i++)
		if(S.count(i)==0)
		{
			//printf("SG(%d):%d\n",state,i);
			return mem[state]=i;
		}
}

int main()
{
	memset(mem,-1,sizeof mem);
	for(int i=1;i<=20;i++)
		mem[(1<<i)-1]=0,num[1<<(i-1)]=(i-1);
	cin>>T;
	while(T--)
	{
		cin>>n;
		int ans=0;
		while(n--)
		{
			cin>>m;
			int state=0;
			for(int i=0;i<m;i++)
			{
				scanf("%d",&a[i]);
				a[i]=20-a[i];
				state|=(1<<(a[i]));
			}
			nex[m-1]=a[m-1]-1;
			for(int i=m-2;i>=0;i--)
			{
				if(a[i]==a[i+1]+1) nex[i]=nex[i+1];
				else nex[i]=a[i]-1;
			}//预处理出下一个位置
			ans^=SG(state);
		}
		if(ans) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

不好想的是当作台阶Nim处理QAQ：

图源
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
int T,n;
int vis[25];

int main()
{
	scanf("%d",&T);
	while(T--)
	{
		int ans=0;
		scanf("%d",&n);
		for(int i=1;i<=n;++i)
		{
			int now=0,num;
			memset(vis,0,sizeof(vis));
			scanf("%d",&num);
			for(int j=1;j<=num;++j)
			{
				int x;
				scanf("%d",&x);
				vis[x]=1;
			}
			int cnt=0,tot=0;
			for(int j=20;j>=0;j--)
			{
				if(!vis[j])
				{
					if(tot)
					{
						ans^=tot;
						tot=0;
					}
					cnt^=1;
				}
				else if(cnt) ++tot;
			}
			if(tot) ans^=tot;
		}
		printf("%s\n",ans?"YES":"NO");
	}
	return 0;
}

另外扔一些最近写的博弈

P4643 [国家集训队]阿狸和桃子的游戏

#include<iostream>
#include<algorithm>
using namespace std;

int n,m,ans,a[10001];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
    {
		cin>>a[i];
		a[i]*=2;
	}
	for(int i=1;i<=m;i++)
    {
		int x,y,z;
		cin>>x>>y>>z;
		a[x]+=z,a[y]+=z;
	}
	sort(a+1,a+1+n);
	for(int i=n;i>=1;i-=2)
		ans+=a[i]-a[i-1];
	cout<<ans/2;
	return 0;
}

Take Apples

首先，“一眼能看出”

if(m<=n) cout<<"Alice"<<endl;
if(m>n&&(m-n)%(s+1)==0) cout<<"Alice"<<endl;

考虑当m>n&&(m-n)%(s+1)!=0时，Alice是否有办法用一步变成后手必胜局面。可以斩三堆使得n<s，这样只用考虑m堆的情况（因为从n取不会改变最终到m堆的先后手情况，如果Bob进一步斩三堆也是稳输），假设只剩下m堆了，Alice后手，这在m%(s+1)==0的情况下Alice稳赢。所以Alice可以在第一步的时候就通过调整，使得调整后呈现后手必胜局面。

Bob必胜态大小为 n n n的堆Alice取一个Bob取另一个，大小为 m m m的堆Bob取 s + 1 − s+1- s+1−Alice取的数量。
否则Alice能一步变成后手必胜态（ n > s n>s n>s时同时取3个堆，否则取 m m m堆）。

然后这个题目有点坑，输入顺序应该是m,n,s…

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

int main()
{
    int s,m,n;
    while(~scanf("%d%d%d",&m,&n,&s))
    {
        if(n<=s&&m%(s+1)==0) cout<<"Bob"<<endl;
        else cout<<"Alice"<<endl;
    }
}
春弦_
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
14.1.5 蓝桥杯博弈论之SG函数
tang7mj的博客
02-14 442
SG函数是一种用于非合作博弈中，判断游戏状态是否为必胜状态的函数。对于游戏中的每一个状态，SG函数都会赋予一个非负整数值。这个值反映了该状态的必胜程度：如果一个状态的SG函数值为0，表示这是一个必败状态；否则，是一个必胜状态。SG函数是理解和解决博弈论问题的有力工具，尤其在处理复杂或组合游戏时显示出其独特优势。通过熟悉SG函数的原理和计算方法，参赛者可以在蓝桥杯等算法竞赛中更加灵活地分析和解决博弈题目。
博弈论SG函数
Link_Ray的博客
05-15 435
参考: http://www.cnblogs.com/ECJTUACM-873284962/p/6398385.html http://www.cnblogs.com/ECJTUACM-873284962/p/6921829.html 巴什博奕 只有一堆石子，每个人可以从里面取1~m个石子，先取光者胜。 当 n=m+1n = m+1n=m+1先手必败，因为先手无论选什么，都会使其个数小于m。 因...
博弈论之sg函数
huantwofat
04-28 639
#include #include #define N 10000 int grun[N],b[N]; bool ha[N]; void grundy(int n) { int i,j; memset(grun,0,sizeof(grun)); for(i=1;i<=N;i++) { memset(ha,0,sizeof(ha));
博弈论之SG函数(NIM博弈、反NIM博弈证明+例题)--POJ2311
m0_50623076的博客
02-22 760
目录 NIM博弈： 题目： 代码： 反NIM博弈： 题目： 代码: 公平组合游戏ICG： 有向图游戏： Mex运算： SG函数： 有向图游戏的和： 定理： 题目： 代码: 参考材料： NIM博弈： 内容：给定N堆物品，第i堆物品有Ai个。两名玩家轮流行动，每次可以任选一堆，取走任意多个物品，可把一堆取光，但不能不取。取走最后一件物品者获胜。两人都采取最优策略，问先手是否必胜。 定理：NIM博弈先手必胜，当且仅当 A1 ^ A2 ...
2.18博弈论SG函数
m0_73553411的博客
03-11 2140
总结来说，SG为0表示当前局面是一个必败态，而非0的SG值表示当前局面是一个必胜态。这是根据博弈论中SG函数的定义和理论推导得出的。自己走的是SG不为0的点，那么对手就必须从这个点开始往下继续走了，而不能重复了必败态的后继状态要么没有，即最底层，要么就是必胜态，因为不能连续走两步，必胜的后面必然是必败；同理，必胜的后面至少得有一个必败态，如果后面都是必胜态的话，那么此时为必败态就是底层叶子结点表示结尾，一定是必败态，往上紧邻的一定是必胜态。
【博弈论】SG函数/SG定理（组合游戏）
Qiuker_jl的博客
12-17 718
文章目录一.前置知识1.异或（xor）2.必胜态/必败态二.Nim游戏1.游戏内容2.结论（Bouton定理）3.证明三.SG函数1.作用2.mex运算3.SG函数计算4.实例（取石子游戏）5.Sprague-Grundy定理 一.前置知识 1.异或（xor） 定义： 用符号⊕表示异或运算 两个一位二进制数运算时： a⊕b=(¬a∧b)∨(a∧¬b)a⊕b= (¬a ∧ b) ∨ (a ∧¬b)a⊕b=(¬a∧b)∨(a∧¬b) 1⊕0=11⊕0=11⊕0=1 ； 0⊕1=10⊕1=10⊕1=1； 1⊕
博弈论基础知识与SG函数
Lunar Arc的博客
02-24 2081
博弈论入门简介要素博弈的类型1.合作博弈 和 非合作博弈2.静态博弈 和 动态博弈3.完全信息博弈 和 不完全信息博弈纳什均衡经典案例一经典案例二四大博弈模型一、巴什博弈二、尼姆博弈 ※SG函数三、斐波那契博弈四，威佐夫博弈SG函数 简介 博弈论，又称为对策论（Game Theory）、赛局理论等。博弈论主要研究公式化的激励结构间的相互作用，是研究具有斗争或竞争性质现象的数学理论和方法。 博弈论考虑游戏中的个体的预测行为和实际行为，并研究它们的优化策略。 要素 1.局中人：在一场竞赛或博弈中，每一个有决策权
博弈论与SG函数
weixin_61819021的博客
05-17 509
公平组合游戏 公平组合游戏（Impartial Game）的定义如下： 游戏有两个人参与，二者轮流做出决策，双方均知道游戏的完整信息； 任意一个游戏者在某一确定状态可以作出的决策集合只与当前的状态有关，而与游戏者无关； 游戏中的同一个状态不可能多次抵达，游戏以玩家无法行动为结束，且游戏一定会在有限步后以非平局结束。 非公平组合游戏 非公平组合游戏（Partizan Game）与公平组合游戏的区别在于在非公平组合游戏中，游戏者在某一确定状态可以做出的决策集合与游戏者有...
博弈论和SG函数_方泓杰.pdf
09-14
"博弈论和SG函数_方泓杰.pdf" 本资源主要讨论博弈论和SG函数的相关知识点，并提供了多个游戏示例来阐述必胜点和必败点的概念。 首先，博弈论是研究在策略竞争中作出决策的数学理论，它可以应用于许多领域，例如...
SG函数论文四篇合集
02-28
总的来说，这个论文合集对于深入理解SG函数及其在博弈论中的应用提供了丰富的资料。无论是对Nim游戏的深入研究，还是对不平等博弈的策略分析，或者是对SG函数在各种组合游戏中的扩展应用，都为我们提供了一个系统而...
Nim和SG函数 博弈
08-06
Nim游戏是一种非常经典的博弈论模型，尤其适用于理解组合游戏理论中的基本概念。它不仅规则简单，而且背后的数学原理异常优雅，非常适合ACM竞赛选手学习。 #### 二、Nim游戏的基本规则 Nim游戏属于一类特殊的组合...
博弈论小结by xaphoenix
04-25
SG函数是解决某些博弈的关键工具，它定义了一个游戏的胜负状态，并且可以用来计算游戏的值。特殊的SG游戏，如Anti-SG、Every-SG、Multi-SG，提供了更复杂的分析视角。例如，Anti-SG是SG游戏的反面，其胜利状态与SG...
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 393
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 170
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 179
DFS
c++——map、set底层之AVL树（动图演示旋转）
2301_80687320的博客
08-05 753
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
嵌入式初学-C语言-十五
最新发布
MaBaB的博客
08-05 504
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
博弈论学习资源与SG函数模板解析
提供的链接包括博弈论的SG函数详解、题型总结以及石子类问题的解析。代码段展示了如何初始化并计算SG函数，其中包含了几个常见的编程错误示例。 博弈论是一种应用于决策科学的数学理论，它研究在零和游戏中（即一方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春弦_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值