数学——博弈论

推荐四道比较好的博弈论题目和sg函数题目，如下：

Fibonacci again and again

杭电oj经典题

分析：整个游戏由三堆独立的石子组成。我们可以分别分析只有一堆石子的情况，然后将结果合并。定理指出，整个游戏的 SG 值是各个独立子游戏 SG 值的 异或 (XOR) 和。 即：SG(m, n, p) = SG(m) XOR SG(n) XOR SG(p)

#include <bits/stdc++.h>

using namespace std;

const int N = 20, M = 1010;

int fib[N], sg[M];

void init()
{
    fib[0] = 1;
    fib[1] = 1;
    for (int i = 2; i < N; i++)
    {
        fib[i] = fib[i - 1] + fib[i - 2];
        if (fib[i] > M)
        {
            fib[i] = 0;
            break;
        }
    }
    sg[0] = 0;
    for (int i = 1; i < M; i++)
    {
        map<int, int> vis;
        for (int j = 0; fib[j] <= i && fib[j] != 0; j++)
        {
            vis[sg[i - fib[j]]] = 1;
        }
        int mex = 0;
        while (vis[mex])
            mex++;
        sg[i] = mex;
    }
}

int main()
{
    init();
    int m, n, q;
    while(cin >> m >> n >> q &&(  m!= 0 || n != 0 || q != 0 )){
        int ans = sg[m] ^ sg[n] ^ sg[q];
        if (!ans)
            cout << "Nacci" << endl;
        else
            cout << "Fibo" << endl;
    }
    return 0;
}

C. Battle

知识点：sg函数

2023江西省赛C题。

p 是奇数时，sg(x) = x % 2。为什么呢？

• 手推一下可以发现 sg 值就是 0, 1, 0, 1, 0, 1... 这样交替出现的。这个序列正好就是 x % 2。所以，当 p 是奇数时，sg(x) 就等于 x 的奇偶性。

当 p 是偶数时，代码的逻辑是

ans ^= sg(x % (p + 1));

这表明，sg(x) 函数的值是周期性的，周期为 p+1。我们只需要分析 x 在 0 到 p 之间的情况。

如何发现 sg(x) 是以 p+1 为周期的特性呢？

方法一：打表找规律

在信息学竞赛中，当遇到一个看似复杂的数学或博弈问题时，如果问题的规模不大（比如此题的 x 我们可以先研究到 100 左右），最有效的方法就是“打表”——写一个简单的程序，计算出小数据范围内的所有 sg 值，然后观察它们的规律。

让我们来模拟这个过程：

1. 选择一个小的偶数 p，比如 p = 2。

2. 写一个暴力程序计算 sg 值。

   • 可用的操作是取走 {1, 2, 4, 8, ...} 个石子。

   • sg(0) = 0

   • sg(1) = mex{ sg(0) } = mex{0} = 1

   • sg(2) = mex{ sg(1), sg(0) } = mex{1, 0} = 2

   • sg(3) = mex{ sg(2), sg(1) } = mex{2, 1} = 0

   • sg(4) = mex{ sg(3), sg(2), sg(0) } = mex{0, 2, 0} = mex{0, 2} = 1

   • sg(5) = mex{ sg(4), sg(3), sg(1) } = mex{1, 0, 1} = mex{0, 1} = 2

   • sg(6) = mex{ sg(5), sg(4), sg(2) } = mex{2, 1, 2} = mex{1, 2} = 0

3. 观察输出的 sg 值序列: 0, 1, 2, 0, 1, 2, 0, 1, 2, ...

4. 发现规律: 我们立刻就能看到，这个序列是以 0, 1, 2 的形式循环的，周期是 3。而我们选的 p=2，周期恰好是 p+1。

5. 验证猜想: 再选一个偶数，比如 p = 4。

   • 可用的操作是取走 {1, 4, 16, ...} 个石子。

   • sg(0) = 0

   • sg(1) = mex{ sg(0) } = 1

   • sg(2) = mex{ sg(1) } = 0

   • sg(3) = mex{ sg(2) } = 1

   • sg(4) = mex{ sg(3), sg(0) } = mex{1, 0} = 2

   • sg(5) = mex{ sg(4), sg(1) } = mex{2, 1} = 0

   • sg(6) = mex{ sg(5), sg(2) } = mex{0, 0} = 1

   • sg(7) = mex{ sg(6), sg(3) } = mex{1, 1} = 0

   • sg(8) = mex{ sg(7), sg(4) } = mex{0, 2} = 1

   • sg(9) = mex{ sg(8), sg(5) } = mex{1, 0} = 2

6. 观察输出的 sg 值序列: 0, 1, 0, 1, 2, 0, 1, 0, 1, 2, ... 这个序列是以 0, 1, 0, 1, 2 循环的，周期是 5。而我们选的 p=4，周期恰好是 p+1。

方法二：数学性质分析

1. 关键恒等式: p ≡ -1 (mod p+1)。这是显然的，因为 p+1 除以 p+1 余 0，所以 p 除以 p+1 余 p 或者说余 -1。

2. 分析操作对 mod (p+1) 的影响: 我们看看每次取走 p^k 个石子，会让石子数 x 在模 p+1 的意义下发生什么变化。

   • 当 k=0，取走 p^0 = 1。x 变为 x-1。在模 p+1 意义下，x 减了 1。

   • 当 k 是奇数时，p^k ≡ (-1)^k ≡ -1 (mod p+1)。取走 p^k 个石子，在模 p+1 意义下，相当于 x - (-1) = x + 1。

   • 当 k 是偶数且 k>0 时，p^k ≡ (-1)^k ≡ 1 (mod p+1)。取走 p^k 个石子，在模 p+1 意义下，相当于 x - 1。

3. 发现核心结构: 无论你执行哪种操作（取走 p^k），石子数 x 在模 p+1 意义下，要么加 1，要么减 1。

4. 得出结论: sg(x) 的值是由 sg(x - p^k) 决定的。而我们刚刚发现，x - p^k 在模 p+1 意义下的值，与 x 在模 p+1 意义下的值有非常紧密的联系（只相差 1）。 这意味着，sg(x) 的计算所依赖的那些 sg 值，它们的下标在模 p+1 意义下都与 x mod (p+1) 相关。 换句话说，sg(x) 的计算方式，只取决于 x mod (p+1) 的值。这就证明了 sg 函数必然以 p+1 为周期。

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define x first
#define y second
#define ll long long
#define PII pair<int, int>
ll n, p;
int sg(int x)
{
    if (x == p)
        return 2;
    if (x & 1)
        return 1;
    return 0;
}
void solve()
{

    cin >> n >> p;
    ll ans = 0;
    for (int i = 0; i < n; i++)
    {
        ll x;
        cin >> x;
        if (p & 1)
        {
            ans ^= (x % 2);
            // cout << "ans = " << ans << endl;
        }
        else
        {
            ans ^= sg(x % (p + 1));
        }
    }
    // cout << ans << endl;
    if( ans )
        cout << "GOOD" << endl;
    else
        cout << "BAD" << endl;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    solve();
    return 0;
}

J. Just another Sorting Problem

2024昆明区域赛简单题

知识点：分类博弈

分析：经验题，自然可以看出n = 2 , n = 3是两个特殊的情况需要拿出来考虑，其他的n >= 4只要不能让A一次获胜就B胜。

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define x first
#define y second
#define ll long long
#define PII pair<int, int>

// 选择 两个相邻的位置 交换 pi 和  pj
void solve()
{
    int n;
    string name;
    cin >> n >> name;
    vector<int> a(n + 1);
    int cnt = 0;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        if (i != a[i])
            cnt++;
    }
    // 升序 aiice 获胜
    // 只有两个 数字不在指定的位置
    if(n == 2){
        cout << "Alice" << endl;
        return;
    }
    if(n == 3){
        if(cnt == 3){
            if(name == "Bob")
                cout << "Alice" << endl;
            else
                cout << "Bob" << endl;
        }else if(cnt == 0 ){
            if(name == "Bob"){
                cout << "Alice" << endl;
            }else{
                cout << "Bob" << endl;
            }
        }else{
            if(name == "Bob"){
                cout << "Bob" << endl;
            }else
            {
                    cout << "Alice" << endl;
            }
        }
        return;
    }

    if (cnt == 2 && name == "Alice")
        cout << "Alice" << endl;
    else
        cout << "Bob" << endl;

}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}

A Multiplication Game

杭电oj经典题目

分析：

p从1开始，每次乘2~9，所以2~9是先手必胜的。然后9~18，是先手必败。19~18*9是先手必胜，同样，18*9+1~18*2*9是先手必败。

容易看出，是以18为规律的，除18，最后看在那个区间。

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    double n;
    while (cin >> n)
    {
        while (n > 18)
        {
            n = n / 18;
        }
        if (n <= 9)
        {
            cout << "Stan wins." << endl;
        }
        else
        {
            cout << "Ollie wins." << endl;
        }
    }
    return 0;
}