扩展欧拉定理和BSGS算法

扩展欧拉定理

欧拉定理，即：若正整数 $a$ 与 $m$ 互质，则: $a^{\phi (m)}\equiv 1(\mathrm{mod}m)$
这里的 $\phi (m)$ 是欧拉函数，即小于或等于 $m$ 且与 $m$ 互质的正整数个数。当 $m$ 是质数 $p$ 时，欧拉定理退化成 费马小定理 $a^{p-1}\equiv 1(\mathrm{mod}p)$ 。

接下来我们证明欧拉定理:

记小于 n 且与 n 互质的正整数集合为

$R=\left\{x_1,x_2,\cdots ,x_{\phi (n)}\right\}$

$S=\left\{a{x}_1\%n,a{x}_2\%n,\cdots ,a{x}_{\phi (n)}\%n\right\}$

$\begin{array}{l}\forall i\in [1,\phi (n)]\\ \because (a,n)=1,\left(x_i,n\right)=1\\ \therefore \left(a{x}_i,n\right)=1\end{array}$

由最大公约数的性质可得 $\left(a{x}_i\%n,n\right)=1$
所以 $\mathrm{S}$ 中所有元素都与 $n$ 互质，且都小于 $n$ 。
又 $\mathrm{S}$ 中无重复元素
假设 $i\ne j,a{x}_i\%n=a{x}_j\%n$
即 $a{x}_i\equiv a{x}_j(\mathrm{mod}n)$, 又 $(a,n)=1$
$\therefore x_i\equiv x_j(\mathrm{mod}n),i=j$ ，矛盾!
$\therefore S=R$
$\therefore {\prod }_{i=1}^{\phi (n)}a{x}_i\%n={\prod }_{i=1}^{\phi (n)}{x}_i$
$\therefore {\prod }_{i=1}^{\phi (n)}a{x}_i\equiv {\prod }_{i=1}^{\phi (n)}{x}_i(\mathrm{mod}n)⟹a^{\phi (n)}{\prod }_{i=1}^{\phi (n)}{x}_i\equiv {\prod }_{i=1}^{\phi (n)}{x}_i(\mathrm{mod}n)$
又 $\left({\prod }_{i=1}^{\phi (n)}{x}_i,n\right)=1$
故 $a^{\phi (n)}\equiv 1(\mathrm{mod}n)$

在算法竞赛中，我们常常会用到它的一个重要的推论：若正整数 $a$ 与 $m$ 互质，则 $a^b\equiv a^{b\mathrm{mod}\phi (m)}(\mathrm{mod}m)$
(这是因为 $a^b=a^{\phi (m)\lfloor b/\phi (m)\rfloor +b\mathrm{mod}\phi (m)}\equiv 1\cdot a^{b\mathrm{mod}\phi (m)}(\mathrm{mod}m)$ )
利用这个推论，即使 $b$ 比较大，我们也可以轻松地计算 $a^b\mathrm{mod}m$ 的值，但需要满足 $a$ 与 $m$ 互质的前提。

为了解决 $a$ 与 $m$ 不互质时的此问题，我们引入拓展欧拉定理: 若 $b\ge \phi (m)$ ，则:
$a^b\equiv a^{b\mathrm{mod}\phi (m)+\phi (m)}(\mathrm{mod}m)(\ast )$
这里仍有前提条件，但影响不大，因为 $b<\phi (m)$ 时直接用快速幂计算即可。
当***$b<\phi (m)$*** 时的板子

#include <bits/stdc++.h>
using namespace std;
bool large_enough = false; // 判断是否有b >= phi(m)
inline int read(int MOD = 1e9 + 7) // 快速读入稍加修改即可以边读入边取模，不取模时直接模一个大于数据范围的数
{
    int ans = 0;
    char c = getchar();
    while (!isdigit(c))
        c = getchar();
    while (isdigit(c))
    {
        ans = ans * 10 + c - '0';
        if (ans >= MOD)
        {
            ans %= MOD;
            large_enough = true;
        }
        c = getchar();
    }
    return ans;
}
int phi(int n) // 求欧拉函数
{
    int res = n;
    for (int i = 2; i * i <= n; i++)
    {
        if (n % i == 0)
            res = res / i * (i - 1);
        while (n % i == 0)
            n /= i;
    }
    if (n > 1)
        res = res / n * (n - 1);
    return res;
}
int qpow(int a, int n, int MOD) // 快速幂
{
    int ans = 1;
    while (n)
    {
        if (n & 1)
            ans = 1LL * ans * a % MOD; // 注意防止溢出
        n >>= 1;
        a = 1LL * a * a % MOD;
    }
    return ans;
}
int main()
{
    int a = read(), m = read(), phiM = phi(m), b = read(phiM);
    cout << qpow(a, b + (large_enough ? phiM : 0), m);
    return 0;
}

BSGS算法

大步小步算法（baby step giant step，BSGS），是一种用来求解离散对数（即模意义下对数）的算法，即给 出 $a^x\equiv b(\mathrm{mod}m)$ 中 $a,b,m$ 的值（这里保证 $a$ 和 $m$ 互质），求解 $x$ 。
既然保证了 $a$ 和 $m$ 互质，那么很容易联想到欧拉定理，我们知道 $a^{\phi (m)}\equiv 1(\mathrm{mod}m)$ ，也就说明 $a^x$ 在模 $m$ 意义下有一个长度为 $\phi (m)$ 的循环节。既然后面都是循环的，我们只需要考虑 $x\le \phi (m)$ 的情形就可以 了。这就有了离散对数的朴素算法: 暴力枚举。复杂度 $O(\phi (m))$ ，因为当 $m$ 是质数时 $\phi (m)=m-1$ ， 最坏时间复杂度就是 $O(m)$ 。
实际上，大步小步算法就是对暴力枚举的一个简单的改进，使用了类似meet in the middle的思想（这个算法 还没有讲，待补）。我们把 $x$ 拆成 $At-B$ ，则原式化为 $a^{At-B}\equiv b(\mathrm{mod}m)$ ，即 $a^{At}\equiv b{a}^B(\mathrm{mod}m)$ 。然后我们预计算出右侧所有可能的取值，再固定一个 $t$ ，计算出左边可能的值，当 发现某个值已经在右边出现过，这时的 $At-B$ 就是我们要求的 $x$ 。

B可能的取值有 $\phi (m)\mathrm{mod}t$ 个，A可能的取值有 $\lfloor \phi (m)/t\rfloor$ 个，不难看出，取 $t=\lceil \sqrt{\phi (m)}]$ 是最好 的，当然为了避免计算欧拉函数，我们直接取 $t=\lceil \sqrt{m}\rceil$ ，不难验证，此时取 $A,B\in [1,t]$ 可以保证把 $x\in [1,m-1]$ 全部枚举一遍。时间复杂度为 $O(\sqrt{m})$ 。
至于如何判定右边的数有没有出现过，用哈希表是最简单的（STL中的 unordered_map 是用哈希表实现的，一般 可以直接使用），如果用 map，复杂度会多一个 $\log$ 。

ll BSGS(ll a, ll b, ll m)
{
    static unordered_map<ll, ll> hs;
    hs.clear();
    ll cur = 1, t = sqrt(m) + 1;
    for (int B = 1; B <= t; ++B)
    {
        (cur *= a) %= m;
        hs[b * cur % m] = B; // 哈希表中存B的值
    }
    ll now = cur; // 此时cur = a^t
    for (int A = 1; A <= t; ++A)
    {
        auto it = hs.find(now);
        if (it != hs.end())
            return A * t - it->second;
        (now *= cur) %= m;
    }
    return -1; // 没有找到，无解
}

拓展大步小步算法

上面的算法只针对 $a$ 和 $m$ 互质的情形，如果不互质，又该如何计算? 我们尝试把它转化成 $a$ 和 $m$ 互质的情 形。
当 $x>0$ 时， $a^x\equiv b(\mathrm{mod}m)$ 等价于 $a^{x-1}a+nm=b$ ，由斐蜀定理（此处曾提到过）可知，有解的 条件是 $b$ 是 $\gcd (a,m)$ 的倍数。
设 $d=\gcd (a,m)$ ，则 $\frac{a^{x-1}a}{d}+\frac{nm}{d}=\frac{b}{d}$ ，即 $\frac{a}{d}{a}^{x-1}\equiv \frac{b}{d}\left(\mathrm{mod}\frac{m}{d}\right)$ 。这时如果 $\gcd \left(a,\frac{m}{d}\right)=1$ ， 就可以直接用大步小步算法求解了 (左侧多了一个系数，但这显然影响不大，把大步小步算法稍作修改即可)， 解出的 $x$ 加上 1 即是原方程的一个解。否则，可以继续递归下去，直到互质为止。
但是，这样算出来的只保证是原方程的一个解，末必是最小解，因为虽然BSGS求出的是最小解，但我们还进行 了递归层数 (下面称为 $cnt$ ) 次加 1 ，真正的最小值可能在 $[0,cnt)$ 间，所以还需要枚举这些数是否为答案。
注意一下特判，本来BSGS是不需要特判的，但是我们的递归条件只对 $x>0$ 时成立。所以如果 $b\equiv 1$ 直接返 回 $x=0$ 即可。
为了进一步加快速度，我们用非递归而非递归的方式实现这个算法。这里很容易做到，而且写起来比递归版本更 加简洁。

// 修改版的BSGS，额外带一个系数
ll BSGS(ll a, ll b, ll m, ll k = 1)
{
    static unordered_map<ll, ll> hs;
    hs.clear();
    ll cur = 1, t = sqrt(m) + 1;
    for (int B = 1; B <= t; ++B)
    {
        (cur *= a) %= m;
        hs[b * cur % m] = B; // 哈希表中存B的值
    }
    ll now = cur * k % m;
    for (int A = 1; A <= t; ++A)
    {
        auto it = hs.find(now);
        if (it != hs.end()) return A * t - it->second;
        (now *= cur) %= m;
    }
    return -INF; // 这里因为要多次加1，要返回更小的负数
}
ll exBSGS(ll a, ll b, ll m, ll k = 1)
{
    ll A = a %= m, B = b %= m, M = m;
    if (b == 1) return 0;
    ll cur = 1 % m;
    for (int i = 0;; i++)
    {
        if (cur == B) return i;
        cur = cur * A % M;
        ll d = gcd(a, m);
        if (b % d) return -INF;
        if (d == 1) return BSGS(a, b, m, k * a % m) + i + 1;
        k = k * a / d % m, b /= d, m /= d; // 相当于在递归求解exBSGS(a, b / d, m / d, k * a / d % m)
    }
}