试除法判定质数

  1. bool is_prime(int x)
  2. {
  3.     if (x < 2) return false;
  4.     for (int i = 2; i <= x / i; i ++ )
  5.         if (x % i == 0)
  6.             return false;
  7.     return true;
  8. }

试除法分解质因数

  1. void divide(int x)
  2. {
  3.     for (int i = 2; i <= x / i; i ++ )
  4.         if (x % i == 0)
  5.         {
  6.             int s = 0;
  7.             while (x % i == 0) x /= i, s ++ ;
  8.             cout << i << ' ' << s << endl;
  9.         }
  10.     if (x > 1) cout << x << ' ' << 1 << endl;
  11.     cout << endl;
  12. }

朴素筛法求素数

  1. int primes[N], cnt;     // primes[]存储所有素数
  2. bool st[N];         // st[x]存储x是否被筛掉
  4. void get_primes(int n)
  5. {
  6.     for (int i = 2; i <= n; i ++ )
  7.     {
  8.         if (st[i]) continue;
  9.         primes[cnt ++ ] = i;
  10.         for (int j = i + i; j <= n; j += i)
  11.             st[j] = true;
  12.     }
  13. }

线性筛法求素数

  1. int primes[N], cnt;     // primes[]存储所有素数
  2. bool st[N];         // st[x]存储x是否被筛掉
  4. void get_primes(int n)
  5. {
  6.     for (int i = 2; i <= n; i ++ )
  7.     {
  8.         if (!st[i]) primes[cnt ++ ] = i;
  9.         for (int j = 0; primes[j] <= n / i; j ++ )
  10.         {
  11.             st[primes[j] * i] = true;
  12.             if (i % primes[j] == 0) break;
  13.         }
  14.     }
  15. }

试除法求所有约数

  1. vector<int> get_divisors(int x)
  2. {
  3.     vector<int> res;
  4.     for (int i = 1; i <= x / i; i ++ )
  5.         if (x % i == 0)
  6.         {
  7.             res.push_back(i);
  8.             if (i != x / i) res.push_back(x / i);
  9.         }
  10.     sort(res.begin(), res.end());
  11.     return res;
  12. }

约数个数和约数之和

  1. 如果 N = p1^c1 * p2^c2 * ... *pk^ck
  2. 约数个数： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
  3. 约数之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)

欧几里得算法

  1. int gcd(int a, int b)
  2. {
  3.     return b ? gcd(b, a % b) : a;
  4. }

求欧拉函数

  1. int phi(int x)
  2. {
  3.     int res = x;
  4.     for (int i = 2; i <= x / i; i ++ )
  5.         if (x % i == 0)
  6.         {
  7.             res = res / i * (i - 1);
  8.             while (x % i == 0) x /= i;
  9.         }
  10.     if (x > 1) res = res / x * (x - 1);
  12.     return res;
  13. }

筛法求欧拉函数

  1. int primes[N], cnt;     // primes[]存储所有素数
  2. int euler[N];           // 存储每个数的欧拉函数
  3. bool st[N];         // st[x]存储x是否被筛掉
  6. void get_eulers(int n)
  7. {
  8.     euler[1] = 1;
  9.     for (int i = 2; i <= n; i ++ )
  10.     {
  11.         if (!st[i])
  12.         {
  13.             primes[cnt ++ ] = i;
  14.             euler[i] = i - 1;
  15.         }
  16.         for (int j = 0; primes[j] <= n / i; j ++ )
  17.         {
  18.             int t = primes[j] * i;
  19.             st[t] = true;
  20.             if (i % primes[j] == 0)
  21.             {
  22.                 euler[t] = euler[i] * primes[j];
  23.                 break;
  24.             }
  25.             euler[t] = euler[i] * (primes[j] - 1);
  26.         }
  27.     }
  28. }

快速幂

  1. 求 m^k mod p，时间复杂度 O(logk)。
  3. int qmi(int m, int k, int p)
  4. {
  5.     int res = 1 % p, t = m;
  6.     while (k)
  7.     {
  8.         if (k&1) res = res * t % p;
  9.         t = t * t % p;
  10.         k >>= 1;
  11.     }
  12.     return res;
  13. }

扩展欧几里得算法

  1. // 求x, y，使得ax + by = gcd(a, b)
  2. int exgcd(int a, int b, int &x, int &y)
  3. {
  4.     if (!b)
  5.     {
  6.         x = 1; y = 0;
  7.         return a;
  8.     }
  9.     int d = exgcd(b, a % b, y, x);
  10.     y -= (a/b) * x;
  11.     return d;
  12. }

高斯消元

  1. // a[N][N]是增广矩阵
  2. int gauss()
  3. {
  4.     int c, r;
  5.     for (c = 0, r = 0; c < n; c ++ )
  6.     {
  7.         int t = r;
  8.         for (int i = r; i < n; i ++ )   // 找到绝对值最大的行
  9.             if (fabs(a[i][c]) > fabs(a[t][c]))
  10.                 t = i;
  12.         if (fabs(a[t][c]) < eps) continue;
  14.         for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 将绝对值最大的行换到最顶端
  15.         for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 将当前行的首位变成1
  16.         for (int i = r + 1; i < n; i ++ )       // 用当前行将下面所有的列消成0
  17.             if (fabs(a[i][c]) > eps)
  18.                 for (int j = n; j >= c; j -- )
  19.                     a[i][j] -= a[r][j] * a[i][c];
  21.         r ++ ;
  22.     }
  24.     if (r < n)
  25.     {
  26.         for (int i = r; i < n; i ++ )
  27.             if (fabs(a[i][n]) > eps)
  28.                 return 2; // 无解
  29.         return 1; // 有无穷多组解
  30.     }
  32.     for (int i = n - 1; i >= 0; i -- )
  33.         for (int j = i + 1; j < n; j ++ )
  34.             a[i][n] -= a[i][j] * a[j][n];
  36.     return 0; // 有唯一解
  37. }

递推法求组合数

  1. // c[a][b] 表示从a个苹果中选b个的方案数
  2. for (int i = 0; i < N; i ++ )
  3.     for (int j = 0; j <= i; j ++ )
  4.         if (!j) c[i][j] = 1;
  5.         else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

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

  1. 首先预处理出所有阶乘取模的余数fact[N]，以及所有阶乘取模的逆元infact[N]
  2. 如果取模的数是质数，可以用费马小定理求逆元
  3. int qmi(int a, int k, int p)    // 快速幂模板
  4. {
  5.     int res = 1;
  6.     while (k)
  7.     {
  8.         if (k & 1) res = (LL)res * a % p;
  9.         a = (LL)a * a % p;
  10.         k >>= 1;
  11.     }
  12.     return res;
  13. }
  15. // 预处理阶乘的余数和阶乘逆元的余数
  16. fact[0] = infact[0] = 1;
  17. for (int i = 1; i < N; i ++ )
  18. {
  19.     fact[i] = (LL)fact[i - 1] * i % mod;
  20.     infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
  21. }

Lucas定理

  1. 若p是质数，则对于任意整数 1 <= m <= n，有：
  2.     C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)
  4. int qmi(int a, int k, int p)  // 快速幂模板
  5. {
  6.     int res = 1 % p;
  7.     while (k)
  8.     {
  9.         if (k & 1) res = (LL)res * a % p;
  10.         a = (LL)a * a % p;
  11.         k >>= 1;
  12.     }
  13.     return res;
  14. }
  16. int C(int a, int b, int p)  // 通过定理求组合数C(a, b)
  17. {
  18.     if (a < b) return 0;
  20.     LL x = 1, y = 1;  // x是分子，y是分母
  21.     for (int i = a, j = 1; j <= b; i --, j ++ )
  22.     {
  23.         x = (LL)x * i % p;
  24.         y = (LL) y * j % p;
  25.     }
  27.     return x * (LL)qmi(y, p - 2, p) % p;
  28. }
  30. int lucas(LL a, LL b, int p)
  31. {
  32.     if (a < p && b < p) return C(a, b, p);
  33.     return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
  34. }

分解质因数法求组合数

  1. 当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
  2.     1. 筛法求出范围内的所有质数
  3.     2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + ...
  4.     3. 用高精度乘法将所有质因子相乘
  6. int primes[N], cnt;     // 存储所有质数
  7. int sum[N];     // 存储每个质数的次数
  8. bool st[N];     // 存储每个数是否已被筛掉
  11. void get_primes(int n)      // 线性筛法求素数
  12. {
  13.     for (int i = 2; i <= n; i ++ )
  14.     {
  15.         if (!st[i]) primes[cnt ++ ] = i;
  16.         for (int j = 0; primes[j] <= n / i; j ++ )
  17.         {
  18.             st[primes[j] * i] = true;
  19.             if (i % primes[j] == 0) break;
  20.         }
  21.     }
  22. }
  25. int get(int n, int p)       // 求n！中的次数
  26. {
  27.     int res = 0;
  28.     while (n)
  29.     {
  30.         res += n / p;
  31.         n /= p;
  32.     }
  33.     return res;
  34. }
  37. vector<int> mul(vector<int> a, int b)       // 高精度乘低精度模板
  38. {
  39.     vector<int> c;
  40.     int t = 0;
  41.     for (int i = 0; i < a.size(); i ++ )
  42.     {
  43.         t += a[i] * b;
  44.         c.push_back(t % 10);
  45.         t /= 10;
  46.     }
  48.     while (t)
  49.     {
  50.         c.push_back(t % 10);
  51.         t /= 10;
  52.     }
  54.     return c;
  55. }
  57. get_primes(a);  // 预处理范围内的所有质数
  59. for (int i = 0; i < cnt; i ++ )     // 求每个质因数的次数
  60. {
  61.     int p = primes[i];
  62.     sum[i] = get(a, p) - get(b, p) - get(a - b, p);
  63. }
  65. vector<int> res;
  66. res.push_back(1);
  68. for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
  69.     for (int j = 0; j < sum[i]; j ++ )
  70.         res = mul(res, primes[i]);

卡特兰数

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

NIM游戏

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

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

公平组合游戏ICG

:::tips 若一个游戏满足：

由两名玩家交替行动；
在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关；
不能行动的玩家判负；
则称该游戏为一个公平组合游戏。
NIM博弈属于公平组合游戏，但城建的棋类游戏，比如围棋，就不是公平组合游戏。因为围棋交战双方分别只能落黑子和白子，胜负判定也比较复杂，不满足条件2和条件3。 :::

有向图游戏

:::tips 给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。
任何一个公平组合游戏都可以转化为有向图游戏。具体方法是，把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。 :::

Mex运算

:::tips 设S表示一个非负整数集合。定义mex(S)为求出不属于集合S的最小非负整数的运算，即：
mex(S) = min{x}, x属于自然数，且x不属于S :::

SG函数

:::tips 在有向图游戏中，对于每个节点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)。 :::

有向图游戏的和

:::tips 设G1, G2, …, Gm 是m个有向图游戏。定义有向图游戏G，它的行动规则是任选某个有向图游戏Gi，并在Gi上行动一步。G被称为有向图游戏G1, G2, …, Gm的和。
有向图游戏的和的SG函数值等于它包含的各个子游戏SG函数值的异或和，即：
SG(G) = SG(G1) ^ SG(G2) ^ … ^ SG(Gm) :::

定理

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