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;
}
试除法分解质因数 O(sqrt(n))
void divide(int x) {
for(int i = 2; i <= x / i; i ++) {
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;
puts("");
}
朴素筛法求质数
预处理1 ~ n 时间复杂度O(nlogn),每一次查询的时间复杂度是O(1)
int primes[N], cnt;
bool st[N];
void get_primes(int n) {
for(int i = 2; i <= n; i ++) {
primes[cnt ++] = i;
for(int j = i; j <= n; j += i) {
st[j] = true;
}
}
}
埃氏筛法求质数
预处理1 ~ n 时间复杂度O(nloglogn),近似O(n),每一次查询的时间复杂度是O(1)
int primes[N], cnt;
bool st[N];
void get_primes(int n) {
for(int i = 2; i <= n; i ++) {
if(st[i]) continue;
primes[cnt ++] = i;
for(int j = i; j <= n; j += i) {
st[j] = true;
}
}
}
线性筛法求质数
预处理1 ~ n 时间复杂度O(n),每一次查询的时间复杂度是O(1)
n只会被最小质因子筛掉
int primes[N], cnt;//primes存储已经发现的素数，处理到i时，把小于等于i的数都扔到数组里
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;//加上会变成线性的神奇优化
}
}
}
2. 约数
试除法求所有约数
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)
- 约数个数
给定 n个正整数 ai，请你输出这些数的乘积的约数个数，答案对 10^9+7 取模。
输入格式
第一行包含整数 n。
接下来 n行，每行包含一个整数 ai。
输出格式
输出一个整数，表示所给正整数的乘积的约数个数，答案需对 10^9+7 取模。
//分别分解每个因数的质因子，再把它们乘起来
const int mod = 1e9 + 7;
int main() {
int n;
cin >> n;
unordered_map<int, int> primes; //哈希表存储所有底数和指数
while(n --) {
int x;
cin >> x;
for(int i = 2; i <= x / i; i ++)
while(x % i == 0) {
x /= i;
primes[i] ++;//i的质因数的质数加一
}
if(x > 1) primes[x] ++;
}
ll res = 1;
for(auto prime : primes) res = res * (prime.second + 1) % mod;
cout << res << endl;
return 0;
}
- 最大公约数和最小公倍数
int gcd(int a,int b) {
return b?gcd(b,a%b):a;
}
int lcm(int a,int b) {
return a/gcd(a,b)*b;
}
3. 欧拉函数
- 欧拉函数
int main() {
int n;
cin >> n;
while(n --) {
int a;
cin >> a;
int res = a;
for(int i = 2; i<= a / i; i ++) {
if(a % i == 0) { //i是a的质因子
res = res / i * (i - 1);//等价res = res * (1 - 1 / i) 替换原因：不能有小数
while(a % i == 0) a /= i;
}
}
if(a > 1) res = res / a * (a - 1);
cout << res << endl;
}
return 0;
}
- 筛法求欧拉函数
给定一个正整数 n，求 1∼n 中每个数的欧拉函数之和。
输入格式
共一行，包含一个整数 n。
输出格式
共一行，包含一个整数，表示 1∼n中每个数的欧拉函数之和。
int primes[N], cnt;
int phi[N];
bool st[N];
LL get_eulers(int n) {
phi[1] = 1;
for(int i = 2; i <= n; i ++) {
if(!st[i]) { //当前数没用被筛过，此数为质数
primes[cnt ++] = i;
phi[i] = i - 1;//质数1~i-1所有数都互质
}
for(int j = 0; primes[j] <= n / i; j ++) {
st[primes[j] * i] = true;
if(i % primes[j] == 0) {
phi[primes[j] * i] = phi[i] * primes[j] ;
break;
}
phi[primes[j] * i] = phi[i] * (primes[j] - 1);
}
}
LL res = 0;
for(int i = 1; i <= n; i ++) res += phi[i];
return res;
}
int main()
{
int n;
cin >> n;
cout << get_eulers(n) << endl;
return 0;
}
4. 快速幂
每一次询问的时间复杂度`O(logn)
作用：以log的速度求出某个数的n次方
原理：2 ^ 18 -> 4 ^ 8 * 4 -> 16 ^ 4 * 4 -> 256 ^ 2 * 4
LL qmi(LL m, int k, int p) {
LL res = 1;
while (k) {
if (k & 1) {
res = res * m % p;
}
m = m * m % p;
k >>= 1;
}
return res;
}
-
快速幂求逆元
int qmi(LL a, int b, int p) {
int res = 1;
while (b) {
if (b & 1) res = res * a % p;
b >>= 1;
a = a * a % p;
}
return res;
}
int main() {
int T;
cin >> T;
while (T -- ) {
int a, p;
cin >> a >> p;
int res = qmi(a, p - 2, p);
if (a % p) cout << res << endl;
else cout << "impossible" << endl;
}
return 0;
}
其他情况
当a和mod固定，b的范围不大(<le7),可以预处理a的所有次方，预处理的时间复杂度O(n),每一次询问O(1)
- a^b
求 a 的 b 次方对 p 取模的值。
输入格式
三个整数 a,b,p,在同一行用空格隔开。
输出格式
输出一个整数，表示a^b mod p的值。
LL qmi(LL a, LL b, LL p) {
LL res = 1 % p;
while (b) {
if (b & 1) res = res * a % p;
b >>= 1;
a = a * a % p;
}
return res;
}
int main() {
LL a, b, p;
cin >> a >> b >> p;
cout << qmi(a, b, p) << endl;
return 0;
}
5. 拓展欧几里得算法
- 扩展欧几里得算法
给定 n 对正整数 ai,bi，对于每对数，求出一组 xi,yi，使其满足 ai×xi+bi×yi=gcd(ai,bi))。
输入格式
第一行包含整数 n。
接下来 n 行，每行包含两个整数 ai,bi。
输出格式
输出共 n 行，对于每组 ai,bi，求出一组满足条件的 xi,yi，每组结果占一行。
本题答案不唯一，输出任意满足条件的 xi,yi 均可。
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;
}
int main() {
int n;
cin >> n;
while (n -- ) {
int a, b;
cin >> a >> b;
int x, y;
exgcd(a, b, x, y);
cout << x << " " << y << endl;
}
return 0;
}
- 线性同余方程
给定 n组数据 ai,bi,mi，对于每组数求出一个 xi，使其满足 ai*xi≡bi(modmi)，如果无解则输出 impossible。
输入格式
第一行包含整数 n。
接下来 n行，每行包含一组数据 ai,bi,mi。
输出格式
输出共 n行，每组数据输出一个整数表示一个满足条件的 xi，如果无解则输出 impossible。
每组数据结果占一行，结果可能不唯一，输出任意一个满足条件的结果均可。
输出答案必须在 int 范围之内。
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;
}
void solve() {
int a, b, m, x, y;
cin >> a >> b >> m;
int d = exgcd(a, m, x, y);
if (b % d) {
puts("impossible");
} else {
cout << (LL)b / d * x % m << endl;
}
}
int main() {
int t;
cin >> t;
while (t -- ) {
solve();
}
return 0;
}
6. 中国剩余定理
- 表达整数的奇怪方式
给定 2n 个整数 a1,a2,…,an和 m1,m2,…,mn，求一个最小的非负整数 x，满足 ∀i∈[1,n],x≡mi(mod ai)。
输入格式
第 11 行包含整数 n。
第 2…n+1 行：每 i+1 行包含两个整数 ai 和 mi，数之间用空格隔开。
输出格式
输出最小非负整数 x，如果 x 不存在，则输出 −1−1。
如果存在 x，则数据保证 x 一定在 64 位整数范围内。
LL exgcd(LL a, LL b, LL &x, LL &y) {
if (!b) {
x = 1, y = 0;
return a;
}
LL d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int main() {
int n;
cin >> n;
bool flag = false;
LL a1, m1;
cin >> a1 >> m1;
for (int i = 0; i < n - 1; i ++ ) {
LL a2, m2;
cin >> a2 >> m2;
LL k1, k2;
LL d = exgcd(a1, a2, k1, k2);
if ((m2 - m1) % d) {
flag = true;
break;
}
k1 *= (m2 - m1) / d;
LL t = a2 / d;
k1 = (k1 % t + t) % t;
m1 = a1 * k1 + m1;
a1 = abs(a1 / d * a2);
}
if (!flag) {
cout << (m1 % a1 + a1) % a1 << endl;
} else {
cout << -1 << endl;
}
return 0;
}
7. 求组合数
递推法求组合数
// 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;
通过预处理逆元的方式求组合数
首先预处理出所有阶乘取模的余数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定理
若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;
}
分解质因数法求组合数
当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
1. 筛法求出范围内的所有质数
2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + ...
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)
- 满足条件的01序列
给定 n 个 0 和 n个 1，它们将按照某种顺序排成长度为 2n 的序列，求它们能排列成的所有序列中，能够满足任意前缀序列中 0 的个数都不少于 1 的个数的序列有多少个。
输出的答案对 10^9+7 取模。
输入格式
共一行，包含整数 n。
输出格式
共一行，包含一个整数，表示答案。
LL qmi(LL a, int b, int p) {
LL res = 1;
while (b) {
if (b & 1) {
res = res * a % p;
}
a = a * a % p;
b >>= 1;
}
return res;
}
void solve() {
int n;
cin >> n;
int a = 2 * n, b = n;
LL res = 1;
for (int i = a; i > a - b; i -- ) {
res = res * i % mod;
}
for (int i = 1; i <= b; i ++ ) {
res = res * qmi(i, mod - 2, mod) % mod;
}
res = res * qmi(n + 1, mod - 2, mod) % mod;
cout << res << endl;
}
int main() {
int t = 1;
// cin >> t;
while (t -- ) {
solve();
}
return 0;
}
8. 容斥原理
- 能被整除的数
给定一个整数 n 和 m 个不同的质数 p1,p2,…,pm。
请你求出 1∼n中能被 p1,p2,…,pm中的至少一个数整除的整数有多少个。
输入格式
第一行包含整数 n和 m。
第二行包含 m 个质数。
输出格式
输出一个整数，表示满足条件的整数的个数。
int main() {
cin >> n >> m;
for (int i = 0; i < m; i ++ ) {
cin >> p[i];
}
int res = 0;
for (int i = 1; i < 1 << m; i ++ ) {
int t = 1, cnt = 0; // t表示当前所有质数的乘积,cnt表示当前选法有几个集合
for (int j = 0; j < m; j ++ ) {
if (i >> j & 1) {
cnt ++ ;
if ((LL)t * p[j] > n) {
t = -1;
break;
}
t *= p[j];
}
}
if (t != -1) {
if (cnt % 2) {
res += n / t;
} else {
res -= n / t;
}
}
}
cout << res << endl;
return 0;
}
9. 博弈论
NIM游戏
给定N堆物品，第i堆物品有Ai个。两名玩家轮流行动，每次可以任选一堆，取走任意多个物品，可把一堆取光，但不能不取。取走最后一件物品者获胜。两人都采取最优策略，问先手是否必胜。
我们把这种游戏称为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条有向边，分别到达节点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)。
有向图游戏的和
设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。
1159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
