原根

根据欧拉定理我们知道，若 $a,\;m$ 互质， $a^{\varphi(m)}\equiv1\pmod m$ 。因此， $a^1,a^2,\dots$ 这样一个数列在模 $m$ 意义下将有一个 $\varphi(m)$ 长度的循环节，因为 $a^{\varphi(m)+1}$ 又回到了一开始的 $a^1$ 。

然而，我们并不能保证它是最短的循环节，例如， $2^1\equiv2,\; 2^2\equiv4,\; 2^3\equiv1\pmod7$ ，可以发现这时最短循环节长度为3，而不是 $\varphi(7)=6$ 。我们把这个最短循环节的长度定义为 $a$ 在模 $m$ 下的阶，记作 $\mathrm{ord}_ma$ 。严格地，定义 $a$ 在模 $m$ 下的阶是同余方程 $a^x\equiv 1\pmod m$ 的最小正整数解。

显然， $\mathrm{ord}_ma$ 一定是 $\varphi(m)$ 的因数。特别地，当 $\mathrm{ord}_ma=\varphi(m)$ 时，就称 $a$ 为模 $m$ 下的一个原根。对于原根 $a$ 来说， $a^1,a^2,\dots, a^{\varphi(m)}$ 在模 $m$ 下各不相同，它们就是最短的循环节。

并不是每个数都存在原根，例如 $\varphi(8)=4$ ，但没有任何数在模8下的阶为4。为判断一个数是否有原根，我们有一个重要的定理：

正整数有原根的充要条件为：它能表示为下列形式之一： $2,\;4,\;p^n,\;2p^n$ ，其中 $p$ 为奇素数。

（证明比较复杂，若感兴趣可参见这篇博客）

那么，如何判断一个数有多少原根？可以发现，如果 $a$ 是模 $m$ 的原根，那么对于任意和 $\varphi(m)$ 互质的正整数 $s$ ， $a^s$ 也是模 $m$ 的原根（此时 $s,\;2s,\;\dots,\;\varphi(m)\cdot s$ 在模 $\varphi(m)$ 下互不相同，于是 $a^s,a^{2s},\dots, a^{\varphi(m)\cdot s}$ 在模 $m$ 下互不相同）。容易证明，它们就是 $m$ 的全部原根（注意到模 $m$ 下与 $m$ 互质的数一共只有 $\varphi(m)$ 个，已经被 $a^1,a^2,\dots, a^{\varphi(m)}$ 占据完了）。所以原根的数量就是模 $m$ 意义下 $s$ 的数量，即 $\varphi(\varphi(m))$ 。

这同时启示我们，求原根时，只需要找到一个原根，就很容易得到全部原根。至于如何找到原根，暴力枚举即可。因为数学家已经证明，一个数 $n$ 若有原根，则其最小原根在渐进意义下不大于 $\sqrt[4]{n}$ 级别^[1]，所以直接枚举的时间复杂度是比较低的。

求 $n$ 的所有原根的步骤为：

预处理

线性筛出不大于 $m$ 的素数，并求出所有不大于 $m$ 的正整数的欧拉函数值。
对每个不大于 $m$ 的素数 $p$ ，求出所有不大于 $m$ 的 $p^q$ 和 $2p^q$ 。

判断 $n$ 是否有原根
求最小原根

求出 $\varphi(m)$ 的所有因数
枚举与 $m$ 互质的 $i$
对于 $\varphi(m)$ 的每个因数 $j$ ，分别计算 $i^j$ ，如果 $j\not=\varphi(m)$ 但 $i^j\equiv1\pmod m$ ，说明 $i$ 不是原根^[2]
继续循环，直到找到合适的 $i$ 为止

求所有原根

枚举 $\varphi(m)$ 以内的正整数 $s$
如果 $s$ 与 $\varphi(m)$ 互质，则 $a^s$ 是一个原根

主要代码如下：

int phi[MAXN]; // 欧拉函数表
bool isnp[MAXN]; // 是否不是素数
vector<int> primes; // 质数表
int qpow(int a, int n, int p); // 快速幂
void init(int n); // 欧拉筛
// 实现省略，可参照之前的笔记

vector<int> get_factors(int a) // 求所有因数
{
    vector<int> v;
    for (int i = 1; i * i <= a; ++i)
        if (a % i == 0)
        {
            v.push_back(i);
            if (i * i != a) v.push_back(a / i);
        }
    return v;
}
bool exist[MAXN]; // 是否存在原根
void init_exist() // 初始化exist数组
{
    exist[2] = exist[4] = true;
    for (int i = 1; i < (int)primes.size(); ++i)
    {
        int p = primes[i];
        for (int q = p; q < MAXN; q *= p)
        {
            exist[q] = true;
            if (q * 2 < MAXN)
                exist[q * 2] = true;
        }
    }
}
vector<int> get_primative_roots(int m) // 求所有原根
{
    vector<int> v;
    if (!exist[m])
        return v;
    int phiM = phi[m], fst;
    auto factors = get_factors(phiM);
    for (int i = 1;; ++i)
    {
        if (gcd(i, m) != 1)
            continue;
        bool ok = true;
        for (auto e : factors)
            if (e != phiM && qpow(i, e, m) == 1)
            {
                ok = false;
                break;
            }
        if (ok)
        {
            fst = i;
            break;
        }
    }
    int cur = fst;
    for (int i = 1; i <= phiM; ++i)
    {
        if (gcd(phiM, i) == 1)
            v.push_back(cur);
        cur = cur * fst % m;
    }
    return v;
}

当然，这样求出来的vector很可能是乱序的，常常还需要排序操作。

此外，如果只需要求最小原根，可以用下面的占用空间较小的算法：

int get_minimum_primitive_root(int m)
{
    int phiM = phi(m);
    for (int i = 1;; ++i)
    {
        if (__gcd(i, m) != 1)
            continue;
        auto factors = get_factors(phiM);
        bool ok = true;
        for (auto e : factors)
            if (e != phiM && qpow(i, e, m) == 1)
            {
                ok = false;
                break;
            }
        if (ok)
            return i;
    }
}