质数

在大于 1 的整数中，如果只包含 1 和本身这两个约数。就成为质数，或者叫素数
除了能被 1 和它本身整除外，还能被其它数整除的数，叫合数。
质数和合数是针对所有大于 1 的 “自然数” 来定义的（所有小于等于 1 的数都不是质数）。
所有小于等于 1 的整数既不是质数也不是合数。
质数和素数都是同一种性质，只是叫法不同。

试除法判定质数

n= （n/d） * d，所以只要列举 d<=n/d 的情况，列举小的那个 d 的就行
时间复杂度最多就是当 d==n/d，n=d^2，O（sqrt（n））

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

试除法分解质因数

每个正整数都能够以唯一的方式表示成它的质因数的乘积。
- n=p1^a1 * p2^a2 *p3^a3.....pn^an
n 中最多包含一个大于 sqrt（n）的质因子
- （反证法，若 n 可以被分解成两个大于 sqrt（n）的质因数，则这两个质因数相乘的结果大于 n）
能满足判断的 i 一定是质数，如果 i 是合数，那么 x 的最小质因数一定是比 i 最小质因数要大，那 x 就不会被 i 整除。
时间复杂度最快 O（logn）最慢 O（sqrt（n））

先枚举小于 sqrt（n）的质因子
最后如果 x>1，则 x 就是最后一个质因子

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )//1
        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;//2
    cout << endl;
}

朴素筛法求素数

先循环每个数
向后把数的所有倍数都删掉

O(nlog(logn)) int primes[N], cnt; // primes[]存储所有素数 bool st[N]; // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )//1
    {
        if (st[i]) continue;//删过的数不用再考虑
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)//2
            st[j] = true;
    }
}

线性筛法求素数

在 1e7 以上的数会比朴素快一倍
1～n 内的合数 p 只会被其最小质因子筛掉
每一个数都只有一个最小质因子，因此每个数都只会被筛一次，因此线性筛法是线性的。
假设一个数是合数： i，他的最小质因子是： d ，倍数是：g

有一个小于他的质因子的质数为 pj

那么 pj * d * g 的最小质因数就是 pj，
如果 pj==d，那么拿 d*g 再乘上一个比 pj 大的质数的最小质数就是 d 了，所以 break
且 d==pj 的话最小的质数 d 或者是 pj 都一样，所以先标 true 再判断
如果 i 是质数，那么 i 就是 primes 的最后一个数，他也是自己的最小质因数，所以不会越界
如果 i 是合数，那么他的质因子一定在此前的质数数组 primes 的 cnt 个数当中。
i%pj==0
- pj 一定是 i 的最小质因子，pj 一定是 pj*i 的最小质因子
i%pj! =0
- pj 一小于 i 的所有质因子，pj 也一定是 pj*i 的最小质因子

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;//primes[j]一定是最小质因子
        }
    }
}

约数

试除法求所有约数

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

约数个数和约数之和

如果 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)
 p^0 + p^1 + ... + p^c:  while(c--)t=(t*p+1)

欧几里得算法--最大公约数

w 为 a，b 公共约数，则 b/w 为整数，a/w-c*b/w 也为整数，所以 b 和 a mod b 有相同约数，固然有最大公约数
gcd（a，b）=（b，a mod b）=（b ， a- c * b）c=a 整除 b

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

欧拉定理

若 a 与 n 互质则（ a ^ ϕ （n）） =1 （mod n）费马定理：当 n 为质数 a^（p-1）=1 （mod p）

欧拉函数

ϕ（N）为 1～n 中有多少个数与 n 互质
N=p1^a1 + p2^a2 + ... + pk^ak ϕ(N)=N(1-1/p1)(1-1/p2)···(1-1/pk)
容斥原理
1. 从 1～N 中去掉 p1，p2···pk 的所有倍数个数
  - $=N - N/p1 - N/p2 ··· N/pk$
2. 加上所有 pi*pj 的倍数个数
  - $= +N/pi*pj$
3. 减去所有 pipjpk
  - $= -N/pi*pj*pk$
4. 不停 + -
归纳起来的公式就是 $ϕ（N）=N（1-1/p1）（1-1/p2）···（1-1/pk）$

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

筛法求欧拉函数

求 1～n 中每一个数的欧拉函数

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)//（i*pj）和i的质因数相同
            {
                euler[t] = euler[i] * primes[j];//根据欧拉函数，两者只差了一个pj
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

快速幂

二进制
m^k=m^（二进制（k））
4^5=4^( 2^0+2^2) =4^(2^0)*4^(2^2) 求 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;
}

扩展欧几里的算法

裴蜀定理：对于任意正整数 a，b，一定存在非零整数 x，y，使得 ax+by=（a，b）

by+(a-(a/b)*b)x=d
ax+b(y-(a/b)*x)=d
gcd（a，b）表示非负整数 a，b 的最大公约数

// 求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;
}

逆元

前提： gcd（a，p）=1
扩展欧几里得求逆元
- a*x=1(mod p)
- ax+my=1
费马定理
- a*a^(p-2)=a^(p-1)=1(mod p)

中国剩余定理

m1,m2··m3,mk;（两两互质）
M=m1m2m3··*mk
Mi=M/mi;
Mi^-1 为 Mi mod mi 的逆元（费马小定理）
x=(a1M1M1^-1)+(a2M2M2^-1)··(akMkMk^-1)
所以 ak=x mod mk

高斯消元

时间复杂度 n^3 n 个方程，n 个未知数
初等行列变换
1. 把某一行乘以一个非零的数
2. 交换某两行
3. 把某行的若干倍叫到另一行
判断解的个数
1. 如果出现 0！=x 无解
2. 出现 0=0 无穷多个解
3. r=n-1 一组解

枚举每一列，找到系数绝对值最大的一行
将该行换到最上一行
将该行第一个数变成 1
将下面所有行的第 c 列消成 0

// a[N][N]是增广矩阵
const double eps =  1e-6；
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; // 有唯一解
}
//最终结果 xn=a[n-1][n]

组合数

递推法求组合数

1<=b<=a<=2000
c[a][b]=c[a-1][b-1]+c[a-1][b]

// 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;

通过预处理法逆元的方式求组合数

1<=b<=a<=1e5
c[a][b]=a!/[(a-b)!*b!]

首先预处理出所有阶乘取模的余数 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 定理

1<=b<=a<=1e18 1<=p<=1e5
c[a][b]=c[a mod p][b mod p]*c[a/p][b/p] ( mod p)

若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 p)  // 快速幂模板
{
    int res = 1 % p;
    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, int p)  // 通过定理求组合数C(a, b)
{
    if (a < b) return 0;

    LL x = 1, y = 1;  // x是分子，y是分母
    for (int i = a, j = 1; j <= b; i --, j ++ )
    {
        x = (LL)x * i % p;
        y = (LL) y * j % p;
    }

    return x * (LL)qmi(y, p - 2, p) % p;
}

int lucas(LL a, LL b, int 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;
}

分解质因数求组合数

当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：

筛法求出范围内的所有质数
通过 C（a， b） = a！ / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中 p 的次数是 n / p + n / p^2 + n / p^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]);

卡特兰数

给定 n 个 0 和 n 个 1，它们按照某种顺序排成长度为 2n 的序列，满足任意前缀中 0 的个数都不少于 1 的个数的序列的数量为： Cat（n） = C（2n， n） / （n + 1）= C（2n，n）-C（2n，n-1）；
在坐标系，1 位向 y 轴正半轴移动，0 位向 x 轴的正半轴移动
所以序列可以表示从（0，0）到（n，n）的路径，总的方案数是 C（2n，n）；
对于要求 0 要多于 1 可理解为x>=y，所以对于路径，不能有超过x=y这条线；
对于超过这条线的路径，对超过部分关于 x=y 对称，就能到达（n-1，n）点，到达的方案数是 C（2n，n-1）；
所以总的结果是 Cat（n） = C（2n， n） / （n + 1）= C（2n，n）-C（2n，n-1）；

容斥原理

时间复杂 2^m
韦恩图
1-2+3-4+5-...+（-1）^（n-1）n 0 （这里数字表示集合内的元素）
可以用二进制的i 位=1 表示对于集合i的选择，1 有奇数个+上，偶数个-去

博弈论

NIM 游戏

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

我们把这种游戏称为 NIM 博弈。把游戏过程中面临的状态称为局面。整局游戏第一个行动的称为先手，第二个行动的称为后手。若在某一局面下无论采取何种行动，都会输掉游戏 h，则称该局面必败。所谓采取最优策略是指，若在某一局面下存在某种行动，使得行动后对面面临必败局面，则优先采取该行动。同时，这样的局面被称为必胜。我们讨论的博弈问题一般都只考虑理想情况，即两人均无失误，都采取最优策略行动时游戏的结果。 NIM 博弈不存在平局，只有先手必胜和先手必败两种情况。

先手必胜状态：可以走到某一个必败状态
先手必败状态：走不到任何一个必败状态定理： NIM 博弈先手必胜，当且仅当 A1 ^ A2 ^ … ^ An ！= 0（^异或）

证明：

必胜态到必败态当前所有的 A1 ^ A2 ^ … ^ An ！= 0（^异或）时，设异或值为 x x 的二进制最高位 k 为 1，存在一个 Ai 的二进制的 k 位为 1 将 Ai 拿去（Ai-（Ai^x））个石子变成 Ai^x（Ai^x 一定小于 Ai）则：A1 ^ A2 ^ … ^ An ^x== 0；所以必胜可以走到必败态

必败态到必胜态当前所有的 1。 A1 ^ A2 ^ … ^ An == 0（^异或）时，设在 Ai 中拿走 n 个变为 bi 个（bi<ai）如果能够到必败态则：2。 A1 ^ A2 ^ … ^bi^…^ An == 0 则得出 1 和 2 异或得 bi==ai，矛盾所以必败态一定走不到必败态

公平组合游戏 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)})
SG（终点）=0；特别地，整个有向图游戏 G 的 SG 函数值被定义为有向图游戏起点 s 的 SG 函数值，即 SG（G） = SG（s）。

有向图游戏的和

设 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。

算法(cpp) - 数学知识

质数