博弈（sg函数

已于 2022-02-19 14:28:05 修改
阅读量2.3k 收藏
点赞数
分类专栏： 博弈
于 2022-02-19 01:34:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cosx_/article/details/122994592
版权

繁繁的博弈博客
巨佬整理的sg函数题目

SG函数

S G SG SG 函数是对游戏图中每一个节点的评估函数。

若 S G ( x ) = 0 SG(x)=0 SG(x)=0 则为必败状态，若 S G ( x ) ≠ 0 S G ( x ) ≠ 0 SG(x)​=0，则为必胜状态

S G 定 理 ： SG定理： SG定理：所有一般胜利下的公平组合游戏都能转化成尼姆数表达的尼姆堆博弈，一个博弈的尼姆值 定义为这个博弈的等价尼姆数，即：对于当前游戏 X X X，它可以被拆分为多个子游戏 x 1 , x 2 , . . . x n x_1,x_2,...x_n x1​,x2​,...xn​，那么 S G ( X ) = S G ( x 1 ) ⨁ S G ( x 2 ) ⨁ S G ( x 3 ) . . . ⨁ S G ( x n ) SG(X)=SG(x_1)\bigoplus SG(x_2) \bigoplus SG(x_3)...\bigoplus SG(x_n) SG(X)=SG(x1​)⨁SG(x2​)⨁SG(x3​)...⨁SG(xn​)

对于由 n n n 个有向图游戏组成的组合游戏 设它们的起点分别为 s 1 , s 2 , s 3 , . . . s n s_1,s_2,s_3,...s_n s1​,s2​,s3​,...sn​，先手胜利时当且仅当 S G ( s 1 ) ⨁ S G ( s 2 ) ⨁ S G ( s 3 ) . . . ⨁ S G ( s n ) ≠ 0 SG(s_1) \bigoplus SG(s_2) \bigoplus SG(s_3)...\bigoplus SG(s_n) \neq 0 SG(s1​)⨁SG(s2​)⨁SG(s3​)...⨁SG(sn​)​=0

求 S G SG SG 函数
设 x x x 的后继状态 y 1 , y 2 , . . . y n y_1,y_2,...y_n y1​,y2​,...yn​
S G ( x ) = m e x ( S G ( y 1 ) , S G ( y 2 ) , . . . S G ( y n ) ) SG(x)=mex(SG(y_1),SG(y_2),...SG(y_n)) SG(x)=mex(SG(y1​),SG(y2​),...SG(yn​))
图片引用自繁繁博客

S-Nim
题意：
给定一个大小为 n n n 的集合 S S S， q q q 组查询，每次查询给定 m m m 堆石头，每堆石头的个数 x i x_i xi​，两人轮流从中取石头，每次取石头的个数来自集合 S S S，问先拿者是否有必胜策略
n < = 100 , S i < = 10000 , q < = 100 , m < = 100 , x i < = 10000 n<=100,S_i<=10000,q<=100,m<=100,x_i<=10000 n<=100,Si​<=10000,q<=100,m<=100,xi​<=10000
思路：
S G SG SG 函数，多个游戏
s g sg sg 函数经典例题
code：

#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<vector>

#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 1e4 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
int a[maxn], sg[maxn];
bool vis[maxn];

void work()
{
	mem(sg, 0);
	for(int i = 1; i <= n; ++i) cin >> a[i];
	for(int i = 1; i <= maxn - 9; ++i){// 预处理石子数为i的sg函数
		for(int j = 1; j <= n; ++j) if(i >= a[j]) vis[sg[i-a[j]]] = 1;// 标记后继状态sg函数值
		while(vis[sg[i]]) ++sg[i];// 求mex
		for(int j = 1; j <= n; ++j) if(i >= a[j]) vis[sg[i-a[j]]] = 0;// 消除标记
	}
	int q;cin >> q;
	while(q--){
		cin >> m;
		int ans = 0;
		for(int i = 1, x; i <= m; ++i){
			cin >> x;
			ans ^= sg[x];// 子游戏sg函数值异或一遍
		}
		cout << (ans ? "W" : "L");
	}
	cout << endl;
}

int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//	int TT;cin>>TT;while(TT--)
	while(cin >> n && n)
	work();
	return 0;
}

黑黑白白
思路:
S G SG SG 函数，单个游戏
设 s g [ x ] sg[x] sg[x] 表示先手轮到 x x x 点时的取胜情况， s g [ x ] = 1 sg[x]=1 sg[x]=1 表示必胜状态

  • 当子状态有必败状态时，该状态为必胜状态。
  • 当子状态全部为必胜状态，该状态为必败状态。

遍历这棵树，把所有孩子结点的答案向上合并
code:

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e6 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
vector <int> e[maxn];
int sg[maxn];
void dfs(int x, int fa){
	bool f = 1;//因为判断必胜状态的条件是存在某个子状态，根据定义的sg函数含义，初始设为1
	for(auto to : e[x]) if(to != fa)
	{
		dfs(to, x);
		f &= sg[to];// 企图&出来0
	}
	sg[x] = !f;
}
void work()
{
	cin >> n >> m;
	for(int i = 1; i <= n; ++i) e[i].clear(), sg[i] = 0;
	for(int i = 1; i < n; ++i){
		int x, y;cin >> x >> y;
		e[x].push_back(y);
		e[y].push_back(x);
	}
	dfs(m, m);
	cout << (sg[m] ? "Gen" : "Dui") << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

春联
思路:
S G SG SG 函数，单个游戏
题解
看了下题解，就是用最后一个字符往前推必胜和必败点
code:

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e6 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m, k;
int sg[maxn], mp[30], vis[30];
string s;
int ans = 0;
int get(){
	mem(vis, 0);
	for(int i = 1; i <= 26; ++i){
		if(mp[i] != n + 1) vis[sg[mp[i]]] = 1;
	}
	for(int i = 0; ; ++i) if(!vis[i]) return i;
}
void work()
{
	cin >> s;n = s.size();s = "@" + s;
	for(int i = 1; i <= 26; ++i) mp[i] = n + 1;	
	for(int i = n; i >= 1; --i){
		s[i] -= 'a' - 1;
		sg[i] = get();
		mp[s[i]] = i;
	}
	cout << (get() ? "kou" : "yukari");
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

寒冬信使2
思路:
S G SG SG 函数，单个游戏
把 w w w 看成 1 1 1, b b b 看成 0 0 0, 可以得到一个 01 01 01 串, 把状态压缩成 X = ∑ i = 0 n − 1 2 i ∗ ( s i = = ′ w ′ ) X=\sum_{i=0}^{n-1}2^i*(s_{i}=='w') X=∑i=0n−1​2i∗(si​==′w′)
可以发现操作只会让 X X X 的值减少或者不变，于是可以记录每个状态的 S G SG SG 函数， X X X 的 S G SG SG 函数为 0 0 0 输出 N o No No，否则输出 Y e s Yes Yes
code:

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e6 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
string s;
bitset <109> vis;
int sg[maxn];
void init(){
	for(int i = 1; i < 1 << 10; ++i)// 二进制枚举预处理所有01串状态
	{
		vis.reset();
		for(int j = 0; j < 10; ++j)
		{
			if(i & (1 << j))// 第j位为1 
			{
				if(j == 0) vis[sg[i ^ (1 << j)]] = 1;//操作二 
				else 
				{
					for(int k = 0; k < j; ++k) vis[sg[i ^ (1 << j) ^ (1 << k)]] = 1;// 操作一 
				}
			}
			while(vis[sg[i]]) ++sg[i];//状态i的sg函数 
		}
	}
} 
void work()
{
	cin >> n >> s;
	int st = 0;
	for(int i = 0; i < n; ++i) if(s[i] == 'w') st |= 1 << (i);
	cout << (sg[st] ? "Yes" : "No") << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	init();
	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

D 与 S
思路：
k k k 个关键点是必胜点，如果一个节点直接连着连着两个必胜点，那么这个点就会变成必胜点，把初始的 k k k 个点放入队列不断更新即可
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m, k;
vector <int> e[maxn];
int sg[maxn], deg[maxn];

void work()
{
	cin >> n >> m >> k;
	for(int i = 1; i <= n; ++i) e[i].clear(), sg[i] = deg[i] = 0;
	queue <int> q;
	for(int i = 1; i <= k; ++i){
		int x;cin >> x;
		sg[x] = 1;
		q.push(x);
	}
	for(int i = 1; i <= m; ++i){
		int x, y;cin >> x >> y;
		e[x].push_back(y);
		e[y].push_back(x);
	}
	while(!q.empty())
	{
		int x = q.front();q.pop();
		for(auto to : e[x]){
			if(sg[to]) continue;
			++deg[to];
			if(deg[to] >= 2){
				sg[to] = 1;
				q.push(to);
			}
		}
	}
	cout << (sg[1] ? "yes" : "no") << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

Anti-SG游戏

S J 定 理 : SJ定理: SJ定理: 对于任意一个 A n t i − S G Anti - SG Anti−SG 游戏，如果我们规定：当局面中所有的单一游戏的 S G SG SG 值为 0 0 0 时，游戏结束，则先手必胜当且仅当：

  • 游戏的 S G SG SG 函数值不为 0 0 0 且游戏中某个单一游戏的 S G SG SG 函数值大于 1 1 1。
  • 游戏的 S G SG SG 函数值为 0 0 0 且游戏中没有任意一个单一游戏的 S G SG SG 函数值大于 1 1 1 。

P4279 [SHOI2008]小约翰的游戏
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e6 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m, k;
int a[maxn];

void work()
{
	cin >> n;
	int sg = 0;bool f = 0;
	for(int i = 1; i <= n; ++i){
		cin >> a[i];
		sg ^= a[i];
		if(a[i] > 1) f = 1;
	}
	if(!f && !sg || f && sg) cout << "John\n";
	else cout << "Brother\n";
}

int main()
{
	ios::sync_with_stdio(0);
	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

Multi - SG游戏

条纹 黑暗爆炸 - 2940
题意：

思路：
具体递推公式好像需要打表找规律
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 1e3 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
int a, b, c;
bool vis[maxn];
int sg[maxn];
void work()
{
	cin	>> a >> b >> c;
	if(a > b) swap(a, b); if(b > c) swap(b, c); if(a > b) swap(a, b);
	for(int i = a; i <= maxn - 9; ++i)
	{
		for(int j = 0; j + a <= i; ++j) vis[sg[j]^sg[i-j-a]] = 1;
		for(int j = 0; j + b <= i; ++j) vis[sg[j]^sg[i-j-b]] = 1;
		for(int j = 0; j + c <= i; ++j) vis[sg[j]^sg[i-j-c]] = 1;
		while(vis[sg[i]]) ++sg[i];
		for(int j = 0; j + a <= i; ++j) vis[sg[j]^sg[i-j-a]] = 0;
		for(int j = 0; j + b <= i; ++j) vis[sg[j]^sg[i-j-b]] = 0;
		for(int j = 0; j + c <= i; ++j) vis[sg[j]^sg[i-j-c]] = 0;
	}
	cin >> m;
	while(m--){
		cin >> n;
		cout << (sg[n] ? 1 : 2) << endl;
	}
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}
__Rain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博弈-sg函数的原理和优化（hdu-1536）
shuimu12345678的专栏
06-19 2649
sg函数：sg函数是博弈中的确定一个position性质的一个函数，全称是sprague-grundy。 性质1：对于所有的p-position，都有sg = 0；对于所有的n-position都有sg ！= 0； 性质2：某点a的sg函数的值由它的后继的sg函数的值来决定，设后继为b, c, d, e……则sg(a) = mex(sg(a), sg(b), sg(c), sg(d), sg(
博弈论 SG函数
热门推荐
Strangedbly
04-12 4万+
别被文章长度吓到，学会博弈(SG)只用看前1/10。 鉴于讲明白博弈要写好多字，于是找了些论文拼凑，对疑难点加了注释并配上“美图”助解。 Nim游戏 重点结论：对于一个Nim游戏的局面(a1,a2,...,an)，它是P-position当且仅当a1^a2^...^an=0，其中^表示位异或(xor)运算。 Nim游戏是博弈论中最经典的模型（之一？），它又有着十分简单的规则和无比优美的结论
组合游戏 - SG函数和SG定理
Enstein_Jun
05-07 1万+
组合游戏的和通常是很复杂的，所以我们介绍一种新工具，可以使组合问题变得简单————SG函数和SG定理。 Sprague-Grundy定理（SG定理）：         游戏和的SG函数等于各个游戏SG函数的Nim和。这样就可以将每一个子游戏分而治之，从而简化了问题。而Bouton定理就是Sprague-Grundy定理在Nim游戏中的直接应用，因为单堆的Nim游戏 SG函数满足 SG(x) =
SG函数（博弈）
wwwlps的博客
07-30 263
https://www.cnblogs.com/ECJTUACM-873284962/p/6921829.html hdu 1848 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cmath&gt; #include &lt;cstring&gt; #include &lt;string&gt; #include...
博弈论之SG函数
magnte的博客
07-26 585
惯例先引入一些概念：（概念来自于网络） 有向图游戏： 给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。 任何一个公平组合游戏都可以转化为有向图游戏。具体方法是，把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。 Mex运算： 设S表示一个非负整数集合。定义mex(S)为求出不属于集合S的最小非负整数的运算，即： mex(S) = min{x}, x属
博弈论和SG函数_方泓杰.pdf
09-14
"博弈论和SG函数_方泓杰.pdf" 本资源主要讨论博弈论和SG函数的相关知识点，并提供了多个游戏示例来阐述必胜点和必败点的概念。 首先，博弈论是研究在策略竞争中作出决策的数学理论，它可以应用于许多领域，例如...
SG函数论文四篇合集
02-28
SG函数，全称为Sprague-Grundy函数，是组合游戏中的一种重要理论工具，特别是在解决不平等博弈问题中扮演着核心角色。这篇论文合集聚焦于SG函数及其在不同游戏场景中的应用，旨在深入探讨和理解这一理论。让我们逐一...
Nim和SG函数 博弈
08-06
比较全面系统的介绍了公平组合游戏，适合于参加acm竞赛的选手使用
SG函数[整理].pdf
10-20
SG函数是一种用于分析公平的两人博弈游戏的数学工具，它基于有向无环图（DAG）的概念。在这样的游戏中，双方玩家拥有完全的信息，并且游戏的结果不依赖于运气，而是取决于玩家的策略选择。最后一个能够合法行动的...
博弈论-SG函数和SG定理
YG爱木木
12-31 3352
1.SG函数和SG定理是一个十分神奇的东西，有了它，绝大部分的博弈都可以被统一到这个上面，都可以使用SG函数解决。是一种解决博弈问题的十分方便的手段。 2.首先给出一些基本的定义：mex运算，这个是作用在集合上的运算，具体的含义就是：找出不属于当前集合最小的非负整数，可能你有点晕，我们看几个例子。mex{1,2,3}=0;为什么？因为自然数从0开始，不属于这个集合最小的非负整数就是0了，再例如m...
博弈论与SG函数
No smile博客
09-03 732
基础博弈 BZOJ2463: [中山市选2009]谁能赢呢？ 环取点 POJ2484A Funny Game nim博弈——SG函数 BZOJ1299 POJ2975 有向图 POJ2425 SG函数典型应用 POJ2960 必胜状态向必败状态的转移,方法数，以及操作 BZOJ1874 阶梯博弈 BZOJ1115 POJ1704 HDU4315 Multi...
博弈（SG函数）
菜鸡的博客
08-15 506
解题模型： 1.把原游戏分解成多个独立的子游戏，则原游戏的SG函数值是它的所有子游戏的SG函数值的异或。 即sg(G)=sg(G1)^sg(G2)^...^sg(Gn)。 2.分别考虑没一个子游戏，计算其SG值。 SG值的计算方法：（重点） 1.可选步数为1~m的连续整数，直接取模即可，SG(x) = x % (m+1); 2.可选步数为任意步，SG...
博弈 SG函数
ACdream
08-10 1800
为什么要学习这个呢？因为每次看到题解的第一句话总是这种的： 水题，简单题，模板题，打表题 然后，第二句话，就是结论，比如sg【x】等于（然后一个分类），就得到了公式 最后就是把所有的亦或起来，就得到了答案了 首先呢，可以把这个题做一做，是一个很好的博弈题。题目链接：HDOJ5754 HDOJ5754题解 这个题，解释了博弈的很经典一个思路：找平衡 什么叫做平衡？就是当
博弈论知识点总结（巴什博奕 威佐夫博弈 尼姆博弈 SG()函数介绍）
SYITwin的博客
10-16 457
转载自：总结 真心感谢博主，终于知道为什么尼姆博弈用异或来解决。 SG函数模板： void init()//根据题目要求进行修改 { a[0]=1; for(int i=1;i&lt;=32;i++) a[i]=a[i-1]*2; } void SG() { for(int i=1;i&lt;=1000;i++) { memset(vis,0,sizeo...
三大博弈博弈+斐波那契博弈+sg函数
卖炫迈的小男孩的博客
04-30 377
博弈 （一）巴什博奕（Bash Game）：只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。最后取光者得胜。 –>要保持给对手留下（m+1）的倍数，就能最后获胜。 例题 HDU-4764-Stone 【巴什博弈】 http://acm.hdu.edu.cn/showproblem.php?pid=4764 （二）威佐夫博奕（Wythoff Game）：有两堆各若...
Nimm博弈sg函数mex函数
Nemaleswang的博客
03-14 1337
op是sg数组int mex(int x){ if(sg[x] != -1) return sg[x]; bool vis[1005]; for(int i = 0;i < 1005;i++) vis[i] = false; for(int i = 0;i < k;i++){ int temp = x-op[i]; i
博弈及SG函数的一点学习笔记
Michael_GLF的博客
02-23 202
一点前置补充 先定义几个概念： 1.一般博弈 emmm，一个人玩多没意思。。。多个人玩情况可能太复杂，所以一般博弈讨论的就是双人间博弈，并且双人进行公平游戏，即规则相同且信息对等，两人轮流操作（即非随机选择），无法操作者判负。 2.状态 类似于DP中的状态，即当前的游戏局面。 3.必胜（败）局面 如果存在一种一定获胜的方法，那么当前局面就是必胜局面。 反之，如果不能存在一种一定获胜...
2.18博弈论SG函数
最新发布
m0_73553411的博客
03-11 2121
总结来说，SG为0表示当前局面是一个必败态，而非0的SG值表示当前局面是一个必胜态。这是根据博弈论中SG函数的定义和理论推导得出的。自己走的是SG不为0的点，那么对手就必须从这个点开始往下继续走了，而不能重复了必败态的后继状态要么没有，即最底层，要么就是必胜态，因为不能连续走两步，必胜的后面必然是必败；同理，必胜的后面至少得有一个必败态，如果后面都是必胜态的话，那么此时为必败态就是底层叶子结点表示结尾，一定是必败态，往上紧邻的一定是必胜态。
五子棋博弈算法 评价函数
12-08
五子棋博弈算法的评价函数是指对当前棋盘局面进行评估的函数，用于指导计算机下一步棋的位置。评价函数的好坏直接影响到计算机下棋的水平。常见的五子棋博弈算法评价函数有以下几种： 1. 简单计分法：根据当前棋盘上黑子和白子的分布情况，对每个位置进行打分，分数越高表示该位置越有利。例如，对于一个空位，如果它周围有黑子，则给它一个正分数，如果周围有白子，则给它一个负分数，否则给它一个较小的分数。 2. 连子计数法：根据当前棋盘上黑子和白子的连子数，对每个位置进行打分，连子数越多表示该位置越有利。例如，对于一个空位，如果它周围有黑子连成了三子，则给它一个正分数，如果周围有白子连成了三子，则给它一个负分数，否则给它一个较小的分数。 3. 棋型分析法：根据当前棋盘上黑子和白子的棋型，对每个位置进行打分，棋型越好表示该位置越有利。例如，对于一个空位，如果它周围有黑子形成了活三，则给它一个正分数，如果周围有白子形成了活三，则给它一个负分数，否则给它一个较小的分数。 4. Alpha-Beta剪枝算法：Alpha-Beta剪枝算法是一种搜索算法，用于在搜索树中剪去不必要的分支，从而提高搜索效率。在五子棋博弈中，可以使用Alpha-Beta剪枝算法搜索下一步最优解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值