数学知识（四）
这一小节讲的是容斥原理和简单博弈论。
容斥原理
定义
最基本的，假设有3个两两相交的圆。那么三个圆所覆盖的面积大小为
S 1 + S 2 + S 3 − S 1 ∩ S 2 − S 2 ∩ S 3 − S 1 ∩ S 3 + S 1 ∩ S 2 ∩ S 3 S_1+S_2+S_3 - S_1 \cap S_2 - S_2 \cap S_3 - S_1 \cap S_3 + S_1 \cap S_2 \cap S_3 S1+S2+S3−S1∩S2−S2∩S3−S1∩S3+S1∩S2∩S3
如果是2个圆的话，那么其所覆盖的面积为
S 1 + S 2 − S 1 ∩ S 2 S_1 + S_2 - S_1 \cap S_2 S1+S2−S1∩S2
如果是4个圆的话，那么面积为
S 1 + S 2 + S 3 + S 4 S_1 + S_2 + S_3 + S_4 S1+S2+S3+S4
− S 1 ∩ S 2 − S 1 ∩ S 3 − S 1 ∩ S 4 − S 2 ∩ S 3 − S 2 ∩ S 4 − S 3 ∩ S 4 - S_1 \cap S_2 - S_1 \cap S_3 - S_1 \cap S_4 - S_2 \cap S_3 - S_2 \cap S_4 - S_3 \cap S_4 −S1∩S2−S1∩S3−S1∩S4−S2∩S3−S2∩S4−S3∩S4
+ S 1 ∩ S 2 ∩ S 3 + S 1 ∩ S 2 ∩ S 4 + S 1 ∩ S 3 ∩ S 4 + S 2 ∩ S 3 ∩ S 4 + S_1 \cap S_2 \cap S_3 + S_1 \cap S_2 \cap S_4 + S_1 \cap S_3 \cap S_4 + S_2 \cap S_3 \cap S_4 +S1∩S2∩S3+S1∩S2∩S4+S1∩S3∩S4+S2∩S3∩S4
− S 1 ∩ S 2 ∩ S 3 ∩ S 4 - S_1 \cap S_2 \cap S_3 \cap S_4 −S1∩S2∩S3∩S4
更一般的，假设有 n n n 个集合， S 1 S_1 S1， S 2 S_2 S2，…， S n S_n Sn
这 n n n 个集合的并集中所包含的元素个数，可以用容斥原理进行计算。
S 1 ∪ S 2 ∪ S 3 . . . ∪ S n = ∑ i S i − ∑ i , j S i ∩ S j + ∑ i , j , k S i ∩ S j ∩ S k − . . . . . S_1 \cup S_2 \cup S_3 ... \cup S_n = \sum_i{S_i} - \sum_{i,j}{S_i \cap S_j} + \sum_{i,j,k}{S_i \cap S_j \cap S_k} - ..... S1∪S2∪S3...∪Sn=∑iSi−∑i,jSi∩Sj+∑i,j,kSi∩Sj∩Sk−.....
上式中，包含1个集合的项，一共有 C n 1 C_n^1 Cn1 个，包含2个集合的项，一共有 C n 2 C_n^2 Cn2个；包含3个集合的项，一共有 C n 3 C_n^3 Cn3 个，…
所以，上式中的所有项的个数，一共是 C n 1 + C n 2 + C n 3 + . . . + C n n = 2 n − 1 C_n^1 + C_n^2 + C_n^3 + ... + C_n^n = 2^n - 1 Cn1+Cn2+Cn3+...+Cnn=2n−1，所以上式中一共有 2 n − 1 2^n - 1 2n−1 项，时间复杂度是 2 n 2^n 2n（其实还要看一下每一项的计算复杂度是多少）。
证明
容斥定理要如何来证明呢？我们可以用集合的并操作来考虑。
假设有 n 个集合，每个集合里有一些元素（集合内的元素是不重复的），求这 n 个集合的并集，即求 n 个集合中不同的元素的总个数。根据容斥原理，可以用如下公式进行计算
S 1 ∪ S 2 ∪ S 3 . . . ∪ S n = ∑ i S i − ∑ i , j S i ∩ S j + ∑ i , j , k S i ∩ S j ∩ S k − . . . . . S_1 \cup S_2 \cup S_3 ... \cup S_n = \sum_i{S_i} - \sum_{i,j}{S_i \cap S_j} + \sum_{i,j,k}{S_i \cap S_j \cap S_k} - ..... S1∪S2∪S3...∪Sn=∑iSi−∑i,jSi∩Sj+∑i,j,kSi∩Sj∩Sk−.....
现在来证明这个公式的正确性，考虑对于某个元素 x ，其是否只被计数了一次。不妨设这个元素 x 一共在 k 个集合中出现过。那么在上面的公式右侧，只包含一个集合时，x 会被加上 k 次，也就是 C k 1 C_k^1 Ck1 次，在第二项，包含2个集合时，x 会被减去上 C k 2 C_k^2 Ck2 次，第三项同理，后续的项也同理。
那么 x 被计数的次数就是 C k 1 − C k 2 + C k 3 − C k 4 + . . . . + ( − 1 ) k − 1 ⋅ C k k C_k^1 - C_k^2 + C_k^3 - C_k^4 + .... + (-1)^{k-1} \cdot C_k^k Ck1−Ck2+Ck3−Ck4+....+(−1)k−1⋅Ckk，而这个式子是恒等于1的。所以元素 x 总共只被计数了1次。
C k 1 − C k 2 + C k 3 − C k 4 + . . . . + ( − 1 ) k − 1 ⋅ C k k C_k^1 - C_k^2 + C_k^3 - C_k^4 + .... + (-1)^{k-1} \cdot C_k^k Ck1−Ck2+Ck3−Ck4+....+(−1)k−1⋅Ckk 这个等式是一个组合恒等式，具体的证明，可以将 ( x + 1 ) n (x+1)^{n} (x+1)n 在 x = − 1 x = -1 x=−1 时进行二项式展开，进行观察。
于是我们就证得，对于任意一个元素 x ，根据容斥原理，其只会被统计一次，也就证明了容斥原理的正确性。
练习题
给定一个整数 n ，以及m个不同的质数 p i p_i pi ，求 1 - n 中能被至少一个质数整除的数有多少个？
举个简单的样例，
n
=
10
，
p
1
=
2
，
p
2
=
3
n = 10，p_1 = 2，p_2=3
n=10，p1=2，p2=3，那么 1 - 10中能被2或3整除的数，有2 3 4 6 8 9 10，共7个
如果暴力来做的话，对于1 - n 每个数，最多可能需要依次枚举 m 个质数，看能否整除，时间复杂度 O ( n m ) O(nm) O(nm)，这道题目光 n 就能取到 1 0 9 10^9 109，所以这样做肯定会超时。
用容斥原理来做，首先我们需要定义集合，对于上面的样例数据，我们定义
S 2 S_2 S2 表示 1 - 10 中所有能被 2 整除的数，即 S 2 = 2 , 4 , 6 , 8 , 10 S_2 = {2,4,6,8,10} S2=2,4,6,8,10，同理，有 S 3 = 3 , 6 , 9 S_3={3,6,9} S3=3,6,9
我们要求的就是 S 2 ∪ S 3 = S 2 + S 3 − S 2 ∩ S 3 = 5 + 3 − 1 = 7 S_2 \cup S_3 = S_2 + S_3 - S_2 \cap S_3 = 5 + 3 - 1 = 7 S2∪S3=S2+S3−S2∩S3=5+3−1=7
而容斥原理的时间复杂度是 2 m 2^m 2m ，对于这道题目， m m m 最大取到16，所以时间复杂度最多达到 2 16 = 65536 2^{16} = 65536 216=65536
我们看一下每一项如何求，即如何求
S
i
S_i
Si，
S
i
S_i
Si 包含了 1 - n 中所有 i 的倍数，而我们只用
S
i
S_i
Si 表示这个集合中的元素个数，则
S
i
=
⌊
n
i
⌋
S_i = \lfloor \frac{n}{i} \rfloor
Si=⌊in⌋ ，那对于两个集合的交集的个数如何求呢，即
S
i
∩
S
j
S_i \cap S_j
Si∩Sj，由于给定的数都是质数，则质数两两都是互质的，既能被 i 整除，又能被 j 整除的数，一定是i和j的倍数，那么其最小公倍数是 i × j，则
S
i
∩
S
j
=
⌊
n
i
⋅
j
⌋
S_i \cap S_j = \lfloor \frac{n}{i \cdot j} \rfloor
Si∩Sj=⌊i⋅jn⌋，对于两个集合的交集，需要2次除法，对于 m 个集合的交集，需要 m 次除法，所以每一项的计算量，我们可以看作是 m ，所以总的复杂度是
O
(
2
m
⋅
m
)
O(2^m \cdot m)
O(2m⋅m) ，大概是
2
16
⋅
16
=
2
20
≈
1
0
6
2^{16} \cdot 16 = 2^{20} \approx 10^6
216⋅16=220≈106
一共是 2 m − 1 2^m - 1 2m−1项（容斥原理公式中，其实就是组合数求和，可以按照每一个集合选或不选，进行状态枚举），所以考虑用位运算来做，因为这道题的 m 最大只有 16
#include <iostream>
typedef long long LL;
using namespace std;
const int N = 20;
int p[N]; // 质数
int main() {
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> p[i];
int ans = 0;
// 状态枚举1 ~ 2^m - 1
for (int i = 1; i < 1 << m; i++) {
// 选了多少个集合, 以及计算下质数的乘积
int cnt = 0, prod = 1;
for (int j = 0; j < m; j++) {
if (i >> j & 1) {
cnt++;
if ((LL)prod * p[j] > n) {
// 乘积超过n了, 说明该项一定为0, 不用计算
prod = -1;
break;
}
prod *= p[j];
}
}
if (prod != -1) {
if (cnt & 1) ans += n / prod; // 奇数个集合时，需要加
else ans -= n / prod; // 偶数个集合时, 需要减
}
}
printf("%d\n", ans);
return 0;
}
博弈论
Nim游戏
公平组合游戏ICG
若一个游戏满足如下3个条件，则称该游戏为一个公平组合游戏
- 两名玩家交替行动（先手，后手）
- 在游戏进程的任意时刻，可以执行的合法行动，与轮到哪位玩家无关（任意时刻，两名玩家能执行的操作都是相同的）
- 不能行动的玩家判负
像一些常见的棋类游戏，就不是公共组合游戏，比如围棋，五子棋，先手和后手分别只能落黑子和白子，操作是不一样的，胜负的判定也比较复杂。Nim游戏则属于公平组合游戏
有向图游戏
给定一个有向无环图，图中有一个唯一的起点，起点上放一枚棋子，两名玩家交替地把这枚棋子沿着有向边进行移动，每次可以移动一步，无法移动者判负。
任何一个公平组合游戏，都可以转化成一个有向图游戏，具体方法是，将每种局面看成图中的一个点，并且从每个局面，向沿着合法行动能够到达的下一个局面，连一条有向边。（状态机）
先手必胜状态：可以走到某一个必败状态
先手必败状态：走不到任何一个必败状态
练习题：891. Nim游戏
给定 n 堆石子，两名玩家轮流操作，每次操作可以从任意一堆石子中拿走任意数量的石子，最后无法操作的人视为失败。若两人都采用最优策略，问先手是否必胜。
这道题目的结论很简单，把所有石子的数量全部异或起来，如果结果是0，则先手必败；否则先手必胜。可以这样理解，只要某一方操作完，每堆石子的数量一样，那么他必胜。
来证明一下这个结论，首先，终局的状态是所有石子都是0，那么终局的状态的异或结果就是0，遇到终局的那个人必败。我们只需要证明一下，对于某个异或结果不为0的局面，都能走到一个异或结果为0的局面即可。
也就是说，对于某个异或结果不为0的局面，我们都能通过从某堆石子里拿走一部分，使得异或结果变为0。
我们只要证明这一点即可。
设每堆石子的个数为 a i a_i ai，设所有石子的异或值为 x x x，则有 a 1 ⊕ a 2 ⊕ a 3 ⊕ . . . ⊕ a n = x ≠ 0 a_1 \oplus a_2 \oplus a_3 \oplus ... \oplus a_n = x \ne 0 a1⊕a2⊕a3⊕...⊕an=x=0
假设， x x x 的二进制表示中，最高的一位1，在第 k 位，则说明， a 1 a_1 a1 到 a n a_n an 中，至少存在一个数，其二进制的第 k 位是1（准确的说是存在奇数个数，这些数的二进制表示的第k位都是1）。不妨设这个数为 a j a_j aj，那么显然有 a j ⊕ x < a j a_j \oplus x < a_j aj⊕x<aj ，因为 x x x 的第 k 位是1，且更前面的位全是0，而 a j a_j aj 的第 k 位也是1，则这两个数异或起来， a j a_j aj 的第 k 位从1变为0，而 a j a_j aj 前面更高位都是不变的，而后面更低位可能变成任何数，但是总体来说都是变得更小了。
所以，我们可以从 a j a_j aj 中拿走一部分石子，使得其变小，变成 a j ⊕ x a_j \oplus x aj⊕x。
我们看下此时的局面，所有的石子数量异或起来就是 a 1 ⊕ a 2 ⊕ a 3 . . . ⊕ a j ⊕ x . . . ⊕ a n = x ⊕ x = 0 a_1 \oplus a_2 \oplus a_3 ... \oplus a_j \oplus x ... \oplus a_n = x \oplus x = 0 a1⊕a2⊕a3...⊕aj⊕x...⊕an=x⊕x=0
所以，对某个异或结果不为0的局面，一定能通过拿走某些石子，使得异或结果变为0。
另外，我们还需要证明下，对于异或结果为0的局面，无论怎么操作，得到的一定是异或结果不为0的局面。
可以用反证法，假设从某个石堆中拿走部分石子，得到的异或结果仍然是0，假设操作的是 a j a_j aj，操作后该石堆剩余的数量为 a j ′ a_j^{'} aj′，那么有 a 1 ⊕ a 2 ⊕ . . . a j . . . ⊕ a n = 0 a_1 \oplus a_2 \oplus ...a_j ... \oplus a_n = 0 a1⊕a2⊕...aj...⊕an=0，并且 a 1 ⊕ a 2 ⊕ . . . a j ′ . . . ⊕ a n = 0 a_1 \oplus a_2 \oplus ...a_j^{'} ... \oplus a_n = 0 a1⊕a2⊕...aj′...⊕an=0，把这两个式子异或起来，就有 a j ⊕ a j ′ = 0 a_j \oplus a_j^{'} = 0 aj⊕aj′=0，这也就说明 a j = a j ′ a_j = a_j^{'} aj=aj′，即我们没有从这堆石子中拿走任何石子，显然矛盾了，因为每次操作不能不拿。
总结一下
- 终局（必败状态），异或结果是0
- 异或结果不为0的局面，则一定能通过某个操作，变成异或结果为0的局面
- 异或结果为0的局面，无论如何操作，都会变成异或结果不为0的局面
故，若初始状态异或结果不为0，则先手必胜；否则先手必败。
此题是最简单的nim游戏，可以自行拓展了解 k-nim 游戏
#include <iostream>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, x, res = 0;
cin >> n;
while (n--) {
cin >> x;
res ^= x;
}
if (res) printf("Yes\n");
else printf("No\n");
return 0;
}
思考题：892. 台阶-Nim游戏
结论：只需要考虑奇数的台阶数，若奇数的台阶上的石子，异或起来结果不等于0，则先手必胜，否则先手必败。
题解参考这篇
#include <iostream>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, a;
cin >> n;
int res = 0;
for (int i = 1; i <= n; i++) {
cin >> a;
if (i & 1) res ^= a;
}
if (res) printf("Yes\n");
else printf("No\n");
return 0;
}
SG函数
Mex运算
针对集合的一种运算，找到一个集合中不存在的最小的自然数，比如集合 S = {1,2 ,3}，那么Mex(S) = 0
SG函数
对于有向图游戏，我们把每种局面（状态）看成一个点，如果由某个局面，可以转变到另外的一些局面，则我们把这些点之间用有向边连接起来。
我们先将终点的状态的SG函数（没有出边的点），定义为0，假设终点状态为e，则SG(e) = 0，则对于某种状态 x ，其SG函数如何求呢？假设 x 能够转变到 y1，y2，y3，…，yk 。则 SG(X) = Mex{SG(y1), SG(y2), ... , SG(yk)}
如下图所示，每个点的SG函数用红色标注了出来
如果整个有向图游戏，只有一个连通块的话，设初始状态为s，则若SG(s) = 0，则先手必败，否则，先手必胜。对于某个状态x，若SG(x) != 0，则说明状态 x 一定能到达某个状态y，并且 SG(y) = 0。所以，任意一个SG非0的状态，都能到达一个SG为0的状态，并且任何一个SG为0的状态，是到不了一个SG为0的状态的。
简单总结就是，任意SG非0的状态，都能到一个SG为0的状态；任意SG为0的状态，都只能到SG非0的状态。而终局状态SG值为0。所以，初始状态SG若非0，则先手必胜，否则先手必败。
若一个图有多个连通块，则我们把每个连通块的初始点的SG值异或起来，若等于0，则先手必败；否则必胜。
证明方法和上面Nim游戏的证明方法一样。
必败态是所有起点的SG值都为0，此时异或结果为0。
若所有起点的SG值异或结果不为0，设所有起点的SG的异或结果为x，则一定能找到一个起点i，使得
SG(i) ^ x < SG(i)，不妨设 y = SG(i) ^ x，则由于y < SG(i)，则说明i一定能到达某个状态j，使得SG(j) = y，那么我们只要从i走到j，那么此时所有连通块起点的异或结果就是
SG(1) ^ SG(2) ^ .. ^ SG(i) ^ x ... SG(n) = x ^ x = 0。
所以一定能从异或结果非0走到0，而从0只能走到非0，于是得证。
通过SG函数，可以显著的降低计算量。
#include <iostream>
#include <unordered_set>
#include <cstring>
using namespace std;
const int N = 110, M = 10010;
int s[N], f[M];
int k, n;
int sg(int x) {
if (f[x] != -1) return f[x];
if (x == 0) return f[x] = 0;
unordered_set<int> S;
for (int i = 0; i < k; i++) {
if (x >= s[i]) S.emplace(sg(x - s[i]));
}
for (int i = 0; ; i++) {
if (!S.count(i)) return f[x] = i;
}
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> k;
for (int i = 0; i < k; i++) cin >> s[i];
memset(f, -1, sizeof f);
int res = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
res ^= sg(x);
}
if (res) printf("Yes\n");
else printf("No\n");
return 0;
}
思考题：894. 拆分 - Nim游戏
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
