本文主要是介绍欧拉函数和逆元，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

欧拉函数

定义

欧拉函数表示 再[1,n-1],这个闭区间中和n互质的的数字的个数。

通式

φ(x)=x* (1-1/p1)* (1-1/p2)* (1-1/p3)* (1-1/p4)……(1-1/pn)

性质

1. 若n为质数 有 phi[n]=n-1
2. 当a，b互质时，phi[a*b]=phi[a]*phi[b](a,b 不一定是质数)
3. 当p是质数，n=kp时，phi[n*p]=phi[n]*p

欧拉函数的求法

单个欧拉函数值的求法

#include<bits/stdc++.h>
using namespace std;
const int N=1e4;


int getphi(int n)
{
    int phi=n;//记得初始化 
    if(n==1||n==0)return 0;//特判0 1
    for(int i=2;i<=n/i;i++)
    {
        if(n%i==0)
        {
            while(n%i==0)n/=i;
            phi=phi/i*(i-1);//定义式 每分解出一个质因数就将原值乘以i/(i-1)
        }
    }
    if(n!=1)phi=phi/n*(n-1);
    return phi;
}
int main()
{
    int n;
    while(cin>>n)
    {
        cout<<getphi(n)<<endl;
    }
    return 0;
}

筛法求欧拉函数

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
vector<int> prime;
int phi[N];
bool st[N];

void getphi(int n)
{
    memset(st, 1, sizeof st);
    for (int i = 2; i <= n; i++)
    { //遍历区间内所有值
        if (st[i])
            prime.push_back(i), phi[i] = i - 1; //性质1
        for (int j = 0; j < prime.size() && prime[j] <= n / i; j++)
        {
            int p = prime[j];
            st[p * i] = 0;
            if (i % p == 0)
            {                            //i 和 p的位置不要搞反
                phi[p * i] = phi[i] * p; //性质3
                break;
            }
            phi[i * p] = phi[i] * (p - 1); //性质2+性质1
        }
    }
}
int main()
{
    int n;
    getphi(N);
    while (cin >> n, n)
    {
        cout << phi[n] << endl;
    }
    return 0;
}

逆元

取模运算法则

(a + b) % p = (a%p + b%p) %p （对）

(a - b) % p = (a%p - b%p) %p （对）

(a * b) % p = (a%p * b%p) %p （对）

(a / b) % p = (a%p / b%p) %p （错）

为解决除法取模 ，提出取模意义下的‘倒数’也就是逆元。

逆元的定义

a*x ≡ 1 (mod p)

上式表示在模p的环境下 ，a的逆元是 x。

显然，ax-1|p

所以，ax-1=kp

即， ax-kp=1

由于k的任意性， ax+kp=1

如此得到逆元的等价定义式，求逆元即求上不定方程的解

假若得到逆元 ， 就可以得到mod意义下的除法公式

(a / b) % p = (a%p * inv( b )%p) %p （对）

逆元存在的冲要条件

根据贝祖定理 ，ax+by=c 有解的条件是k*gcd(a,b)=c

及c必须是gcd(a,b)的整数倍

再考虑逆元的定义是ax+by=1 显然 gcd(a,b)=1。所以ab互质。

也就是说，在mod p环境下 a 的逆元存在的冲要条件是 p和 a 互质。

逆元求法

扩欧求逆元

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;

void exgcd(int a,int b,int &x,int &y)
{
    if(!b)
    {
        x=1,y=0;
        return;
    }
    exgcd(b,a%b,x,y);
    int tmp=x;
    x=y;
    y=tmp-a/b*y;
}

int main()
{
    int x,y;
    int a,p;
    cin>>a>>p;
    exgcd(a,p,x,y);
    cout<<(x%p+p)%p<<endl;//取最小正整数解
    return 0;
}

费马小定理+快速幂求逆元

表述

a ^ (p-2) ∗ a%p = 1

即 inv(a)=a^(p-2)%p

成立条件

求a在环境p下的逆元，需要：

1. gcd(a,p)=1//逆元存在条件
2. p为素数//费马成立条件

代码实现

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 10;

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

int getinv(int a, int mod)
{
    return spow(a, mod - 2, mod) % mod;
}

signed main()
{
    int a, p;
    cin >> a >> p;
    int inv=getinv(a,p);//不用再处理，已经是最小正整数解了
    cout <<  inv << endl;
    return 0;
}

以上两种求单个数的逆元方法的时间复杂度均为O(logN)

这篇关于欧拉函数和逆元的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！