标签：return int res LL times 数学知识 SG

相关证明参考数学部分简介 - 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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。