數學知識-模板

試除法判定質數 —— 模板題 AcWing 866. 試除法判定質數

bool is_prime(int x)
{
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
}

試除法分解質因數 —— 模板題 AcWing 867. 分解質因數

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}

樸素篩法求素數 —— 模板題 AcWing 868. 篩質數

int primes[N], cnt;     // primes[]存儲所有素數
bool st[N];         // st[x]存儲x是否被篩掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i; j <= n; j += i)
            st[j] = true;
    }
}

線性篩法求素數 —— 模板題 AcWing 868. 篩質數

int primes[N], cnt;     // primes[]存儲所有素數
bool st[N];         // st[x]存儲x是否被篩掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

試除法求所有約數 —— 模板題 AcWing 869. 試除法求約數

vector<int> get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

約數個數和約數之和 —— 模板題 AcWing 870. 約數個數, AcWing 871. 約數之和

如果 N = p1^c1 * p2^c2 * ... *pk^ck
約數個數： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
約數之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)

歐幾里得算法 —— 模板題 AcWing 872. 最大公約數

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

求歐拉函數 —— 模板題 AcWing 873. 歐拉函數

int phi(int x)
{
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);

    return res;
}

篩法求歐拉函數 —— 模板題 AcWing 874. 篩法求歐拉函數

int primes[N], cnt;     // primes[]存儲所有素數
int euler[N];           // 存儲每個數的歐拉函數
bool st[N];         // st[x]存儲x是否被篩掉


void get_eulers(int n)
{
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)
            {
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

快速冪 —— 模板題 AcWing 875. 快速冪

求 m^k mod p，時間複雜度 O(logk)。

int qmi(int m, int k, int p)
{
    int res = 1 % p, t = m;
    while (k)
    {
        if (k&1) res = res * t % p;
        t = t * t % p;
        k >>= 1;
    }
    return res;
}

擴展歐幾里得算法 —— 模板題 AcWing 877. 擴展歐幾里得算法

// 求x, y，使得ax + by = gcd(a, b)
int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a/b) * x;
    return d;
}

高斯消元 —— 模板題 AcWing 883. 高斯消元解線性方程組

// a[N][N]是增廣矩陣
int gauss()
{
    int c, r;
    for (c = 0, r = 0; c < n; c ++ )
    {
        int t = r;
        for (int i = r; i < n; i ++ )   // 找到絕對值最大的行
            if (fabs(a[i][c]) > fabs(a[t][c]))
                t = i;

        if (fabs(a[t][c]) < eps) continue;

        for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 將絕對值最大的行換到最頂端
        for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 將當前上的首位變成1
        for (int i = r + 1; i < n; i ++ )       // 用當前行將下面所有的列消成0
            if (fabs(a[i][c]) > eps)
                for (int j = n; j >= c; j -- )
                    a[i][j] -= a[r][j] * a[i][c];

        r ++ ;
    }

    if (r < n)
    {
        for (int i = r; i < n; i ++ )
            if (fabs(a[i][n]) > eps)
                return 2; // 無解
        return 1; // 有無窮多組解
    }

    for (int i = n - 1; i >= 0; i -- )
        for (int j = i + 1; j < n; j ++ )
            a[i][n] -= a[i][j] * a[j][n];

    return 0; // 有唯一解
}

遞歸法求組合數 —— 模板題 AcWing 885. 求組合數 I

// c[a][b] 表示從a個蘋果中選b個的方案數
for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

通過預處理逆元的方式求組合數 —— 模板題 AcWing 886. 求組合數 II

首先預處理出所有階乘取模的餘數fact[N]，以及所有階乘取模的逆元infact[N]
如果取模的數是質數，可以用費馬小定理求逆元
int qmi(int a, int k, int p)    // 快速冪模板
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

// 預處理階乘的餘數和階乘逆元的餘數
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i ++ )
{
    fact[i] = (LL)fact[i - 1] * i % mod;
    infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
}

Lucas定理 —— 模板題 AcWing 887. 求組合數 III

若p是質數，則對於任意整數 1 <= m <= n，有：
    C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)

int qmi(int a, int k)       // 快速冪模板
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}


int C(int a, int b)     // 通過定理求組合數C(a, b)
{
    int res = 1;
    for (int i = 1, j = a; i <= b; i ++, j -- )
    {
        res = (LL)res * j % p;
        res = (LL)res * qmi(i, p - 2) % p;
    }
    return res;
}


int lucas(LL a, LL b)
{
    if (a < p && b < p) return C(a, b);
    return (LL)C(a % p, b % p) * lucas(a / p, b / p) % p;
}

分解質因數法求組合數 —— 模板題 AcWing 888. 求組合數 IV

當我們需要求出組合數的真實值，而非對某個數的餘數時，分解質因數的方式比較好用：
    1. 篩法求出範圍內的所有質數
    2. 通過 C(a, b) = a! / b! / (a - b)! 這個公式求出每個質因子的次數。 n! 中p的次數是 n / p + n / p^2 + n / p^3 + ...
    3. 用高精度乘法將所有質因子相乘

int primes[N], cnt;     // 存儲所有質數
int sum[N];     // 存儲每個質數的次數
bool st[N];     // 存儲每個數是否已被篩掉


void get_primes(int n)      // 線性篩法求素數
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}


int get(int n, int p)       // 求n！中的次數
{
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
}


vector<int> mul(vector<int> a, int b)       // 高精度乘低精度模板
{
    vector<int> c;
    int t = 0;
    for (int i = 0; i < a.size(); i ++ )
    {
        t += a[i] * b;
        c.push_back(t % 10);
        t /= 10;
    }

    while (t)
    {
        c.push_back(t % 10);
        t /= 10;
    }

    return c;
}

get_primes(a);  // 預處理範圍內的所有質數

for (int i = 0; i < cnt; i ++ )     // 求每個質因數的次數
{
    int p = primes[i];
    sum[i] = get(a, p) - get(b, p) - get(a - b, p);
}

vector<int> res;
res.push_back(1);

for (int i = 0; i < cnt; i ++ )     // 用高精度乘法將所有質因子相乘
    for (int j = 0; j < sum[i]; j ++ )
        res = mul(res, primes[i]);

卡特蘭數 —— 模板題 AcWing 889. 滿足條件的01序列

給定n個0和n個1，它們按照某種順序排成長度爲2n的序列，滿足任意前綴中0的個數都不少於1的個數的序列的數量爲： Cat(n) = C(2n, n) / (n + 1)

NIM遊戲 —— 模板題 AcWing 891. Nim遊戲

給定N堆物品，第i堆物品有Ai個。兩名玩家輪流行動，每次可以任選一堆，取走任意多個物品，可把一堆取光，但不能不取。取走最後一件物品者獲勝。兩人都採取最優策略，問先手是否必勝。

我們把這種遊戲稱爲NIM博弈。把遊戲過程中面臨的狀態稱爲局面。整局遊戲第一個行動的稱爲先手，第二個行動的稱爲後手。若在某一局面下無論採取何種行動，都會輸掉遊戲，則稱該局面必敗。
所謂採取最優策略是指，若在某一局面下存在某種行動，使得行動後對面面臨必敗局面，則優先採取該行動。同時，這樣的局面被稱爲必勝。我們討論的博弈問題一般都只考慮理想情況，即兩人均無失誤，都採取最優策略行動時遊戲的結果。
NIM博弈不存在平局，只有先手必勝和先手必敗兩種情況。

定理： NIM博弈先手必勝，當且僅當 A1 ^ A2 ^ … ^ An != 0

公平組合遊戲ICG
若一個遊戲滿足：

由兩名玩家交替行動；
在遊戲進程的任意時刻，可以執行的合法行動與輪到哪名玩家無關；
不能行動的玩家判負；
則稱該遊戲爲一個公平組合遊戲。
NIM博弈屬於公平組合遊戲，但城建的棋類遊戲，比如圍棋，就不是公平組合遊戲。因爲圍棋交戰雙方分別只能落黑子和白子，勝負判定也比較複雜，不滿足條件2和條件3。

有向圖遊戲
給定一個有向無環圖，圖中有一個唯一的起點，在起點上放有一枚棋子。兩名玩家交替地把這枚棋子沿有向邊進行移動，每次可以移動一步，無法移動者判負。該遊戲被稱爲有向圖遊戲。
任何一個公平組合遊戲都可以轉化爲有向圖遊戲。具體方法是，把每個局面看成圖中的一個節點，並且從每個局面向沿着合法行動能夠到達的下一個局面連有向邊。

Mex運算
設S表示一個非負整數集合。定義mex(S)爲求出不屬於集合S的最小非負整數的運算，即：
mex(S) = min{x}, x屬於自然數，且x不屬於S

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(s)。

有向圖遊戲的和 —— 模板題 AcWing 893. 集合-Nim遊戲
設G1, G2, …, Gm 是m個有向圖遊戲。定義有向圖遊戲G，它的行動規則是任選某個有向圖遊戲Gi，並在Gi上行動一步。G被稱爲有向圖遊戲G1, G2, …, Gm的和。
有向圖遊戲的和的SG函數值等於它包含的各個子游戲SG函數值的異或和，即：
SG(G) = SG(G1) ^ SG(G2) ^ … ^ SG(Gm)

定理
有向圖遊戲的某個局面必勝，當且僅當該局面對應節點的SG函數值大於0。
有向圖遊戲的某個局面必敗，當且僅當該局面對應節點的SG函數值等於0。