洛谷P6091（原根模板）

阶

阶：由欧拉定理可知，对于$a\in z$，$m\in {\mathbb{N}}^{\ast }$，若$\gcd (a,m)=1$，则$a^{\phi (m)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$。

因此满足同余式$a^n\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$的最小整数$n$存在，这个n称作$a$模$m$的阶，记作${\delta }_m(a)$。

性质1：$a,a^2,\cdots ,a^{{\delta }_m(a)}$模$m$两两不同余

性质2：$a^n\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$，则${\delta }_m(a)\mid n$。

性质3：设$m\in {\mathbb{N}}^{\ast }$，$a,b\in z$，$\gcd (a,m)=\gcd (b,m)=1$，则${\delta }_m(ab)={\delta }_m(a){\delta }_m(b)$的充分必要条件是$\gcd ({\delta }_m(a),{\delta }_m(b))=1$

性质4：设$k\in \mathbb{N}$，$m\in {\mathbb{N}}^{\ast }$，$a\in z$，$\gcd (a,m)=1$，则${\delta }_m(a^k)=\frac{{\delta }_m(a)}{gcd\left(\right({\delta }_m(a),k)}$

原根

原根：设$m\in {\mathbb{N}}^{\ast }$，$a\in z$，若$\gcd (a,m)=1$，且${\delta }_m(a)=\phi (m)$，则称$a$为模$m$的原根。

原根判定定理

原根判定定理：设$m⩾3,\gcd (a,m)=1$，则$a$是模$m$的原根的充要条件，对于$\phi (m)$的每个素因数$p$，都有$a^{\frac{\phi (m)}{p}}\not\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$。

原根个数

若一个数$m$有原根，则它原根的个数为$\phi (\phi (m))$。

原根存在定理

原根存在定理：一个数$m$存在原根当且仅当$m=2,4,p^{\alpha },2p^{\alpha }$，其中$p$为奇素数，$\alpha \in {\mathbb{N}}^{\ast }$。

定理1：对于奇素数$p$，$p$有原根。

定理2：对于奇素数$p$，$\alpha \in {\mathbb{N}}^{\ast }$，$p^{\alpha }$有原根。

定理3：对于奇素数$p$，$\alpha \in {\mathbb{N}}^{\ast }$，$2p^{\alpha }$有原根。

定理4 ：对于$m\ne 2,4$，且不存在奇素数$p$及$\alpha \in {\mathbb{N}}^{\ast }$使得$m=p^{\alpha },2p^{\alpha }$， 模$m$的原根不存在。

总结

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

然而，我们并不能保证它是最短的循环节，例如，$2^1\equiv 2,2^2\equiv 4,2^3\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}7)$，可以发现这时候最短循环节长度为$3$，而不是$\phi (7)=6$。我们把这个最短循环节的长度定义为$a$在模$m$下的阶，记住${\delta }_m(a)$。严格地，定义$a$在模$m$下的阶是同余方程$a^x\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$的最小正整数解。

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

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

1.预处理

1. 线性筛出不大于 $m$ 的素数，并求出所有不大于$m$的正整数的欧拉函数值。

2. 对每个不大于$m$的素数$p$，求出所有不大于$m$的$p^{\alpha }$和 $2p^{\alpha }$。（原根存在定理）

2.判定$n$是否有原根

3.求最小原根

1. 求出$\phi (m)$的所有因质数
2. 枚举与$m$互质的$i$（原根定义）
3. 对于$\phi (m)$的每个质因数$j$，分别计算$i^{\frac{\phi (m)}{j}}$，如果$i^{\frac{\phi (m)}{j}}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$说明$i$不是原根（原根判定定理）
4. 继续循环，直到找到合适的$i$为止

4.求所有原根

1. 枚举$\phi (m)$以内的正整数$s$
2. 如果$s$与$\phi (m)$互质，则$a^s$是一个原根（阶的性质4）

洛谷P6091(求模m意义下的原根）

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define Buff std::ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
#define lowbit(x) (x & (-x))
#define ls (rt * 2)
#define rs (rt * 2 + 1)
typedef long long ll;
const ll mod = 1000000007;
const ll MAXN = 1e7 + 10;
const double eps = 1e-8;
//======================================
vector<ll> primes;
bitset<MAXN> st, exist;
ll euler[MAXN];

//求最小公约数
ll gcd(ll a, ll b) {
    return b ? gcd(b, a % b) : a;
}

//快速幂
ll qpow(ll a, ll k, ll p) {
    ll res = 1;
    while (k) {
        if (k & 1) res = res * a % p;
        a = a * a % p;
        k >>= 1;
    }
    return res;
}
//把1~n当中的素数筛选出来，同时把1~n的欧拉函数值求出来
void get_eulers(ll n) {
    euler[1] = 1;
    for (ll i = 2; i <= n; i++) {
        if (!st[i]) primes.push_back(i), euler[i] = i - 1;
        for (ll j = 0; primes[j] <= n / i; j++) {
            st[i * primes[j]] = 1;
            if (i % primes[j] == 0) {
                euler[i * primes[j]] = euler[i] * primes[j];
                break;
            }
            euler[i * primes[j]] = euler[i] * (primes[j] - 1);
        }
    }
}
//标记是否存在原根
void init() {
    exist[1] = exist[2] = exist[4] = 1;
    for (auto x : primes) {
        if (x % 2) {
            for (ll i = x; i < MAXN; i *= x) {
                exist[i] = 1;
                if (i * 2 < MAXN) exist[i * 2] = 1;
            }
        }
    }
}
//分解质因数
vector<ll> get_primesfactor(ll x) {
    vector<ll> res;
    // for (ll i = 2; i <= x / i; i++)
    //     if (x % i == 0) {
    //         res.push_back(i);
    //         while (x % i == 0) x /= i;
    //     }
    // if (x > 1) res.push_back(x);
    for (auto prime : primes) {
        if (prime > x) break;
        if (x % prime == 0) res.push_back(prime);
    }
    return res;
}
//求解质因数
vector<ll> get_primative_roots(ll m) {
    vector<ll> v;
    //第二步
    if (!exist[m]) return v;
    ll phi = euler[m], fst;
    //第三步的第一小步
    auto factors = get_primesfactor(phi);
    //第三步的第二小步
    for (ll i = 1;; i++) {
        if (gcd(i, m) != 1) continue;
        bool ok = true;
        //第三步的第三小步
        for (auto x : factors) {
            if (qpow(i, phi / x, m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok) {
            fst = i;
            break;
        }
    }
    //第四步
    ll cur = fst;
    for (ll i = 1; i <= phi; i++) {
        if (gcd(phi, i) == 1) v.push_back(cur);
        cur = cur * fst % m;
    }
    return v;
}
// int get_minimum_primitive_root(int m) {
//     if (!exist[m]) return 0;
//     int phi = euler[m];
//     for (int i = 1;; i++) {
//         if (gcd(i, m) != 1) continue;
//         auto factors = get_primesfactor(phi);
//         bool ok = true;
//         for (auto x : factors)
//             if (qpow(i, phi / x, m) == 1) {
//                 ok = false;
//                 break;
//             }
//         if (ok) return i;
//     }
// }
int main() {
    Buff;
    //     clock_t c1 = clock();
    // #ifdef LOCAL
    //     freopen("in.in", "r", stdin);
    //     freopen("out.out", "w", stdout);
    // #endif
    //=========================================
    ll t;
    ll n = 1000000;
    //第一步的第一小步
    get_eulers(n);
    //第一步的第二小步
    init();
    cin >> t;
    while (t--) {
        ll n, d, m, s, t, x, id, j;
        cin >> n >> d;
        auto ans = get_primative_roots(n);
        ll len = ans.size();
        sort(ans.begin(), ans.end());
        cout << len << endl;
        for (int i = d; i <= len; i += d) {
            cout << ans[i - 1] << " ";
        }
        cout << endl;
    }
    //=========================================
    // cerr << "Time Used:" << clock() - c1 << "ms" << endl;
}