Acwing 简单博弈论

公平组合游戏ICG
若一个有限满足：由两名玩家交替行动：

• 在游戏进程的任意时刻；
• 可以执行的合法行动与轮到哪名玩家无关；
• 不能行动的玩家判负；

则称该游戏为一个公平组合游戏。NIM博弈属于公平组合游戏，但城建的棋类游戏，比如围棋就不是公平组合游戏。因为围棋交战双方只能落黑子和白子，胜负判定也比较复杂，不满足条件2和3.

Nim游戏
给定N堆物品，第i堆物品由Ai个。两名玩家轮流行动，每次可以任选一堆，取走多个物品，可把一堆取光，但不能不取，取走最后一件物品者获胜。两人都采取最优策略，问先手是否必胜。

我们把这种游戏称为NIM博弈。把游戏过程中面临的状态称为局面。整局游戏第一个行动的称为先手，第二个行动的称为后手。若在某一局面下无论采取何种行动，都会输掉游戏，则称该局面必败。 所谓采取最优策略是指，若在某一局面下存在某种行动，使得行动后对面面临必败局面，则优先采取该行动。同时，这样的局面被称为必胜。我们讨论的博弈问题一般都只考虑理想情况，即两人均无失误，都采取最优策略行动时游戏的结果。 NIM博弈不存在平局，只有先手必胜和先手必败两种情况。

• 必胜状态：先手进行某一个操作，留给后手是一个必败状态时，对于先手来说是一个必胜状态。即先手可以走到某一个必败状态。
• 必败状态：先手无论如何操作，留给后手都是一个必胜状态时，对于先手来说是一个必败状态。即先手走不到任何一个必败状态。
  结论：假设n堆物品，数目分别为a1,a2,a3…an，如果a1⊕a2⊕a3.......⊕an != 0，则先手必胜；否则为0，先手必败

证明过程我们不必理会，记住这个结果，代码还是很简单的。
Acwing 891.Nim游戏

具体实现代码（详解版）：

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

int main() {
    int n;
    cin >> n; // 读取石子堆的数量 n
    int res = 0; // 用来存储所有石子堆数量的异或结果
    while (n--) { // 读取每一堆的石子数量
        int a;
        cin >> a; // 读取每堆石子的数量
        res ^= a; // 将每个堆的石子数与当前异或结果进行异或
    }
    
    // 判断异或结果是否为0
    if (res) puts("Yes"); // 如果 res 不为 0，表示先手必胜
    else puts("No");      // 如果 res 为 0，表示先手必败
    
    return 0;
}

下面看一个变形题目：

Acwing 892 台阶-Nim游戏

实现思路：此时我们需要将奇数台阶看做一个经典的Nim游戏，如果先手时奇数台阶上的值的异或值为0，则先手必败，反之必胜；

具体实现代码（详解版）：

#include <iostream>
#include <algorithm>

using namespace std;

int main(){
    int n ,res = 0;
    cin >> n ;
    for(int i = 1 ; i <= n ; i ++){
        int a; 
        cin >> a;
        if(i % 2) res ^= a;//选择奇数台阶进行异或
    }
    if(res) puts("Yes");//异或非零必胜
    else puts("No");
    
    return 0;
}

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

Mex运算
设S表示一个非负整数集合。定义mex（S）为求出不属于集合S的最小非负整数的运算，即mex（S）=min{x}，x属于自然数，且x不属于S。eg：mex({1,2,3})=0，mex({0,1,2})=3；

SG函数
在有向图游戏中，对于每个节点x，设从x出发共有k条有向边，分别到达节点y1, y2, …, yk，定义SG(x)为x的后继节点y1, y2, …, yk 的SG函数值构成的集合再执行mex(S)运算的结果，即： SG(x) = mex({SG(y1), SG(y2), …, SG(yk)}) 特别地，整个有向图游戏G的SG函数值被定义为有向图游戏起点s的SG函数值，即SG(G) = SG(起点)。且图的终点（即不含出边的点）的SG函数值为0.

定理：

• 有向图游戏的某个局面必胜，当且仅当该局面对应节点的SG函数值不为0。
• 有向图游戏的某个局面必败，当且仅当该局面对应节点的SG函数值等于0。

有向图游戏的和
设G1，G2,····,Gm是m个有向图游戏.定义有向图游戏G,他的行动规则是任选某个有向图游戏Gi,并在Gi上行动一步.G被称为有向图游戏G1,G2,·····,Gm的和.
有向图游戏的和的SG函数值等于它包含的各个子游戏SG函数的异或和,即:SG(G)=SG(G1)⊕SG(G2)⊕··⊕ SG(Gm)

Acwing 893.集合-Nim游戏

若有一堆的数量为10，取法为2，5，则他的状态图如下所示，就是每次选择取法不同，出现不一样的分支

得到其SG函数的值，即SG(10)=1。同理计算其他石子堆的的SG值，将所有堆SG值异或，若不为0，则先手必胜，若为0则先手必败。

实现思路：

• 设置取法数组s[]，所有石子堆共享操作
• 设置一个数组f，f[x]记录图中某点x的SG值，初始为-1表示x还未计算。注意只要x的SG确定了那么就不会再改变，因为针对同一个数x，无论在哪个石子堆，他就只能执行相同的操作，因为所有石子堆共享取法集合。比如x=5，取法{2,5}，那么在任何石子堆，x的出边只能为0或3，固定的；
• 这里使用一个哈希表S存储当前点出边点的SG值，以此确定当前点的SG值，可实现自动排序，和判断某个值是否出以此来完成mex操作（选出最小且没有出现的自然数）。哈希表S必须定义为局部变量，每次递归都会使用新的哈希表，所以一个图其他不与当前点相连的点的存在不会影响当前点SG的计算

为什么哈希S不能开全局，只能作为局部变量？
对于集合-Nim，注意到0这个值可以被映射多次（如上图），这意味着有多个可能的值xi作为叶子节点（末尾节点），满足f[xi] = 0。而如果将S作为全局变量，则其中只能有一个值x’映射到0，由mex函数知其他的值都将映射到大于0的值（即f[x’] = 0，f[xi/x’] > 0，xi/x’代表集合x排除掉x’所剩值组成的集合），因而不能将S作为全局变量，防止不同点的相互影响。

具体实现代码（详解版）：

#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_set>

using namespace std;

const int N = 110, M = 10010; 

int n, m; 
int s[N], f[M]; // s 存储取法数，f 存储 SG 值

// 计算状态 x 的 SG 值
int sg(int x) {
    if (f[x] != -1) return f[x]; // 如果 SG 值已计算过，直接返回

    unordered_set<int> S; // 哈希表 存储x能到的点的SG值，以此确定x的值，每次递归都是最新的
    for (int i = 0; i < m; i++) { // 遍历所有操作数
        int sum = s[i];
        if (x >= sum) S.insert(sg(x - sum)); // 一条分支路径 直到终点
    }
    
    // mex操作 确定x的SG值
    for (int i = 0;; i++) {
        if (!S.count(i)) 
            return f[x] = i; // 选出最小的没有出现的自然数，赋给x的SG值
    }
}

int main() {
    cin >> m; 
    for (int i = 0; i < m; i++) cin >> s[i]; 
    cin >> n; 
    
    memset(f, -1, sizeof f); // 初始化 SG 值数组为 -1，表示还未计算
    
    int res = 0; 
    for (int i = 0; i < n; i++) { 态
        int x;
        cin >> x; 
        res ^= sg(x); //各个堆的SG值异或，每个堆的SG=起点的SG值
    }
    
    // 根据结果判断先手是否有必胜策略
    if (res) puts("Yes"); // 如果 res 不为 0，先手必胜
    else puts("No");      // 如果 res 为 0，先手必败
    
    return 0;
}

Acwing 894.拆分-Nim游戏

实现思路：首先可以看出必然会有解（有限的），因为每次放入的两堆规模各自都会比原规模小，各堆石子每次操作后呈递减趋势，最后必然会趋于0，比如一堆石子个数是1，取走以后，只会再放入两堆个数为0的石子。相比于集合-Nim，这里的每一堆可以变成小于原来那堆的任意大小的两堆
即a[i]可以拆分成(b[i], b[j]),为了避免重复规定b[i]>= b[j],即: a[i]>b[i]>= b[j]
相当于一个局面拆分成了两个局面，由SG函数理论，多个独立局面的SG值，等于这些局面SC值异或和。因此需要存储的状态就是sg(b[i])^sg(b[j])(与集合-Nim的唯一区别)
PS:因为这题中原堆拆分成的两个较小堆小于原堆即可，因此任意一个较小堆的拆分情况会被完全包含在较大堆中，因此S可以开全局。当然也可以在函数中定义。

具体实现代码（详解版）：

#include <iostream>
#include <cstring>
#include <unordered_set>

using namespace std;
const int N = 110;

int n;
int f[N];

unordered_set<int> S;

//求sg的值
int sg(int x){
    if(f[x] != -1) return f[x];//表示已经求过了 无需再求
    
    //将一堆石子拆分成两堆更小的石子i ,j
    for(int i = 0 ;i < x ; i ++){
        for(int j = 0 ; j <= i ; j ++){//规定j不大于i，避免重复计算
            S.insert(sg(i) ^ sg(j));//由SG的函数理论，多个独立局面的SG值等于这些局面SG值的异或
        }
    }
    //mex操作 得到不存在的最小数
    for(int i = 0 ; ; i ++){
        if(!S.count(i))
          return f[x] = i;
    }
}

int main(){
    memset(f , -1 ,sizeof f);
    
    cin >> n;
    int res = 0;
    while(n --){
        int x;
        cin >> x;
        res ^= sg(x);
    }
    
    if(res) puts("Yes");
    else puts("No");
    
    return 0;
}

以上就是一些简单博弈论的题目，需要把数学公式给提炼出来。