快速幂
思想:反复平方法
求 a^k mod p,时间复杂度 O(logk)。
int qmi(int a, int k, int p)
{
int res = 1 % p, t = a;
while (k)
{
if (k&1) res = (long long)res * t % p; //防止数值太大越界
t = (long long)t * t % p;
k >>= 1;
}
return res;
}
扩展欧几里得定理
裴蜀定理: 有一对正整数a,b,那么一定存在非零整数x,y,使得ax+by=最大公约数(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;
}
高斯消元法
// a[N][N]是增广矩阵
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; // 有唯一解
}
求组合数
递推方法
10w组询问 0<a,b<2000 用递推的方法 O(n^2)
// 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;
用预处理的方法 O(NlogN)
1w 组询问 1<b<a<10^5
首先预处理出所有阶乘取模的余数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定理
20 组询问 1<b<a<10^18
lucas定理 o(plognlogp)
若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 res = 1;
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) // 通过定理求组合数C(a, b)
{
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;
}
return res;
}
int lucas(LL a, LL b)
{
if (a < p && b < p) return C(a, b);
return (LL)C(a % p, b % p) * lucas(a / p, b / 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;
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)
容斥原理
同上面的公式一样:
-------------------------容斥原理----------------------------
|假如我们要去除1-n中 p1,p2,p3,p4,p5....的倍数 |
|那么有多少个呢?N-N/p1-N/p2-N/p3....N/pk;这里面有多去的部分|
|加上所有pi*pj的倍数 +N/(Pi*pj)+... |
|减去所有pi*pj*pk的倍数 |
-------------------------------------------------------------
我们现在只是分析一下这个复杂度,首先就是有多少中可能
S1 U S2 U S3 =(S1+S2+S3)-S1∩S2-S2∩S3-S1∩S3+S1∩S2∩S3
也就是S1、S2、S3中选1个,选2个,选3个组合在一起,也就是在3个中选择任意多个的可能性组合
那么再抽象就是S1 S2 S3分别选和不选 也就是2^n-1 种选择的可能性;
那么一般可以用移位操作来表示选和不选:1-(2^3-1) 也就是 001+010+100-011-101-110+111 这几种选择
我们就以通过"位"来表示这几种容斥的情况,其中我们在操作的时候还要记下1个数,1为奇数为+,1为偶数则为-;
------
Nim游戏
简单的Nim游戏就是看我们的选择的情况为任意多个还是限定的个
如果是任意多个那么其实我们的sg(n)=n;
所以我们的sg(n1)^sg(n2)^sg(n3)^sg(n4)^sg(n5)^sg(n6)=n1^n2^n3^n4^n5^n6;
那么结论就是:sg(n1)^sg(n2)^sg(n3)^sg(n4)^sg(n5)^sg(n6)>0 先手的那么我们就必赢
sg(n1)^sg(n2)^sg(n3)^sg(n4)^sg(n5)^sg(n6)=0 先手的那么我们就必输
那么结果是怎样证明的呢?
我们直接用n1^n2^n3^n4^n5^n6操作而不用sg(),实际上我们应该用sg来操作;
假设:n1^n2^n3^n4^n5^n6=x 为必胜态,那么先手的我就一定能转换成必输态
x的最高位有一个1,假设我们是n6赋予他的;那么n6^x<x;
所以我们就可以把n6改变成n6^x;(变成比自己小的没有问题吧)因为我们sg(n)代表的就是最小的一个不在可能集合里面的数;
那么n1^n2^n3^n4^n5^n6^x=x^x=0; 那么就转换成为必输态;
相同必输态只要操作,就会变为必赢态。