数学知识

2022-08-10 21:31:25 作者：互联网

数论

质数

在大于 $1$ 的整数中，只包括 $1$ 和它本身的约数，又称作素数

质数的判定——试除法

$O(\sqrt n)$

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

分解质因数——试除法

从小到大枚举所有 $n$ 的质因数

$n$ 中最多有一个大于 $\sqrt n$ 的质因子（反证法：如果有两个就大于 $n$ 了）

void divide(int n)
{
    for (int i = 2; i <= n / i; i++)
        if (n % i == 0)
        {
            int s = 0;
            while (n % i == 0)
            {
                n /= i;
                s++;
            }
            printf("%d %d\n", i, s);
        }
    if (n > 1)
        printf("%d %d\n", n, 1);
}

筛法

埃氏筛法

$O(nloglog \, n)$

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

线性筛法

把每一个合数用它的质因子筛掉

核心：$n$ 只会被它的最小质因子筛掉

int primes[N], cnt;
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++) // 筛选所有小于 n 的合数
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break; // primes[j] = 一定是 i 的最小质因子
        }
    }
}

if (i % primes[j] == 0) break; 解释
$i$ 就是之前被筛选过了
$primes$ 里面的质数都是从小到大的，$i$ 乘上其他的质数也一定是 $prime[j]$ 的
倍数，他们将在后面被筛，为了保证每次用最小质因子筛选，直接break

约数

试除法求约数

$\because d \, |n \quad \therefore \dfrac{n}{d}|d$ 所以只用枚举到 $\sqrt n$

$O(n)$

vector<int> get_divsors(int n)
{
    vector<int> res;
    for (int i = 1; i <= n / i; i++)
        if (n % i == 0)
        {
            res.push_back(i);
            if (i != n / i) // 出去 i * i = n 的特殊情况
                res.push_back(n / i);
        }
    sort(res.begin(), res.end());
    return res;
}

约数个数

$N = p_1^{\alpha_1} \times p_2^{\alpha_2} \times \dots \times p_n^{\alpha_n}$

约数形为 $d=p_1^{\beta_1} \times p_2^{\beta_2} \times \dots \times p_n^{\beta_n}$

约数个数为：$(\alpha_1 + 1) \times (\alpha_2 + 1) \times \dots \times (\alpha_n + 1)$

约数之和为：$(p_1^0 + p_1^1 + \dots + p_1^{\alpha_1})\times\dots\times(p_n^0 + p_n^1 +\dots+p_n^{\beta_n})$

870. 约数个数 - AcWing题库

#include <iostream>
#include <unordered_map>

using namespace std;

const int mod = 1e9 + 7;

int main()
{
    int n;
    cin >> n;
    unordered_map<int, int> q;
    while (n--)
    {
        int x;
        cin >> x;
        for (int i = 2; i <= x / i; i++)
            if (x % i == 0)
                while (x % i == 0)
                {
                    q[i]++;
                    x /= i;
                }
        if (x > 1)
            q[x]++;
        
    }
    
    long long res = 1;
    
    for (auto it : q)
        res = res * (it.second + 1) % mod;
    cout << res << endl;
    return 0;
}

约数和

    LL res = 1;
    for (auto p : primes)
    {
        LL a = p.first, b = p.second;
        LL t = 1;
        while (b -- ) t = (t * a + 1) % mod;
        res = res * t % mod;
    }

欧几里得算法

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

欧拉函数

$\varphi(n):$ $1$ 到 $n$ 中与 $n$ 互质的数。

$n = p_1^{\alpha_1} \times p_2^{\alpha_2} \times \dots \times p_k^{\alpha_k} $

$\varphi(n) = n\prod_{i=1}^{n}(1 - \dfrac{1}{p_i}) $

证明：

若 $p$ 为质数，$\varphi(p^k) = p^{k} - p^{k-1}$，因为 $p^k$ 除了 $p^{k-1}$ 个 $p$ 的倍数外，其他都与 $p^k$ 互质。

\[\begin{align} \varphi(n) &= \prod_{i = 1}^{k} \varphi(p_i^{k_i}) \\ &= \prod_{i = 1}^{k} p_i^k - p_i^{k-1} \\ &= \prod_{i = 1}^{k} p_i^{k}(1 - \dfrac{1}{p_i}) \\ &= n\prod_{i = 1}^{k} (1 - \dfrac{1}{p_i}) \end{align} \]

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

筛法求欧拉函数

求 $1$ 到 $n$ 中每个数的欧拉函数。

用线性筛选，每个合数都是被最小质因数筛掉。

分三种情况

$i$ 是质数，$euler[i] = i - 1$
$i \bmod p_i = 0$，$p_i$ 是 $i \times p_i$ 的最小质因数，$i$ 包含所有 $i \times p_i$ 的质因数，所以 $\varphi(i*p_i) = p_i \times \varphi(i)$
$i \bmod \neq 0 $，由性质 $\varphi(i * p_i) = \varphi(i) \times \varphi(p_i) = p_i \times \varphi(i)$

int primes[N], cnt, euler[N]; // primes 记录质数，euler记录欧拉函数
bool st[N];

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);
        }
    }
}

欧拉定理

欧拉定理：若 $a$ 与 $n$ 互质，则 $a^{\varphi(n)} \equiv 1 \bmod n)$

费马定理：若 $a$ 与 $n$ 互质，且 $n$ 为质数则 $a^{n-1} \equiv 1 \bmod n$

快速幂

快速求出 $a^k mod \;p$ $O(log \,k)$

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

快速幂求逆元

逆元：$ax \equiv 1 \bmod b$， $x$ 为 $a$ 模 $b$ 的逆元，其中 $p$ 是质数

乘法逆元：要求$\dfrac{a}{b} \bmod m$，可以算 $\dfrac{a}{b} \equiv ax \bmod m$ ，$x$ 就是 $b$ 的乘法逆元。

算法：费马小定理：$a^{p-1} \equiv 1 \bmod p$

得 $x = a^{p-2} \bmod p$

扩展欧几里得算法

求 $ax + by = gcd \, (a, b)$ 的一组解

$b = 0$:

$gcd(a, 0) = a \\ ax + 0y = a \\ x = 1, y = 0$

$b \neq 0:$

$d = ax + by = gcd(b, a \bmod b) $ 每次递归将 $x$ 和 $y$ 变换

$by + (a \bmod b)x = d$ 带入展开

$by + (a - \lfloor \dfrac{a}{b}\rfloor \times b)x = d$ $ax + b(y - \lfloor \dfrac{a}{b}\rfloor x) = d$

比较原式 $x$ 不变，$y = y - \lfloor \dfrac{a}{b} \rfloor x$

int exgcd(int a, int b， int &x, int &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }
    int d = ecgcd(b, a % b, y, x); // 能简化运算
    y -= a / b * x; 
    return d;
}

线性同余方程

$ax \equiv b \bmod m$ 求出 $x$

$ax = ym + b \implies ax - ym = b$

根据扩展欧几里得定理可以得到 $ax + by = gcd(a, b)$ 的一组解，$x$ 的就可以求出来。

#include <iostream>
using namespace std;

typedef long long LL;
int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }
    int t = exgcd(b, a % b, y, x);
    
    y -= a / b * x;
    return t;
}
int main()
{
    int n;
    scanf("%d", &n);
    while (n--)
    {
        int a, b, m, x, y;
        scanf("%d %d %d", &a, &b, &m);
        int t = exgcd(a, m, x, y);
        if (b % t == 0)
            printf("%d\n", (LL) b / t * x % m);
        else
            puts("impossible");
    }
    return 0;
}

中国剩余定理

高斯消元

枚举每一列 c

找到绝对值最大的一行
将改行换到最上面去
将改行的第一个数变成 1，此时这一行的方程固定。
将下面所有行的第 c 列消成 0

枚举之后倒着求解

883. 高斯消元解线性方程组 - AcWing题库

#include <iostream>
#include <cmath>

using namespace std;

const int N = 110;

double a[N][N];
int n;
double eps = 1e-8; // 判断是否为 0 
void out()
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= n; j++)
            printf("%10.2lf", a[i][j]);
        puts("");
    }
    puts("");
}
int gauss()
{
    int r, c;
    for (r = 0, c = 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]);
        // 将改行第一个数字变成 1 
        for (int i = n; i >= c; i--) 
            a[r][i] /= a[r][c];
        // 将改行下面第 c 列都变成 0 
        for (int i = r + 1; i < n; i++)
            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;
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= n; j++)
            cin >> a[i][j];
    int t = gauss();
    if (t == 0)
        for (int i = 0; i < n; i++) 
        {
            if (fabs(a[i][n]) < eps)
                a[i][n] = 0;
            printf("%.2lf\n", a[i][n]);

        }
    else if (t == 1)
        puts("Infinite group solutions");
    else
        puts("No solution");
    return 0;
}

组合数学

$C_n^m = \dfrac{n!}{m!(n-m)!}$

$C_n^m = C_{n-1}^{m} + C_{n-1}^{m-1}$

卢卡斯定理：

$C_n^m \equiv C_{n \, \bmod \, p}^{m \, \bmod \, p} \cdot C_{n\div p}^{m \div p} \bmod p$

求组合数 $C_n^m$ 的常用方法。

求的组数	$n,m$ 范围	方法	时间复杂度
100000	$1 \leq m \leq n \leq 2000$	递推	$O(n^2)$
10000	$1 \leq m \leq n \leq 100000$	预处理	$O(nlogn)$
10000	$1 \leq m \leq n \leq 10^{18}$	卢卡斯定理
1	$ 1 \leq m \leq n \leq 5000$ 且不取模	高精度

递推

int c[N][N];

void init()
{
    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;
}

预处理

#include <iostream>
using namespace std;

typedef long long LL;
const int N = 100010, mod = 1e9 + 7;

int fact[N], infact[N];

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

int main()
{
    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;
    }
    int n;
    cin >> n;
    while (n--)
    {
        int a, b;
        scanf("%d %d", &a, &b);
        printf("%d\n", (LL) fact[a] * infact[b] % mod * infact[a - b] % mod);
    }
    return 0;
}

卢卡斯定理

#include <iostream>
using namespace std;

typedef long long LL;

int qmi(int a, int k, int p)
{
    int res = 1;
    while (k)
    {
        if (k & 1)
            res = (LL) res * a % p;
        k >>= 1;
        a = (LL)a * a % p;
    }
    return res;
}
int C(int a, int b, int p)
{
    if (b > a)
        return 0;
    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) % p;
    }
    return res;
}

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

int main()
{
    int n;
    cin >> n;
    while (n--)
    {
        LL a, b, p;
        cin >> a >> b >> p;
        cout << lucas(a, b, p) << endl;
    }
    return 0;
}

分解质因数法求组合数

任意一个大于 1 的正整数可以分解为 $n = p_1^{\alpha_1}p_2^{\alpha_2} \cdots p_k^{\alpha_k}$ 的的形式，$p$ 都为质因子。

$C_a^b = \dfrac{a!}{b!(a-b)!}$，$a!$ 对 $p$ 分解得到的质因数个数为 $\lfloor \dfrac{a}{p}\rfloor + \lfloor \dfrac{a}{p^2}\rfloor + \cdots \lfloor \dfrac{a}{p^k}\rfloor$ ，因此

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

const int N = 5010;

int primes[N], cnt, 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)
{
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
}

vector<int> mul(vector<int> &a, int b)
{
    vector<int> res;
    int t = 0;
    for (int i = 0; i < a.size(); i++)
    {
        t += a[i] * b;
        res.push_back(t % 10);
        t /= 10;
    }

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

}

int main()
{
    int a, b;
    cin >> a >> b;

    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]);

    for (int i = res.size() - 1 ; i >= 0; i--)
        printf("%d", res[i]);

    return 0;
}

卡特兰数

给定 n 个 0 和 n 个 1，它们按照某种顺序排成长度为 2n 的序列，满足任意前缀中 0 的个数都不少于 1 的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)

$H_n = C_{2n}^{n} - C_{2n-1}^{n-1} = \dfrac{C_{2n}^{n}}{n+1}(n \geq 2,n \in N_+)$

容斥原理

容斥原理 - OI Wiki (oi-wiki.org)

\[\begin{aligned} \bigcup_1^{m} S_i &= S_1 + S_2 + \cdots S_i - (S_1 \cap S_2 + S_1 \cap S_3 + \cdots + S_{m-1} \cap S_m) + S_1 \cap S_2 \cap S_3 + \cdots \\ &= \sum_1^{m}(-1)^{m-1} \sum_{a_i < a_{i + 1}} \bigcap_{i = 1}{m}S_{a_i} \end{aligned} \]

890. 能被整除的数 - AcWing题库

$p$ 为质数集，记能被 $p_i$ 整除的数的集合为 $S_i$，要求 $n$ 中能被任意一个 $p_j$ 整除的数的个数，即求解所有集合的交集。

集合总数为 $2^{m-1}$, 枚举每个集合，用二进制来表示集合的状态。例如枚举到 $11$ 时，二进制表示 $(1011)_2$ 就可以表示为选中 $S_1,S_2, S_4$ 这个集合，集合个数为 $3$ 为奇数，交集元素总数为 $\dfrac{n}{p_1p_2p_4}$。

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;
const int N = 20;;

int p[N];
int n, m;

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) scanf("%d", &p[i]);
    
    int res = 0;
    for (int i = 1; i < 1 << m; i++)
    {
        int t = 0, cnt = 0;
        for (int j = 0; j < m; j++)
        {
            if (i >> j & 1)
            {
                if ((LL)p[j] * t > n)
                {
                    t = -1;
                    break;
                }
                t *= p[j];
                cnt++;
            }
        }
        if (t == -1)
            continue;
        if (cnt % 2)
            res += n / t;
        else
            res -= n / t;
    }
    cout << res << endl;
    
    return 0;
}

简单博弈论

NIM游戏

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

我们把这种游戏称为 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$ 条有向边，分别到达节点 $y_1, y_2, \cdots, y_k$ ，定义 $SG(x)$ 为 $x$ 的后继节点 $y_1, y_2, \cdots, y_k $的 $SG$函数值构成的集合再执行 $mex(S)$运算的结果，即：
$SG(x) = mex({SG(y_1), SG(y_2), …, SG(y_k)})$
特别地，整个有向图游戏G的SG函数值被定义为有向图游戏起点 $s$ 的 $SG$ 函数值，即 $SG(G) = SG(s)$。

有向图游戏的和 —— 集合-Nim游戏设 $G_1, G_2, …, G_m $是 $m$ 个有向图游戏。定义有向图游戏 $G$ ，它的行动规则是任选某个有向图游戏$G_i$，并在 $G_i$ 上行动一步。$G$ 被称为有向图游戏 $G_1, G_2, …, G_m$ 的和。
有向图游戏的和的SG函数值等于它包含的各个子游戏 $SG$函数值的异或和，即：
$SG(G) = SG(G_1) \oplus SG(G_2) \oplus \cdots \oplus SG(G_m)$（$\oplus$ 表示异或）

定理

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

参考

作者：yxc
链接：https://www.acwing.com/blog/content/406/
来源：AcWing

标签：return,int,res,LL,times,数学知识,SG
来源： https://www.cnblogs.com/zhi-qiu/p/16573955.html

求的组数	\(n,m\) 范围	方法	时间复杂度
100000	\(1 \leq m \leq n \leq 2000\)	递推	\(O(n^2)\)
10000	\(1 \leq m \leq n \leq 100000\)	预处理	\(O(nlogn)\)
10000	\(1 \leq m \leq n \leq 10^{18}\)	卢卡斯定理
1	$ 1 \leq m \leq n \leq 5000$ 且不取模	高精度