数学知识——欧拉函数、快速幂、龟速乘法

本文链接：https://blog.youkuaiyun.com/qq_44965626/article/details/109112197

本文介绍了数学算法中的几个关键概念：欧拉函数的定义及其求法，包括直接计算和筛法；快速幂运算及其在求逆元中的应用；龟速乘法的概念及其实现方式。这些算法在计算机科学和信息安全领域有着广泛的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数学知识——欧拉函数、快速幂

欧拉函数
欧拉函数
筛法求欧拉函数

快速幂
快速幂
快速幂求逆元
龟速乘法

欧拉函数

欧拉函数定义：1 ~ N 中与 N 互质的数的个数被称为欧拉函数，记为ϕ(N)。
若在算数基本定理中，N=p₁^a1p₂^a2…p_n^an,则ϕ(N)= N * $\frac{p1-1}{p1}$ * $\frac{p2-1}{p2}$ * … * $\frac{pn-n}{pn}$ 。

AcWing 873. 欧拉函数

#include<iostream>

using namespace std;

int n;

int oula(int a)//欧拉函数
{
    int res = a;
    for(int i = 2; i <= a / i; i++)//因为大于a的平方根的质数p只可能有1个，所以i不用循环到a
    {
        if(a % i)continue;
        while(a % i == 0)a /= i;
        res = res / i * (i - 1);
    }
    if(a > 1)res = res / a * (a - 1);//若此时a>1，则a就是那个大于原来a的平方根的质数p（唯一）
    return res;
}
int main()
{
    cin >> n;
    while(n--)
    {
        int a;
        cin >> a;
        cout << oula(a) << endl;
    }
    return 0;
}

AcWing 874. 筛法求欧拉函数

核心思路：
若i为质数，则ϕ(i) = i - 1。
若i为合数：
若i % primes[j] == 0，ϕ(i*primes[j]) = primes[j] * ϕ(i)（因为此时i * primes[j]的质因数与i完全一致，对应于欧拉函数定义ϕ(N)= N * $\frac{p1-1}{p1}$ * $\frac{p2-1}{p2}$ * … * $\frac{pn-n}{pn}$ ，只有N大primes[j]倍）
若i % primes[j] != 0，ϕ(i*primes[j]) = primes[j] * ϕ(i) * $\frac{primes[j]-1}{primes[j]}$ = (primes[j]-1) * ϕ(i)(因为此时N大了primes[j]倍，质数多了一个pirmes[j]）

#include<iostream>

using namespace std;

typedef long long LL;
const int N = 1e6 + 5;

int primes[N], phi[N], cnt, n;
bool st[N];

LL eulers(int n)
{
    for(int i = 2; i <= n; i++)
    {
        if(!st[i])
        {
            phi[i] = i - 1;
            primes[cnt++] = i;
        }
        for(int j = 0; i * primes[j] <= n; j++)
        {
            st[i * primes[j]] = true;
            if(i % primes[j] == 0)
            {
                phi[i * primes[j]] = primes[j] * phi[i];
                break;
            }
            phi[i * primes[j]] = (primes[j] - 1) * phi[i];
        }
    }
    LL res = 1;
    for(int i = 2; i <= n; i++)
        res += phi[i];
    return res;
    
}
int main()
{
    cin >> n;
    cout << eulers(n);
    return 0;
}

快速幂

AcWing 875. 快速幂

功能：以log(n)的时间复杂度计算aⁿ
思路：
将n看成二进制数，再看成多个连续的2的指数次幂之和，系数为0或1，由二进制数n决定，每次a=a*a,实际上是遍历下一个2的指数次幂。
两个同底指数次幂相乘，底数不变，指数相加

#include<iostream>

using namespace std;

typedef long long LL;
int n;

LL qmi(int a, int k, int p)
{
    LL res = 1;
    while(k)
    {
        if(k & 1)res = res * a % p;
        k >>= 1;
        a = (LL)a * a % p;
    }
    return res;
}
int main()
{
    cin >> n;
    while(n--)
    {
        int a, b, p;
        cin >> a >> b >> p;
        cout << qmi(a, b, p) << endl;
    }
    return 0;
}

AcWing 876. 快速幂求逆元

乘法逆元定义：如果ax≡1 (mod p),且gcd(a,p)=1（a与p互质），则称a关于模p的乘法逆元为x。
逆元的一个作用：求 $\frac{a}{b}$ %p等价于求(a%p)* (b模p的逆元)而不是求(a%p)*( $\frac{1}{b}$ %p)，往往在分母b数值较大的时候使用逆元。
若p为质数，则a^p-2即为a关于模p的乘法逆元。
互质：两个互质数的公约数只有1。

核心思路：利用快速幂求a^p-2 % p的值。

#include<iostream>

using namespace std;

typedef long long LL;
int n;

int qmi(int a, int k, int p)
{
    int res = 1;
    while(k)
    {
        if(k & 1)res = (LL)res * a % p;
        k >>= 1;
        a = (LL)a * a % p;
    }
    return res;
}
int main()
{
    cin >> n;
    while(n--)
    {
        int a, p;
        cin >> a >> p;
        if(a % p == 0)
        {
            cout << "impossible" << endl;
            continue;
        }
        cout << qmi(a, p - 2, p) << endl;
    }
    return 0;
}

龟速乘法

快速幂和龟速乘法主要是用来解决中间运算结果过大的问题，具有一定的相似之处。
快速幂将指数运算分解为乘法运算，而龟速乘法将乘法运算变为加法运算。
同理将k看做一个二进制数，a每次乘以2再根据二进制k的该位情况来决定是否将a加入结果，初始a对应二进制k的最低位（右）。

#include<iostream>

using namespace std;

const int mod = 1e9 + 7;

int slow(int a, int k)
{
    int res = 0;
    while(k)
    {
        if(k & 1)res = (res + a) % mod;
        k >>= 1;
        a = 2 * a % mod;
    }
    return res;
}

int main()
{
    int a, b;
    cin >> a >> b;
    cout << slow(a, b);
    return 0;
}