乘法逆元
对于缩系中的元素,每个数a均有唯一的与之对应的乘法逆元x,使得
在一般数学中,我们所说的逆元就是倒数,但是在数论中,如果一个数字a存在一个对p的逆元x,就可以写成
逆元的含义:模n意义下,1个数a如果有逆元x,那么除以a相当于乘以x。
满足
当我们要求
证明
根据
把k带入
所以原式等于:
拓展欧几里得
拓展欧几里得:
当我们要求
我们可以展开一下变成
我们用拓展欧几里得求出一个最小的x就是
这个方程可以转化为
求解:
现在我们已经有了
根据欧几里得算法我们可以知道
而且我们可以看出
由此我们可得:(由于两边
我们想要把式子简化一下,可以从
所以我们可以化简得到
移项:
系数相等,所以我们可以解得
根据欧几里得算法,我们一直递归下去,总会到
所以式子变成了
此时解出来的
PS:算法效率较高,常数较小,时间复杂度
void exgcd(LL a, LL b, LL &x, LL &y) {
if (b == 0) {
x = 1;y = 0;
} else {
exgcd(b, a%b, y, x);
y -= (a/b) * x;
}
}
void extgcd(LL a, LL b, LL &d, LL &x, LL &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
extgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
LL inverse(LL a, LL n) {
LL d, x, y;
extgcd(a, n, d, x, y);
return d == 1 ? (x + n) % n : -1;
}递推求阶乘逆元
我们经常会用到阶乘的逆元,我们可以考虑用费马小定理先求出最大的那个阶乘的逆元,然后再往回推
我们可以把
我们要求
即
因此
void init() {
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = fact[i - 1] * i %mod;
}
inv[maxn - 1] = power(fact[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) %mod;
}
}费马小定理
在模为素数p的情况下,有费马小定理
符号解释
既约
既约,或称不可约,或称互质,或称互素,a,m既约,记做
而在模数不为素数p得情况下,有欧拉定理
同理
因此逆元x便可以套用快速幂求得了
如何判断a是否有逆元?检验逆元的性质,看求出的幂值x与a相乘是否为1即可
PS:这种算法复杂度为
当p比较大的时候需要用快速幂求解
LL pow_mod(LL x, LL n, LL mod) {
LL res = 1;
while (n > 0) {
if (n & 1)res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}当模p不是素数的时候需要用到欧拉定理
所以时间复杂度即求出单个欧拉函数的值
(当p为素数的时候
PS:这里就贴出欧拉定理的板子,很少会用欧拉定理求逆元
特殊情况
一
当N是质数,这点也很好理解。当N是质数,
二
求逆元一般公式(条件b|a)
证明:
PS:实际上
通过递推求1~n的逆元
有时候会遇到这样一种问题,在模质数p下,求
推导过程如下,设
左右同时除
再把t和k替换掉
初始化
另外有个结论 1->p 模 p的所有逆元值对应 1->p 中所有的数,比如p=7,那么 1->6 对应的逆元是 1 4 5 2 3 6
const int N = 1e5 + 5;
int inv[N];
void inverse(int n, int p) {
inv[1] = 1;
for (int i = 2; i <= n; ++i) {
inv[i] = (ll) (p - p / i) * inv[p % i] % p;
}
}通过递推求n!的逆元
递推公式:
// 快速幂求逆元
int quick_inverse(int n, int p) {
int ret = 1;
int exponent = p - 2;
for (int i = exponent; i; i >>= 1, n = n * n % p) {
if (i & 1) {
ret = ret * n % p;
}
}
return ret;
}
int invf[N], factor[N];
void get_factorial_inverse(int n, int p) {
factor[0] = 1;
for (int i = 1; i <= n; ++i) {
factor[i] = i * factor[i - 1] % p;
}
invf[n] = quick_inverse(factor[n], p);
for (int i = n-1; i >= 0; --i) {
invf[i] = invf[i + 1] * (i + 1) % p;
}
}