其他分享
首页 > 其他分享> > 数学知识

数学知识

作者:互联网

相关证明参考数学部分简介 - OI Wiki (oi-wiki.org)

数论

质数

在大于 \(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\) 中每个数的欧拉函数。

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

分三种情况

  1. \(i\) 是质数,\(euler[i] = i - 1\)
  2. \(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)\)
  3. $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. 找到绝对值最大的一行
  2. 将改行换到最上面去
  3. 将改行的第一个数变成 1,此时这一行的方程固定。
  4. 将下面所有行的第 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