SG 函数

Sprague–Grundy 函数完全解析

本文系统深入地探讨 Sprague–Grundy 函数（SG 函数）的理论基础、计算方法、变形应用以及在算法竞赛中的实战技巧。从基本定义出发，逐步过渡到复杂博弈的 SG 分析，并涵盖多种经典变体与高级话题。所有代码均符合竞赛规范，运算符左右不留空格，禁止动态指针与链式前向星。

第一章引言：从 Nim 到 SG 函数

1.1 组合博弈的抽象模型

组合博弈（Impartial Combinatorial Game, ICG）满足以下公理：

双方：恰好两名玩家，轮流行动。
完全信息：所有玩家知道当前局面的全部信息。
无随机性：每个局面的合法行动集合是确定的。
公平性：合法行动集合仅取决于局面，与玩家身份无关（即双方可行动作相同）。
有限性：任何游戏序列必须在有限步内结束。
正常规则：无法行动者判负（也有变体采用反常规则，即无法行动者获胜，但通常单独讨论）。

Nim 博弈是最经典的 ICG：有 \(n\) 堆石子，每堆数量 \(a_i\)，每次选择一堆并取走任意正整数个，取走最后一个石子者胜。Bouton 在 1901 年给出了简洁的判定：先手必胜当且仅当 \(\oplus_{i=1}^n a_i \ne 0\)，其中 \(\oplus\) 表示按位异或。

但 Nim 只是冰山一角。对于形形色色的 ICG，是否存在统一的理论工具？这就是 Sprague–Grundy 定理 的核心贡献：每个 ICG 局面都可以映射为一个非负整数（SG 值），组合多个独立游戏时，其 SG 值为各子游戏 SG 值的异或。这一定理将任意 ICG 转化为 Nim 堆的等价形式，因此得名 “Nim 数”。

1.2 SG 函数的直观意义

SG 值本质上衡量了一个局面在“可控性”上的距离。值为 0 的局面是必败态（P-position），非 0 则是必胜态（N-position）。更重要的是，SG 值指明了在该局面下，先手可以将游戏引导到任何 SG 值小于当前值的状态，类似于 Nim 堆中取走石子后堆大小可以变成任意更小的数。

第二章 SG 函数形式化定义

2.1 基本定义

设 \(G\) 为一个 ICG，其局面集合为 \(S\)，转移关系为 \(x \to y\)（表示从局面 \(x\) 可以一步到达 \(y\)）。定义函数 \(g: S \to \mathbb{N}_0\)（非负整数）如下：

\[g(x) = \operatorname{mex}\bigl(\{ g(y) \mid x \to y \}\bigr) \]

其中 \(\operatorname{mex}(A)\)（minimum excludant）表示集合 \(A\) 中未出现的最小非负整数。例如：

\(\operatorname{mex}(\varnothing) = 0\)
\(\operatorname{mex}(\{0,1,3\}) = 2\)
\(\operatorname{mex}(\{0,1,2,3\}) = 4\)

这个递归定义是良基的，因为博弈是有限的（游戏树无环），可以通过逆拓扑序计算。

2.2 SG 函数的基本性质

性质 1：\(g(x) = 0\) 当且仅当 \(x\) 是 P-position（必败态）。

证明：若 \(g(x)=0\)，则不存在后继 \(y\) 使得 \(g(y)=0\)（否则 mex 会包含 0），即所有后继均为 N 态，所以当前为 P。反之，若 \(g(x) \ne 0\)，则存在后继 \(y\) 满足 \(g(y)=0\)（因为 mex 跳过的最小值意味着所有小于 \(g(x)\) 的值均出现在后继中，特别地 0 出现），即可以走到 P 态，所以当前为 N。

性质 2：从局面 \(x\)，若 \(g(x)=k>0\)，则对于任意 \(0 \le t < k\)，都存在某个后继 \(y\) 使得 \(g(y)=t\)。这是 mex 定义的直接推论。

性质 3：不存在后继使得 \(g(y)=g(x)\)，因为 mex 排除了当前值。

这些性质是推导 SG 组合定理的基础。

2.3 SG 定理（Sprague–Grundy 定理）

对于多个独立子游戏的和游戏 \(G = G_1 + G_2 + \cdots + G_n\)，其局面由各子游戏局面组成（记为 \((x_1,\dots,x_n)\)），合法行动是选择其中一个子游戏并执行一步。则

\[g(x_1,\dots,x_n) = g_1(x_1) \oplus g_2(x_2) \oplus \cdots \oplus g_n(x_n) \]

其中 \(\oplus\) 是按位异或（XOR）。

证明概要：
令 \(h = g_1(x_1) \oplus \cdots \oplus g_n(x_n)\)。

首先证明对于任意后继局面（将某个 \(x_i\) 变为 \(y_i\)），其新 SG 值 \(h'\) 不等于 \(h\)。设 \(k = g_i(x_i)\)，\(k' = g_i(y_i)\)，由于 \(k' \ne k\)（性质 3），则异或后 \(h' = h \oplus k \oplus k'\)，因为 \(k \oplus k' \ne 0\)，所以 \(h' \ne h\)。
其次证明对于任意 \(0 \le t < h\)，都存在一个后继使新 SG 值为 \(t\)。设 \(d = h \oplus t\)，取 \(d\) 的最高二进制位 \(b\)，那么存在某个 \(i\) 使得 \(g_i(x_i)\) 的第 \(b\) 位为 1（因为 \(h\) 在该位为 1）。令 \(k = g_i(x_i)\)，则 \(k \oplus d < k\)（因为最高位从 1 变 0）。根据性质 2，存在 \(y_i\) 使得 \(g_i(y_i) = k \oplus d\)，于是新异或为 \(h \oplus k \oplus (k \oplus d) = h \oplus d = t\)。

综上，新局面的 SG 值集合包含了所有小于 \(h\) 的非负整数，且不包含 \(h\)，故其 mex 恰好为 \(h\)。定理得证。

第三章 SG 函数的计算方法

3.1 基础实现：记忆化搜索

对于状态空间可枚举的游戏，最直接的方式是递归计算。由于游戏图通常为 DAG（无环），可以使用记忆化。

模板代码（通用）：

const int MAXS = 100005;
int sg[MAXS];
bool vis[MAXS];

int getSG(int state, vector<int>& moves) {
    if (sg[state] != -1) return sg[state];
    bool used[MAXS] = {0}; // 注意这里 MAXS 要足够大
    for (int m : moves) {
        if (state >= m) {
            used[getSG(state - m, moves)] = true;
        }
    }
    for (int i = 0; ; i++) {
        if (!used[i]) return sg[state] = i;
    }
}

优化：若 moves 集合固定，可预处理所有状态的 SG。

3.2 递推法

若局面具有明确的数值递增顺序（如石子数量），可直接从 0 开始递推。

void calcSG(int n, vector<int>& moves) {
    sg[0] = 0;
    for (int i = 1; i <= n; i++) {
        bool used[MAXS] = {0};
        for (int m : moves) {
            if (i >= m) used[sg[i - m]] = true;
        }
        for (int j = 0; ; j++) {
            if (!used[j]) { sg[i] = j; break; }
        }
    }
}

3.3 周期性规律

许多游戏的 SG 值呈现周期性。找出周期可大幅加速计算，例如：

取石子可取 \(1,2,\dots,m\)：\(SG(n) = n \bmod (m+1)\)。
取法为 Fibonacci 数列：SG 值有周期性（需打表观察）。

3.4 位运算加速

有时需要快速计算多个独立子游戏的组合 SG，若子游戏数量巨大，可使用线性基或分组技巧。

第四章经典游戏的 SG 分析

4.1 Bash 博弈

规则：一堆 \(n\) 个，每次取 \(1\) 到 \(m\) 个。
转移：\(i \to i - t\)，\(1 \le t \le m\)。
SG 计算：\(SG(0)=0\)，\(SG(i) = \operatorname{mex}\{ SG(i-t) \mid 1 \le t \le m \}\)。归纳得 \(SG(i) = i \bmod (m+1)\)。

4.2 Nim 博弈（单堆即为取任意正数）

单堆 \(n\)：可转移到 \(0\) 到 \(n-1\)，所以 \(SG(n) = n\)。
多堆组合：总 SG 为各堆 SG 异或，即 \(\oplus a_i\)。

4.3 取石子游戏（多种固定取法）

例如可取 \(\{1,3,4\}\)。计算 SG 值：

\(SG(0)=0\)
\(SG(1)=\operatorname{mex}\{SG(0)\}=1\)
\(SG(2)=\operatorname{mex}\{SG(1)\}=0\)
\(SG(3)=\operatorname{mex}\{SG(2),SG(0)\}=\operatorname{mex}\{0,0\}=1\)（去重后集合为 \(\{0\}\)，故 mex=1）
\(SG(4)=\operatorname{mex}\{SG(3),SG(1),SG(0)\}=\operatorname{mex}\{1,1,0\}=2\)
等等。

这类问题常通过 DP 或找循环节解决。

4.4 减法游戏（Subtraction Game）

一般形式：给定集合 \(S\)，每次可减去 \(S\) 中某个数。SG 值可通过上述递推得到。当 \(S\) 有限时，SG 序列最终是周期性的（因为状态有限且转移固定）。

4.5 威佐夫博弈（Wythoff's Game）

两堆石子 \((a,b)\)，每次可从一堆取任意正数，或两堆同时取相同正数。
必败态（P-position）为 \(( \lfloor k\phi \rfloor, \lfloor k\phi^2 \rfloor )\)，\(\phi = \frac{1+\sqrt5}{2}\)。
SG 值没有简单的闭式，但可以通过递推计算。不过通常直接判 P/N 即可。

4.6 格林哈肯博（Green Hackenbush）

游戏在图上进行，每次可删除一条边，同时移除与该边不连通的部分（通常有一个“地面”根）。公平版中每条边都是绿色。
对于树，SG 值可通过子树递归计算：\(SG(u) = \bigoplus_{v \in children(u)} (SG(v) + 1)\)，因为每条边相当于一个 Nim 堆大小为其子树高度。

第五章 SG 函数与动态规划（博弈 DP）

5.1 状态空间为 DAG 的博弈 DP

当游戏状态构成有向无环图时，可用 DP 计算 SG。典型例子是“有向图博弈”：每个节点代表状态，出边为行动。若有环，则需用其他方法（如求强连通分量归约，或使用一般性博弈求解算法）。

例题：给定 DAG，每个节点有一个数字，玩家从起点出发，沿有向边移动，移动到终点时游戏结束，最后移动者胜（即无法移动者输）。求起点的 SG。

解法：从出度为 0 的节点（终态）开始，反向拓扑计算 SG。

代码（拓扑排序）：

vector<int> g[N];
int sg[N], indeg[N], outdeg[N];
queue<int> q;
// 先统计出度，将出度为0的入队并设sg=0
while (!q.empty()) {
    int u = q.front(); q.pop();
    // 计算sg[u]需要知道所有后继的sg，但由于拓扑序，后继的sg已算好
    bool used[1000] = {0};
    for (int v : g[u]) used[sg[v]] = true;
    for (int i = 0; ; i++) if (!used[i]) { sg[u] = i; break; }
    // 对于每个前驱，当所有后继都已处理时，将其入队
    // 略去具体入队逻辑，需维护剩余后继计数
}

5.2 区间博弈 DP 与 SG

对于区间取数问题，我们通常不直接计算 SG，而是计算最大收益差。但有时也可定义 SG，例如“从两端取石子，每次可取任意数量”之类的游戏。

5.3 树形博弈 DP

树形结构天然适合递归。常见模型：

树上删边（如上所述）。
树上移动棋子：在树上放置棋子，每次移动到相邻未访问节点，不能移动者输。这等价于树上的“无向图博弈”，其 SG 可通过树形 DP 计算（每个子树视为一个 Nim 堆，堆大小为子树中最长路径长度等）。实际上，对于树上的“点删除”游戏，SG 通常为子树 SG 异或。

模板（计算树的 Green Hackenbush SG）：

vector<int> tree[N];
int dfsSG(int u, int fa) {
    int res = 0;
    for (int v : tree[u]) {
        if (v == fa) continue;
        res ^= (dfsSG(v, u) + 1);
    }
    return res;
}

5.4 复杂状态压缩博弈 DP

当局面维度较高但状态数有限时，可用状态压缩 DP 结合 SG。例如棋盘上的硬币游戏，用位掩码表示局面，然后记忆化搜索。

注意：由于状态数可能巨大，需要剪枝或利用对称性。

第六章 SG 函数的变形与推广

6.1 Anti-SG（反常规则）

规则：无法行动者获胜（即取最后一个石子者输）。这种情况不能直接用普通 SG 判定，需要修改判定条件。对于 Anti-Nim（多堆 Nim 的反常版），结论已在前面给出。对于一般游戏，可以定义“反 SG 值”，但更常见的是直接通过胜负态递推。

通用解法：设 \(win(x)\) 表示当前局面是否为必胜态（反规则下），则：

终止态（无行动）：\(win = true\)（因为无法行动者胜）。
若存在后继为 \(win=false\)，则当前 \(win=true\)；否则 \(win=false\)。
这与正常规则恰好相反。

6.2 双人零和博弈的最优策略与 SG

在非公平博弈（Partizan）中，SG 不适用。但在某些不对称游戏中，可以分别计算左右玩家的 SG 值（如“绿树”与“蓝树”），这就进入了 Conway 博弈论领域。

6.3 SG 与 Nim 堆的等价性

SG 值可以理解为该局面等价于一个大小为 \(g(x)\) 的 Nim 堆。组合多个游戏时，异或运算恰好对应 Nim 堆的合并。这一定义为“游戏等价类”提供了数学基础。

6.4 SG 的区间合并（线段树优化）

当有大量子游戏且每个子游戏的 SG 值需要动态修改时，可以用线段树维护异或和。这在动态博弈问题中偶有出现。

6.5 SG 与矩阵快速幂

某些 SG 序列具有线性递推关系（如减法游戏的周期），可以用矩阵快速幂求第 \(n\) 项。

第七章典型例题精讲

7.1 例题1：HDU 1847 “Good Luck in CET-4 Everybody!”

题意：一堆石子，数量 \(n\)，每次只能取 \(2^k\) 个（\(k\ge 0\)），即 \(1,2,4,8,\dots\)。取最后一个胜。

解法：计算 SG 值，找规律。打表可得 SG 值以 3 为周期：0,1,2,0,1,2,... 实际上 \(SG(n) = n \bmod 3\)。因为可取集合为 \(\{1,2,4,8,\dots\}\)，但观察到 4 和 8 对取模 3 的影响等价于 1 和 2，所以周期性成立。

代码：

#include <bits/stdc++.h>
#define int long long
#define COUT cout<<"\n------------------------------------------------------------------------------------------\n";
#define fi first
#define se second
#define be begin()
#define en end()
using namespace std;
const int N=2e5+5;
const int mod=998244353;
const int inf=1e18;
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    while (cin >> n) {
        if (n % 3 == 0) cout << "Cici\n";
        else cout << "Kiki\n";
    }
    return 0;
}

7.2 例题2：POJ 2311 “Cutting Game”

题意：一张 \(w \times h\) 的矩形纸，每次可以选择一个矩形，沿水平或垂直方向剪成两个矩形，谁剪出 \(1 \times 1\) 的小块谁获胜（注意：正常规则，即剪出 \(1\times1\) 的玩家获胜，但按照常规理解，剪出 \(1\times1\) 后游戏继续？实际上题意是：谁先剪出一个 \(1\times1\) 的小正方形谁获胜。这是“反常”规则吗？需仔细分析）。更常见的版本是：每次将矩形沿格线剪开，当所有矩形都是 \(1\times1\) 时无法行动者输。但此题常见表述为：谁剪出 \(1\times1\) 谁胜，这属于正常规则（因为一旦产生 \(1\times1\)，该玩家立即获胜）。因此可以这样处理：如果一个矩形为 \(1\times1\)，则它已经是终局（不能再剪），且该玩家已获胜。但为了避免歧义，通常的做法是：把 \(1\times1\) 视为必胜态（因为上一手刚剪出它）。在博弈树上，我们设置 \(SG(1,1)=0\)（表示该局面无可行动，但根据规则，剪出它的玩家获胜，所以这个局面是必败态？需要理清）。

实际上该经典题的标准解法是：用 SG 函数，状态为 \((w,h)\)，当 \(w=1\) 且 \(h=1\) 时，SG=0（因为无法再剪，当前玩家输）。对于其他状态，可以剪成两个矩形 \((w1,h1)\) 和 \((w-w1,h)\) 或 \((w,h1)\) 和 \((w,h-h1)\)，但要注意，当剪出 \(1\times1\) 时，该移动直接导致胜利，即该后继局面是必败态（SG=0），所以转移时把 \(1\times1\) 对应的后继 SG 视为 0。

SG 计算：

int sg[205][205];
int getSG(int w, int h) {
    if (sg[w][h] != -1) return sg[w][h];
    bool vis[1000] = {0};
    // 水平剪：分成 (i,h) 和 (w-i,h)
    for (int i = 1; i < w; i++) {
        vis[getSG(i, h) ^ getSG(w - i, h)] = true;
    }
    // 垂直剪
    for (int i = 1; i < h; i++) {
        vis[getSG(w, i) ^ getSG(w, h - i)] = true;
    }
    for (int i = 0; ; i++) if (!vis[i]) return sg[w][h] = i;
}

注意：对于 \(1\times1\)，其 SG 为 0（无后继）。

完整代码（含多组输入）：

#include <bits/stdc++.h>
#define int long long
#define COUT cout<<"\n------------------------------------------------------------------------------------------\n";
#define fi first
#define se second
#define be begin()
#define en end()
using namespace std;
const int N=205;
int sg[N][N];
int getSG(int w,int h) {
    if (sg[w][h]!=-1) return sg[w][h];
    bool vis[1000]={0};
    for (int i=1;i<w;i++) vis[getSG(i,h)^getSG(w-i,h)]=true;
    for (int i=1;i<h;i++) vis[getSG(w,i)^getSG(w,h-i)]=true;
    for (int i=0;;i++) if(!vis[i]) return sg[w][h]=i;
}
signed main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    memset(sg,-1,sizeof(sg));
    sg[1][1]=0;
    int w,h;
    while (cin>>w>>h) {
        if (getSG(w,h)) cout<<"WIN\n"; else cout<<"LOSE\n";
    }
    return 0;
}

7.3 例题3：UVA 10561 “Treblecross”

题意：一行 \(n\) 个格子，初始某些格子已放 'X'，玩家轮流在空位放 'X'，谁先形成连续的三个 'X'（即 "XXX"）谁获胜。求先手所有必胜第一步的位置。

解法：这是典型的 SG 应用。将空白段视为子游戏，因为放置一个 'X' 会将该段分裂成左右两段，并且需要考虑新放置的 'X' 是否会与已有的 'X' 形成三连。通常对每个空白段计算 SG，但要排除那些会导致立即失败的位置（即如果放置后形成 "XXX" 则立即胜，所以该移动是直接获胜，其 SG 为 0 的后继？实际上，若某步能直接形成 "XXX"，那么该步必胜，因此该移动应认为可以转移到必败态，所以该局面的 SG 非 0。在计算 SG 时，我们将这种移动视为将游戏结束，即后继局面为终局 SG=0。但注意，如果某一步会使对手下一步形成 "XXX"，那这一步是危险的，需要排除。

更严谨的做法是：预处理所有安全位置（放置后不会导致三连且不会留给对手三连的机会），然后对每个连续空格段做 SG。由于长度较小，可以直接暴力枚举每个空格并检查。

这里不展开全部细节，仅给出核心 SG 计算思路。

7.4 例题4：Codeforces 768E “Game of Stones”

题意：有 \(n\) 堆石子，每堆数量为 \(a_i\)，每次可以选择一堆，取走任意数量，但不能与之前从该堆取走的数量相同（即同一堆不能重复取同一个数量）。求先手胜负。

解法：这是一个变种 Nim，需要为每堆单独计算 SG。由于限制“不能重复取相同数量”，这相当于每次取的数量必须是新数。可以将每堆视为一个独立的游戏，其 SG 值仅与该堆大小有关，且可预计算。因为 \(a_i\) 最大不超过 \(60\)（由于 \(1+2+\dots+10=55\)，\(1+\dots+11=66\)，所以最多取 10 次），故可暴力搜索。

SG 计算：状态为 (剩余数量, 已用数量集合) 但集合太大，可用位掩码（因为取的数量不超过60）。但更巧妙的规律是：\(SG(a) = a \bmod (k+1)\)? 实际上这题有结论：SG 值等于将 a 表示为 \(1+2+\dots+k\) 的形式，若 \(a = k(k+1)/2\) 则 SG=0？仔细分析：该游戏等价于每次取的数量不能与之前相同，故本质上是一个“减法游戏”但限制条件与历史相关。可以通过递推求出 SG 值，发现周期为 \(m\) 时 \(SG(a) = a \bmod (m+1)\) 不成立，而是与“取过的数”有关。但我们可以将每堆视为一个整体，直接计算其 SG，因为 \(a_i\) 最大 60，所以可以记忆化搜索，状态用 (剩余, 可用集合掩码) 但可用集合最多 60 位，可以用 64 位整数表示。

简化：由于 \(a_i \le 60\)，可以预先计算所有可能状态的 SG。常用做法是：对于一堆石子，其 SG 只依赖于当前数量，因为已取过的数量集合会影响未来可取的数，但我们可以将当前数量视为“还有多少石子”，而可取的数必须小于等于剩余数且未用过。我们可以在搜索时传入一个 mask 表示已用数量，但数量范围小，可以枚举所有 mask。

更常见的解法是：将每个石子堆看作一个“取石子游戏”的子游戏，但该子游戏有内部状态。然而，由于所有堆的规则相同且独立，我们可以计算该子游戏的 SG 函数 \(sg[x]\)（只依赖当前石子数）吗？不行，因为已取过的集合不同，即使当前剩余数量相同，后续可能性也不同。因此，需要更精细的状态。

实际上，对于每堆，我们可以定义状态为 (剩余数量, 可用的最大取数) 或者 (剩余数量, 已用集合)。由于 \(a_i\le 60\)，我们可以用二维 DP：\(f[x][mask]\)，但 mask 太大。不过，由于每次取的数量不能重复，最多取 \(O(\sqrt{x})\) 次，所以可取的次数有限，我们可以用“已取数量集合”的压缩，但可以通过贪心策略证明，最优策略总是取当前可取的某个数，且不会重复。最终可得到 SG 值就是 \(x\) 减去某个三角数后模周期。具体结论：若 \(x\) 在第 \(k\) 个三角数 \(T_k = k(k+1)/2\) 和 \(T_{k+1}\) 之间，则 SG 为 \(x - T_k\)，且周期为 \(k+1\)。例如 \(x=1\) 在 \([T_1=1, T_2=3)\)，\(SG=1-1=0\)；\(x=2\)，\(SG=2-1=1\)；\(x=3\)，\(T_2=3\)，\(SG=0\)；\(x=4\)，在 \([3,6)\)，\(k=2\)，\(SG=4-3=1\)；等等。这个结论可以通过归纳证明。

代码（直接计算 SG）：

int getSG(int x) {
    int k = 0;
    while ((k+1)*(k+2)/2 <= x) k++;
    return x - k*(k+1)/2;
}

7.5 例题5：SPOJ “NIM” 变种 – 每次取素数个

题意：一堆石子，每次可取素数个（如 2,3,5,7,...），取最后一个胜。求 \(n\) 的胜负。

解法：计算 SG 值，找规律。素数集合无限，但可以发现 SG 值有周期。由于素数的分布不规则，周期可能较长，但打表可知周期为 3 或 6 等？实际上，对于包含 2 和 3 的情况，因为 \(2\) 和 \(3\) 互质，周期可能为 6。但需要打表确认。

第八章高级话题与研究扩展

8.1 复杂博弈的 SG 计算复杂度

计算任意有限 ICG 的 SG 值属于 PSPACE-complete（当游戏图作为输入时）。但对于具体结构，如树、区间、平面图等，有多项式算法。研究界关注“SG 值序列”的代数性质，例如线性递推、自动机可识别性等。

8.2 SG 与 Nim 堆的加性分解

每个 ICG 可以分解为若干个“原子游戏”的直和，每个原子游戏的 SG 值为 2 的幂次（因为 Nim 堆可分解为若干二进制位）。这引出了“Green Hackenbush 的扭结理论”等。

8.3 不平等博弈中的 SG 推广

对于 Partizan 游戏，不再有单一 SG 值，但可以定义两个数（左值和右值），属于“超现实数”范畴。尽管如此，公平子游戏仍然是 SG 函数的天下。

8.4 SG 在组合优化中的应用

某些组合优化问题可建模为博弈，如资源分配、网络攻防等，SG 值可用于评估局面对抗性。

8.5 随机化 SG

当允许随机转移时，可定义“概率 SG”，但通常不保留异或性质，需另辟蹊径。

8.6 大规模 SG 计算技巧

哈希映射：对于状态稀疏的情况，用 unordered_map 存储 SG。
时间戳优化：在记忆化搜索中，使用时间戳数组避免重复初始化 used 数组。
位集优化：对于取法集合固定，可用 bitset 加速 mex 计算。

时间戳模板：

int sg[N], vis[N], tag;
int getSG(int x) {
    if (sg[x] != -1) return sg[x];
    tag++;
    for (int m : moves) {
        if (x >= m) vis[getSG(x-m)] = tag;
    }
    for (int i = 0; ; i++) if (vis[i] != tag) return sg[x] = i;
}

8.7 SG 与博弈树搜索的结合（Alpha-Beta）

在无法计算全部 SG 时，可结合搜索与启发式评估，但这对竞赛意义不大。

第九章常见误区与调试技巧

9.1 误判终态 SG

确保终态的 SG 值为 0（正常规则）。若规则是“最后一个行动者输”，则终态为必胜，需特殊处理。

9.2 循环依赖

若游戏有环，不能直接递归（会无限循环）。需用解方程法（如求最小不动点）或转化为有向图博弈的胜败判定（非 SG）。

9.3 数组越界

注意状态范围，若石子数可达 \(10^9\)，不能开数组，需找规律。

9.4 多组数据时清空数组

用 memset(sg, -1, sizeof(sg)) 可能过慢，使用时间戳或每次只初始化用到的部分。

9.5 异或优先级

在 C++ 中，^ 的优先级低于 ==，故条件判断需加括号，如 if ((a^b) != 0)。

第十章综合模板与代码库

10.1 通用 SG 记忆化模板（支持多种移动）

#include <bits/stdc++.h>
#define int long long
#define COUT cout<<"\n------------------------------------------------------------------------------------------\n";
#define fi first
#define se second
#define be begin()
#define en end()
using namespace std;
const int N=200005;
const int mod=998244353;
const int inf=1e18;

int sg[N], tag, vis[N];
vector<int> moves;

int getSG(int x) {
    if (sg[x] != -1) return sg[x];
    tag++;
    for (int m : moves) {
        if (x >= m) vis[getSG(x - m)] = tag;
    }
    for (int i = 0; ; i++) if (vis[i] != tag) return sg[x] = i;
}

signed main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    memset(sg, -1, sizeof(sg));
    // 初始化 moves
    int n;
    while (cin >> n) {
        // 处理每个游戏
    }
    return 0;
}

10.2 区间 SG 模板（如拆分游戏）

int sg[205][205];
int getSG(int l, int r) {
    if (sg[l][r] != -1) return sg[l][r];
    bool used[1000] = {0};
    for (int k = l; k < r; k++) {
        used[getSG(l, k) ^ getSG(k+1, r)] = true;
    }
    for (int i = 0; ; i++) if (!used[i]) return sg[l][r] = i;
}

10.3 树上博弈 SG

vector<int> tree[N];
int dfsSG(int u, int fa) {
    int res = 0;
    for (int v : tree[u]) if (v != fa) res ^= (dfsSG(v, u) + 1);
    return res;
}

第十一章定理与推论汇总

SG 存在性：每个有限无环 ICG 唯一确定 SG 函数。
SG 可加性：组合游戏的 SG 等于各子游戏 SG 的异或。
必败态判定：SG=0 当且仅当为 P-position。
SG 值范围：对于 \(n\) 个状态的游戏，SG 值不超过 \(n\)。
减法游戏的周期性：当取法集合有限时，SG 序列最终周期。
Nim 堆等价：任何 SG 值为 \(k\) 的局面等价于一个大小为 \(k\) 的 Nim 堆。
反 SG 判别：对于 Anti-SG，可通过单独计算胜负态。

第十二章结语

SG 函数是组合博弈论中最优美的工具之一，它将看似复杂的游戏化为简单的数论运算。掌握 SG 函数不仅有助于解决算法竞赛中的博弈题，也能加深对递归、异或、mex 等基础概念的理解。本文从定义出发，逐步展开，覆盖了计算、变形、例题和高级话题，希望能成为读者的一站式参考。

尽管本文已尽量详尽，但博弈论领域博大精深，若读者有志深入，可进一步阅读：

Conway, J.H. On Numbers and Games (1976)
Ferguson, T.S. Game Theory (讲义)
算法竞赛相关书籍如《挑战程序设计竞赛》博弈章节。

祝你在博弈的海洋中畅游愉快！

posted @ 2026-09-21 14:21 Aries2011 阅读(30) 评论(0) 收藏举报

刷新页面返回顶部

Aries2011