基础数论算法（7）欧拉函数与BSGS算法

本文介绍了数论中的欧拉函数概念及其计算方法，并详细解释了如何利用积性函数特性进行高效计算。同时，文章还探讨了BSGS算法的工作原理及应用，用于解决特定的模指数方程。

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

欧拉函数

我真的觉得欧拉无所不能…

在提到欧拉函数之前，我们先要说一个定义：积性函数。什么是积性函数？对于互质的数a,b，有f(ab)=f(a)*f(b)。
这个玩意真的特别神奇。最简单的积性函数是 $\tau (n)$ ，这个函数表示所有因子数量。例如， $\tau(6)=4$ ， $\tau(2)=2$ ， $\tau(3)=2$ ， $\tau(6)=\tau(2)*\tau(2)$ 。
另一个积性函数是 $\sigma(n)$ 表示所有因子之和。 $\sigma(6)=12$ ， $\sigma(2)=3$ ， $\sigma(3)=4$ ， $\sigma(6)=\sigma(2)*\sigma(3)$
欧拉函数是什么呢？我们称1~n中与n互质的数的个数为欧拉函数，记作 $\phi (n)$ 。作为积性函数，我们还是用6来验证一下： $\phi (6)=2$ ， $\phi (2)=1$ ， $\phi (3)=2$ ， $\phi (6)=\phi (2)*\phi (3)$ 。是不是觉得非常神奇？
那么如何求欧拉函数值？有这样一个公式：

ϕ (n) = n \cdot \prod (1 - 1 p i) ， 其 中 p i 表 示 n 的 一 个 质 因 数

$\phi(n) =n·\prod(1-\dfrac{1}{p_i} )，其中p_i表示n的一个质因数$
例如，

160=25⋅5 $160=2^5·5$ ，所以

ϕ(160)=160⋅12⋅45=64 $\phi(160)=160·\dfrac{1}{2}·\dfrac{4}{5}=64$ 。那这个东西怎么得来的呢？

以下内容大可无视
来考虑假设p是a的一个因数
那么 $\dfrac{a}{p}$ 就是1~a中所有的p的倍数的个数
因此不妨来考虑一下这样一个概率问题：从1~a中选出一个数与a互质
这就是一个古典概型，假定 $a=p_1^{k_1}·p_2^{k_2}·...·p_n^{k_n}$ ，那么显然 $p_1,p_2,...,p_n$ 的倍数都是与a不互质的。
因此，这就是一个分步的乘法原理：拿到非 $p_i$ 的倍数的概率为 $1-\dfrac{1}{p_i}$ ，结果相乘。
所以，拿到与p互质的数的概率就是 $\prod(1-\dfrac{1}{p_i} )$
因此， $\phi(n) =n·\prod(1-\dfrac{1}{p_i} )，其中p_i表示n的一个质因数$

这样我们可以在O(n)的时间内求出某个数的欧拉函数值。如果用一些高科技手段分解质因数，又会略微快一点。
但是一般来说如果要涉及到欧拉函数都是多组的，那么这样求出一个欧拉函数表复杂度要 $O(n^2)$ 。这是我们不能容忍的，所以我们可以在欧拉筛里加几句话来处理出一张欧拉函数表。
首先，我们需要了解几个东西。
（1）对素数来说， $\phi (n)=n-1$
（2）如果p为质数， $i\ mod\ p\neq 0$ ，那么
$\phi (i·p)=\phi (i)·\phi (p)=\phi (i)·(p-1)$
（3）如果p为质数， $i\ mod\ p = 0$ ，那么 $\phi (i·p)=p·\phi (i)$
前两条都是显然的，一个是素数本身的性质，一个是积性函数的定义。第三条比较有趣，我们来看一下之前得到的公式：
$\phi(i) =i·\prod(1-\dfrac{1}{p_j} )，其中p_j表示i的一个质因数$ ，观察一下就会发现，这里由于p为i的质因数，所以 $\prod(1-\dfrac{1}{p_i} )$ 这一部分并未发生改变，亦即 $\phi(n·p)=p·n·\prod(1-\dfrac{1}{p_i} )=p·\phi(n).$

那么接下来就是欧拉函数与欧拉筛相结合。代码：

#include <iostream>
#define MAXN 40003
using namespace std;
int n;
int phi[MAXN],prime[MAXN],cnt,ans;
bool notprime[MAXN];
void getphi(){
    int i,j;
    phi[1]=1;
    for(i=2;i<=40000;++i){
        if(!notprime[i]){
            prime[++cnt]=i;
            phi[i]=i-1;
        }
        for(j=1;j<=cnt;++j){
            if(i*prime[j]>0) break;
            notprime[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(){
    getphi();
    return 0;
}

非常有趣吧。

北上广深拔山盖世 BSGS算法

北上广深，啊不对，BSGS算法是Baby-step-Giant-step的简称，从名字上看就是挺蛋疼的一个算法。BSGS算法的用处在于，求解 $A^x \equiv B(mod\ \ C)$ 其中C为素数。不过相对应的还有EXBSGS用于解C不为素数的情况，那就比较复杂了我们不谈它。
因为一般而言NOIP考数论都会放在Day2的T1，所以出这玩意概率并不大……总之了解一下吧。

$A^x \equiv B(mod\ C)$
$设m=\lceil \sqrt{m} \ \rceil,x=i·m+j$
$从而，(A^i)^m·A^j \equiv B(mod\ C)$
$变一下形，A^j \equiv \dfrac{B}{(A^i)^m}(mod\ C)$
是不是看到了什么熟悉的东西？没错，exgcd求逆元。
我们先将 $A^j$ 存在Hash表中，然后枚举i，快速的查出结果。
将 $A^j$ 存表我们称为Baby Step，而枚举i我们称为Giant Step.