数论2:欧拉函数,快速幂，扩展欧几里得算法

欧拉函数

  欧拉函数f(n):1-n中与n互质的数的个数。互质指两个整数只有1这一个公约数,或者说最大公约数为1,gcd(a,b)=1。eg.f(6) = 2.
  根据唯一分解定理:N=p₁^a1p₂^a2…p_n^an
  可以得到欧拉函数f(N) = N*(1-1/p₁)(1-1/p₂)…(1-1/p_n)
欧拉函数的证明可以利用容斥定理。

int Eula(int t)
{
    int  ans = t;
    for(int i = 2;i <= t / i;i++)
    {
        if(t % i == 0)
        {
             ans = ans / i * (i - 1);
            while(t % i == 0)  t /= i;
        }
    }
    if(t > 1) ans = ans / t * (t - 1);
    return ans;
}

线性筛优化求欧拉函数
利用线性筛法可以优化欧拉函数求解

  phi[1] = 1; //定义
  for(int i = 2;i <= n;i++)
  {
      if(!st[i])
      {
         primes[++cnt] = i;
         phi[i] = i - 1; //根据定义,质数的欧拉函数
      }
      for(int j = 1;primes[j] <= n/ i;j++)
      {
          st[primes[j] * i] = true;
          if(i % primes[j] == 0) 
          {
              phi[primes[j] * i] = phi[i] * primes[j]; //1.公式推导
              break;
          }
          phi[primes[j] * i] = phi[i] * (primes[j] - 1); //2.公式推导
      }
  }

  给出(1)的推导。因为primes[j]是i的约数，根据唯一分解定理primes[j]*i与i拥有相同的约数。再根据欧拉函数的定义可以推出。
  给出(2)的推导。因为primes[j]不是i的约数，那么primes[j]是primes[j]*i的最小公约数。根据定理:自然数N的最小约数一定是质数，这是唯一分解定理的基础。根据欧拉函数的定义，展开phi[primes[j]*i]与phi[i]，进行对比并化简即可。
欧拉函数的应用
若a与n互质，则a^f(n) mod n = 1,当n为质数有:a^n-1 mod n = 1.
  证明,因为有f(n)个与n互斥的整数,记为p₁p₂…p_f(n)而ap₁, ap₂,…,ap_f(n)也与n互质。当ap₁, ap₂,…,ap_f(n)对n取模后，得到n个与n互质的数，他们和p₁p₂…p_f(n)相等，但顺序可能不一致。

快速幂

  快速幂可以在O(logk)的时间内计算出a^k mod b.思想将a^k 用a的2⁰,2¹…2^logk表示。

long long quick(int a,int k,int p)
{
    long long ans = 1;
    while(k)
    {
        if(k & 1) ans = ans * a % p;
        k >>= 1;
        a = (long long)a * a % p; 
    }
    return ans;
}

快速幂求逆元
  快速幂求逆元根据逆元的定义，a/b同余于ab^-1（mod m）化简得a同余于abb^-1(mod m)，又由于a与m互质，则可以得出bb^-1同余于1(mod m)，又由于m是质数，根据上节欧拉函数，b^-1= b^m-2.

#include<iostream>
#include<algorithm>
using namespace std;
int n;
long long quick(int a,int k,int p)
{
    long long ans = 1;
    while(k)
    {
       if(k & 1) ans = ans * a % p;
       k >>= 1;
       a = (long long) a * a % p;
    }
    return ans;
}
int main()
{
    cin>>n;
    while(n--)
    {
        int a,p;
        scanf("%d%d",&a,&p);
        int res = quick(a,p-2,p);
        if(a % p) printf("%d\n",res);
        else puts("impossible");
    }
    return 0;
}

扩展欧几里得算法

  裴蜀定理：对于一对正整数a,b一定存在非0整数x,y使得ax₀+by₀=gcd(a,b).且x,y不唯一。并且根据欧几里得算法，对上式变形得到bx₁+(a%b)y₁ = gcd(a,b).化简x₀=y₁ ，y₀=x₁-a/b*y1
扩展欧几里得算法

#include<iostream>
using namespace std;
int n;
int exgcd(int &x,int &y,int a,int b)
{
    if(!b)
    {
        x = 1,y = 0;
        return a;
    }
    d = exgcd(y,x,b,a%b);
    y = y - a / b * x;
    return d;
}
int main()
{
    cin>>n;
    while(n--)
    {
        int a,b,x,y;
        scanf("%d%d",&a,&b);
        int d = exgcd(x,y,a,b);
        printf("%d %d\n",x,y);
    }
    return 0;
}

线性同余方程的求解
  求解线性同余方程ax与b同余于m，等价于求解ax=mt+b，等价于ax+my=b有解，根据扩展欧几里得算法，当b是gcd(a,m)的整数倍时，原方程有解。否则无解。

#include<iostream>
#include<algorithm>
using namespace std;
int n;
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 = y - a / b * x;
    return d;
}
int main()
{
    cin>>n;
    while(n--)
    {
        int a,b,m,x,y;
        scanf("%d%d%d",&a,&b,&m);
        int d = exgcd(a,m,x,y);
        if(b % d) puts("impossible");
        else printf("%lld\n",(long long)x * b / d % m);
    }
    return 0;
}