求逆元的四种方法

如果ax≡1(mod p)，且a与p互质（gcd(a,p)=1），则称a关于模p的乘法逆元为x。（不互质则乘法逆元不存在）

求逆元的四种方法：

1. 费马小定理
2. 欧拉定理求逆元 （相当于费马小定理的扩展）
3. 扩展欧几里德
4. 递推打表

1、费马小定理 （p为素数）

费马小定理：  ( a^p - p ) 是 p 的倍数，所以可推出  , 这也是更为常用的书写形式。

因为 a^(p-1) = a * a^(p-2) , 故费马小定理可写成逆元的形式，( a * a^(p-2) ) ≡ 1 （mod p）

因此 a^(p-2) 就是所求的逆元，用快速幂求出即可。

LL pow_mod(LL a, LL b, LL p){//a的b次方求余p 
    LL ret = 1;
    while(b){
        if(b & 1) ret = (ret * a) % p;
        a = (a * a) % p;
        b >>= 1;
    }
    return ret;
}
LL Fermat(LL a, LL p){//费马求a关于b的逆元 
        return pow_mod(a, p-2, p);
}

2、欧拉定理求逆元

摘自大佬博客： https://www.cnblogs.com/vongang/archive/2013/06/04/3117370.html

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<iostream>
using namespace std;
typedef long long  LL;
const int N = 100009;

int check[N];
int prime[N];
int phi[N];
int inv[N];
int cnt;

int fast_pow(int a,int b)
{
    int ans=1;
    while(b)
    {
        if(b&1)
            ans=a*ans;
        a=a*a;
        b>>=1;
    }
    return ans;
}

void is_prime(int n)
{
    int i,p,j;
    cnt=0;
    phi[1]=1;
    for(i=2;i<=n;i++)
    {
        if(!check[i])
        {
            prime[cnt++]=i;
            phi[i]=i-1;
        }
        for(j=0;j<cnt;j++)
        {
            if(i*prime[j]>n)
                break;
            check[i*prime[j]]=1;

            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else
            {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
}
int main()
{
    int i,p,j,n;
    is_prime(100);
    scanf("%d",&p);
    for(i=0;i<=10;i++)
        if(i%p)
            inv[i]=(fast_pow(i,phi[p]-1)%p);    //// i关于1模p的逆元
        else
            inv[i]=-1;
    for(i=0;i<=10;i++)
    {
        printf("%d ",inv[i]);
    }
    return 0;
}

3、扩展欧几里德

　　

　　a*x=1 (mod p)  相当于 a*x-y*p=1 (y为整数，最小的x应当是y等于零的时候，所以最后的时候把y赋成0)

　　a*x-y*p=1 , 为了便于理解，将p写成b，

　　即， a*x+b*y=1。 理解为 a关于 1 模 b 的乘法逆元为 x 。

　　

　　开始的 x，y，d 为任意值，但是不能等于零！！！

　　因为d是 gcd(a,b),所以最后给d赋值为gcd的值。若d为1,说明存在这样的x，否则不存在。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<vector>
#include<deque>
#include<iostream>
using namespace std;
typedef long long  LL;
const int N = 100009;

void exgcd(LL a,LL b,LL &d,LL &x,LL &y)
{
    if(b==0)
    {
        x=1;
        y=0;
        d=a;
        return ;
    }
    else
    {
        exgcd(b,a%b,d,x,y);
        LL mid=x;
        x=y;
        y=mid-a/b*y;
    }

    return ;
}
LL inv(LL a, LL b)
{
    LL x,y,d;
    exgcd(a,b,d,x,y);
    return d == 1 ? (x+b)%b : -1;

}
int main()
{
    LL a,p;
    scanf("%lld%lld",&a,&p);
    printf("%lld
",inv(a,p));
    return 0;
}

4、递推打表

　　令 a*x + b = p.

　　b * inv[b] ≡ 1 (mod p) , 将 b 替换为 p - a*x

　　(p - a * x) * inv[b] ≡ 1(mod p) ,即 p * inv[b] - (a * x * inv[b] ) ≡ 1(mod p)

　　因为 p mod p 等于零， 所以上式变为 -(a * x * inv[b]) ≡ 1(mod p)

　　观察 a * x + b = p 得 ， 在计算机中 a = p/x , b = p%x .

　　故 - (p/x * inv[p % x] * x) ≡ 1(mod p)

　　因此  -p/x *inv[p % x] ≡ inv[x] (mod p)    

　　

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<iostream>
using namespace std;
typedef long long  LL;
const int N = 100009;

int inv[N];
int main()
{
    int i,p,j,n;
    scanf("%d%d",&n,&p);
    inv[1]=1;
    for(i=2;i<=n;i++)
        inv[i] = LL(p-p/i)*inv[p%i]%p;
    for(i=2;i<=n;i++)
        printf("%d %d 
",i,inv[i]);

    return 0;
}