跳转至

# 高次剩余 & 单位根

前置知识：离散对数

本文讨论模意义下的高次剩余和单位根，并介绍模意义下开方运算的算法．

## 高次剩余

模运算下的高次剩余，可以认为是在讨论模意义下开高次方的可行性．它是 二次剩余 的推广．

𝑘 k 次剩余

令整数 𝑘 ≥2 k≥2，整数 𝑎 a 和正整数 𝑚 m 互素．若存在整数 𝑥 x 使得

𝑥 𝑘≡𝑎(m o d 𝑚),x k≡a(mod m),

则称 𝑎 a 为模 𝑚 m 的 𝑘 k 次剩余（𝑘 k-th residue），𝑥 x 为 𝑎 a 模 𝑚 m 的 𝑘 k 次方根（𝑘 k-th root）；否则称 𝑎 a 为模 𝑚 m 的 𝑘 k 次非剩余（𝑘 k-th nonresidue）．

也就是说，𝑎 a 模 𝑚 m 的 𝑘 k 次方根存在，当且仅当 𝑎 a 是模 𝑚 m 的 𝑘 k 次剩余．

### 性质

类似二次剩余，可以讨论 𝑘 k 次剩余的判定、个数以及 𝑘 k 次剩余类的个数问题．和其他 同余方程 问题一样，可以通过 中国剩余定理 将它们转化为素数幂模的情形．根据原根的有无，这进一步区分为奇素数幂模和模数为 2 2 的幂次的情形．

奇数幂模的情形较为简单．事实上，对于所有原根存在的情形，都有如下结论：

定理

设整数 𝑘 ≥2 k≥2，整数 𝑎 a 和正整数 𝑚 m 互素．设模 𝑚 m 的原根存在，且 𝑔 g 是模 𝑚 m 的一个原根．记 𝑑 =g c d(𝑘,𝜑(𝑚))d=gcd(k,φ(m)) 且 𝑑′ =𝜑(𝑚)𝑑 d′=φ(m)d，其中，𝜑(𝑚)φ(m) 是 欧拉函数．那么，有：

1. 𝑎 a 为模 𝑚 m 的 𝑘 k 次剩余，当且仅当

   𝑎 𝑑′≡1(m o d 𝑚).a d′≡1(mod m).

2. 当 𝑎 a 为模 𝑚 m 的 𝑘 k 次剩余时，同余意义下，𝑎 a 模 𝑚 m 恰有 𝑑 d 个互不相同的 𝑘 k 次方根，且它们具有形式

   𝑥≡𝑔 𝑦 0+𝑖 𝑑′(m o d 𝜑(𝑚)), 0≤𝑦 0<𝑑′, 𝑖=0,1,⋯,𝑑−1.x≡g y 0+i d′(mod φ(m)), 0≤y 0<d′, i=0,1,⋯,d−1.

3. 模 𝑚 m 的 𝑘 k 次剩余类的个数为 𝑑′d′，且它们的全体就是

   {𝑔 𝑑 𝑖 m o d 𝑚:0≤𝑖<𝑑′}.{g d i mod m:0≤i<d′}.

证明

因为 𝑎 ⟂𝑚 a⟂m，所以 𝑥 ⟂𝑚 x⟂m．因为 𝑔 g 是模 𝑚 m 的原根，所以，𝑥 x 和 𝑎 a 均与某个 𝑔 g 的幂次同余．设 𝑥 ≡𝑔 𝑦(m o d 𝑚)x≡g y(mod m)，方程 𝑥 𝑘 ≡𝑎(m o d 𝑚)x k≡a(mod m) 就等价于

𝑔 𝑘 𝑦≡𝑔 i n d 𝑔⁡𝑎(m o d 𝑚).g k y≡g ind g⁡a(mod m).

其中，i n d 𝑔⁡𝑎 ind g⁡a 是离散对数．根据 阶的性质 和 𝛿 𝑚(𝑔) =𝜑(𝑚)δ m(g)=φ(m)，这等价于同余方程

𝑘 𝑦≡i n d 𝑔⁡𝑎(m o d 𝜑(𝑚)).k y≡ind g⁡a(mod φ(m)).

这是关于 𝑦 y 的 线性同余方程．应用该页面对其解结构的分析，就可以知道方程有解当且仅当 𝑑 ∣i n d 𝑔⁡𝑎 d∣ind g⁡a，且通解形式为

𝑦=𝑦 0+𝑖 𝑑′(m o d 𝜑(𝑚)), 0≤𝑦 0<𝑑′, 𝑖=0,1,⋯,𝑑−1.y=y 0+i d′(mod φ(m)), 0≤y 0<d′, i=0,1,⋯,d−1.

由此，就几乎可以得到本定理的全部内容；唯一需要额外说明的是判别式 𝑎 𝑑′ ≡1(m o d 𝑚)a d′≡1(mod m)．由 阶的性质 3 可知

𝛿 𝑚(𝑎)=𝛿 𝑚(𝑔 i n d 𝑔⁡𝑎)=𝜑(𝑚)g c d(𝜑(𝑚),i n d 𝑔⁡𝑎)=𝜑(𝑚)i n d 𝑔⁡𝑎.δ m(a)=δ m(g ind g⁡a)=φ(m)gcd(φ(m),ind g⁡a)=φ(m)ind g⁡a.

又已知方程有解当且仅当 𝑑 ∣i n d 𝑔⁡𝑎 d∣ind g⁡a，亦即 𝛿 𝑚(𝑎) ∣𝑑′δ m(a)∣d′．由 阶的性质 2 可知，这就等价于该判别式．

模数为 2 2 的幂次的情形较为特殊．为处理这种情形，需要用到关于模 2 𝑒 2 e 既约剩余系结构的一个 结论：所有奇数 𝑎 a 都唯一地同余于某个 ( −1)𝑠 5 𝑟 m o d 2 𝑒(−1)s 5 r mod 2 e 形式的整数，其中，𝑠 ∈{0,1}s∈{0,1} 且 0 ≤𝑟 <2 𝑒−2 0≤r<2 e−2．借助这一结果，可以得到如下结论：

定理

设整数 𝑘 ≥2 k≥2，奇数 𝑎 a 和正整数 𝑚 =2 𝑒 m=2 e 且 𝑒 ≥2 e≥2．那么，当 𝑘 k 是奇数时，有：

1. 𝑎 a 恒为模 𝑚 m 的 𝑘 k 次剩余．
2. 𝑎 a 模 𝑚 m 的 𝑘 k 次方根有且仅有一个．
3. 模 𝑚 m 的 𝑘 k 次剩余类个数为 2 𝑒−1 2 e−1，且它们就是全体既约剩余类．

当 𝑘 k 是偶数时，记 𝑑 =g c d(𝑘,2 𝑒−2)d=gcd(k,2 e−2) 且 𝑑′ =2 𝑒−2 𝑑 d′=2 e−2 d，有：

1. 𝑎 a 为模 𝑚 m 的 𝑘 k 次剩余，当且仅当 𝑎 ≡1(m o d 4)a≡1(mod 4) 且 𝑎 𝑑′ ≡1(m o d 𝑚)a d′≡1(mod m)．

2. 当 𝑎 a 为模 𝑚 m 的 𝑘 k 次剩余时，同余意义下，𝑎 a 模 𝑚 m 恰有 2 𝑑 2 d 个互不相同的 𝑘 k 次方根，且它们具有形式

   𝑥≡±5 𝑦 0+𝑖 𝑑′(m o d 2 𝑒−1), 0≤𝑦 0<𝑑′, 𝑖=0,1,⋯,𝑑−1.x≡±5 y 0+i d′(mod 2 e−1), 0≤y 0<d′, i=0,1,⋯,d−1.

3. 模 𝑚 m 的 𝑘 k 次剩余类的个数为 𝑑′d′，且它们的全体就是

   {5 𝑑 𝑖 m o d 𝑚:0≤𝑖<𝑑′}.{5 d i mod m:0≤i<d′}.

证明

因为 𝑎 ⟂𝑚 a⟂m，所以 𝑥 ⟂𝑚 x⟂m．因为 𝑥 x 和 𝑎 a 都是奇数，由前述结论可知，可以设 𝑎 ≡( −1)𝑠 5 𝑟(m o d 2 𝑒)a≡(−1)s 5 r(mod 2 e) 且 𝑥 =( −1)𝑧 5 𝑦(m o d 2 𝑒)x=(−1)z 5 y(mod 2 e)．因为表示是唯一的，所以同余方程 𝑥 𝑘 ≡𝑎(m o d 2 𝑒)x k≡a(mod 2 e) 等价于 线性同余方程 组

𝑘 𝑧≡𝑠(m o d 2),𝑘 𝑦≡𝑟(m o d 2 𝑒−2).k z≡s(mod 2),k y≡r(mod 2 e−2).

结合该页面对于线性同余方程解的分析，就可以得到同余方程 𝑥 𝑘 ≡𝑎(m o d 2 𝑒)x k≡a(mod 2 e) 解的结构．根据 𝑘 k 的奇偶性不同，可以分为两种情形：

- 当 𝑘 k 是奇数时，因为 g c d(𝑘,2) =g c d(𝑘,2 𝑒−2) =1 gcd(k,2)=gcd(k,2 e−2)=1，所以两个线性同余方程对于所有 𝑠,𝑟 s,r 都有解，故而原同余方程对于所有奇数 𝑎 a 总是有解．

- 当 𝑘 k 是偶数时，第一个方程有解当且仅当 2 ∣𝑠 2∣s，第二个方程有解当且仅当 𝑑 =g c d(𝑘,2 𝑒−2) ∣𝑟 d=gcd(k,2 e−2)∣r．将两者结合就得到 𝑘 k 次剩余类的全体形式．直接计算可知，第一个条件等价于 𝑎 ≡1(m o d 4)a≡1(mod 4)；重复奇素数幂情形的分析可知，第二个条件等价于 𝑎 𝑑′ =1 a d′=1．将两点结合起来就得到定理中的判定方法．两个线性同余方程的通解也是已知的：

  𝑧≡0,1(m o d 2),𝑦≡𝑦 0+𝑖 𝑑′(m o d 2 𝑒−2), 0≤𝑦 0<2 𝑒−2.z≡0,1(mod 2),y≡y 0+i d′(mod 2 e−2), 0≤y 0<2 e−2.

  将两者结合就得到原方程的通解．

这就完全解决了不同模数下 𝑘 k 次剩余的判定问题．二次剩余中的 Legendre 记号和二次互反律等内容也可以推广到高次剩余的情形，但这并不容易，需要用到 分圆域 等概念．在代数数论中，二次互反律最终可以推广到 Artin 互反律．

## 单位根

作为 𝑘 k 次方根的特殊情形，本节讨论 𝑘 k 次（本原）单位根的概念．它可以看作是复数域 𝐂 C 中 𝑘 k 次 单位根 的概念在模 𝑚 m 既约剩余系 𝐙∗𝑚 Z m∗ 中的对应．当模数 𝑚 m 合适时，用模 𝑚 m 的 𝑘 k 次本原单位根代替复数根 𝜔 𝑘 ω k 可以加速计算．

类似于复数域的情形，有如下定义：

模 𝑚 m 的 𝑘 k 次单位根

对于模数 𝑚 m，元素 1 1 的 𝑘 k 次方根称为 模 𝑚 m 的 𝑘 k 次单位根（𝑘 k-th root of unity modulo 𝑚 m）．特别地，如果 𝑥 x 是模 𝑚 m 的一个 𝑘 k 次单位根，且它不是模 𝑚 m 的任何 𝑘′ <𝑘 k′<k 次单位根，那么，也称 𝑥 x 为 模 𝑚 m 的 𝑘 k 次本原单位根（𝑘 k-th primitive root of unity modulo 𝑚 m）．

比较 原根的定义 可知，原根 𝑔 g 就是模 𝑚 m 的 𝜑(𝑚)φ(m) 次本原单位根，其中，𝜑(𝑚)φ(m) 是 欧拉函数．

当模 𝑚 m 的 𝑘 k 次本原单位根存在时，它的代数性质和 𝑘 k 次本原单位复根 𝜔 𝑘 ω k 一致，可以代替 𝜔 𝑘 ω k 进行各种计算．例如，将它应用于 快速傅里叶变换 中，就得到有限域1上的 快速数论变换．

### 性质

复数域中，任意次（本原）单位根都存在．但是，数论中的（本原）单位根并非如此．

性质

对于模数 𝑚 m，设 𝜆(𝑚)λ(m) 为它的 Carmichael 函数，有：

1. 所有与 𝑚 m 互素的整数 𝑎 a 都是模 𝑚 m 的 𝛿 𝑚(𝑎)δ m(a) 次本原单位根，其中，𝛿 𝑚(𝑎)δ m(a) 是 𝑎 a 模 𝑚 m 的 阶．
2. 元素 𝑎 a 是模 𝑚 m 的 𝑘 k 次单位根，且 𝑘′k′ 是 𝑘 k 的任意倍数，那么 𝑎 a 也是模 𝑚 m 的 𝑘′k′ 次单位根．
3. 元素 𝑎 a 是模 𝑚 m 的 𝑘 k 次（本原）单位根，那么元素 𝑎 ℓ a ℓ 是模 𝑚 m 的 𝑘 g c d(𝑘,ℓ)k gcd(k,ℓ) 次（本原，相应地）单位根．
4. 当 𝑘′k′ 遍历 𝑘 k 的因数，所有模 𝑚 m 的 𝑘′k′ 次本原单位根恰构成模 𝑚 m 的 𝑘 k 次单位根的一个划分．而且，对于 ℓ ⟂𝑘 ℓ⟂k，映射 𝑥 ↦𝑥 ℓ x↦x ℓ 给出 𝑘 k 次单位根之间的双射，且保持上述划分不变：它将 𝑘′ ∣𝑘 k′∣k 次本原单位根仍然映射到 𝑘′k′ 次本原单位根．
5. 模 𝑚 m 的 𝑘 k 次本原单位根存在，当且仅当 𝑘 ∣𝜆(𝑚)k∣λ(m)．特别地，模 𝑚 m 的 𝜆(𝑚)λ(m) 次本原单位根存在，称为 模 𝑚 m 的 𝜆 λ‑原根．
6. 元素 𝑎 a 是模 𝑚 m 的 𝑘 k 次单位根，当且仅当 𝑎 𝑘 ≡1(m o d 𝑚)a k≡1(mod m) 且对于任意素因子 𝑝 ∣𝑘 p∣k 都有 𝑎 𝑘/𝑝 ≢1(m o d 𝑚)a k/p≢1(mod m)．

证明

根据阶的定义，所有与 𝑚 m 互素的整数 𝑎 a 都是模 𝑚 m 的 𝛿 𝑚(𝑎)δ m(a) 次本原单位根，其中，𝛿 𝑚(𝑎)δ m(a) 是 𝑎 a 模 𝑚 m 的阶．反过来，如果 𝑎 a 是模 𝑚 m 的 𝑘 k 次单位根，那么 g c d(𝑎 𝑘,𝑚) =1 gcd(a k,m)=1，所以 g c d(𝑎,𝑚) =1 gcd(a,m)=1．因此，𝑎 a 是模 𝑚 m 的（本原）单位根，当且仅当 𝑎 a 与 𝑚 m 互素．这就是性质 1．

直接验证定义可知，只要 𝑘 ∣𝑘′k∣k′，就可以从 𝑎 𝑘 ≡1(m o d 𝑚)a k≡1(mod m) 推出 𝑎 𝑘′ ≡1(m o d 𝑚)a k′≡1(mod m)，这就是性质 2．根据 阶的性质 可知

𝛿(𝑎 ℓ)=𝛿 𝑚(𝑎)g c d(𝛿 𝑚(𝑎),ℓ).δ(a ℓ)=δ m(a)gcd(δ m(a),ℓ).

如果 𝑎 a 是模 𝑚 m 的 𝑘 k 次本原单位根，那么，𝛿 𝑚(𝑎) =𝑘 δ m(a)=k，直接代入上式就得到 𝑎 ℓ a ℓ 是模 𝑚 m 的 𝑘 g c d(𝑘,ℓ)k gcd(k,ℓ) 次本原单位根．如果 𝑎 a 只是模 𝑚 m 的 𝑘 k 次单位根，设它是 𝑘′ ∣𝑘 k′∣k 次本原单位根，故而 𝑎 ℓ a ℓ 是模 𝑚 m 的 𝑘′g c d(𝑘′,ℓ)k′gcd(k′,ℓ) 次本原单位根．由于 𝑘′ ∣𝑘 k′∣k，有

𝑘′g c d(𝑘′,ℓ)∣𝑘 g c d(𝑘,ℓ),k′gcd(k′,ℓ)∣k gcd(k,ℓ),

再由性质 2，就得到 𝑎 ℓ a ℓ 是模 𝑚 m 的 𝑘 g c d(𝑘,ℓ)k gcd(k,ℓ) 次单位根．这就是性质 3．

对于 𝑘′ ∣𝑘 k′∣k，由性质 2，模 𝑚 m 的 𝑘′k′ 次本原单位根必然是模 𝑚 m 的 𝑘 k 次单位根．它们两两不交，故而构成划分．而对于 ℓ ⟂𝑘 ℓ⟂k，总有 ℓ ⟂𝑘′ℓ⟂k′，因此对于模 𝑚 m 的 𝑘′k′ 次本原单位根 𝑎 a，总有 𝑎 ℓ a ℓ 是模 𝑚 m 的 𝑘′k′ 次本原单位根．取 ℓ′ =ℓ−1 m o d 𝑘 ℓ′=ℓ−1 mod k，可以验证 𝑥 ↦𝑥 ℓ x↦x ℓ 和 𝑥 ↦𝑥 ℓ′x↦x ℓ′ 互为逆映射，因此，𝑥 ↦𝑥 ℓ x↦x ℓ 是双射．这就是性质 4．

根据 Carmichael 函数的性质可知，模 𝑚 m 的 𝜆(𝑚)λ(m) 次本原单位根总是存在的，设它为 𝑎 a，且 𝛿 𝑚(𝑎) =𝜆(𝑚)δ m(a)=λ(m)．对于 𝑘 ∣𝜆(𝑚)k∣λ(m)，设 𝑘′ =𝜆(𝑚)𝑘 k′=λ(m)k，总有

𝛿 𝑚(𝑎 𝑘′)=𝜆(𝑚)(𝜆(𝑚),𝑘′)=𝜆(𝑚)𝑘′=𝑘.δ m(a k′)=λ(m)(λ(m),k′)=λ(m)k′=k.

因此，𝑎 𝑘′a k′ 是 𝑘 k 次本原单位根．而根据 Carmichael 函数的定义，所有 𝑥 ⟂𝑚 x⟂m 的阶都是 𝜆(𝑚)λ(m) 的因子．这就得到性质 5．

几乎重复 原根判定定理 的证明，就可以得到性质 6．这一判别方法实际上在验证 𝛿 𝑚(𝑎) =𝑘 δ m(a)=k．

从这些性质可以看出，相对于原根存在的情形，模 𝑚 m 的 𝜆 λ‑原根起到了类似的基础作用．与原根不同的是，𝜆 λ‑原根的幂次并不能用于生成模 𝑚 m 的全体单位根．尽管如此，由于 𝜆 λ‑原根的密度并不低2，如果确实需要找到 𝑘 k 次本原单位根，可以首先通过随机方法找到一个 𝜆 λ‑原根，再通过求幂次得到一个 𝑘 k 次本原单位根．

如果已知 𝑎 a 模 𝑚 m 的一个 𝑘 k 次方根，可以通过模 𝑚 m 的全体 𝑘 k 次单位根生成 𝑎 a 模 𝑚 m 的全体 𝑘 k 次方根．

定理

设 𝑥 x 是 𝑎 a 模 𝑚 m 的一个 𝑘 k 次方根，当 𝑟 r 遍历模 𝑚 m 的全体 𝑘 k 次单位根时，𝑥 𝑟 x r 遍历 𝑎 a 模 𝑚 m 的全体 𝑘 k 次方根．

证明

对于 𝑎 a 模 𝑚 m 的两个 𝑘 k 次方根 𝑥,𝑦 x,y，设 𝑟 =𝑥−1 𝑦 m o d 𝑚 r=x−1 y mod m，那么 𝑟 r 满足 𝑟 𝑘 ≡1(m o d 𝑚)r k≡1(mod m)，是模 𝑚 m 的 𝑘 k 次方根．反过来，只要 𝑟 r 是模 𝑚 m 的 𝑘 k 次单位根，那么，(𝑥 𝑟)𝑘 =𝑥 𝑘 𝑟 𝑘 ≡𝑎(m o d 𝑚)(x r)k=x k r k≡a(mod m)，也就是说，𝑥 𝑟 x r 是模 𝑚 m 的 𝑘 k 次方根．

利用 𝑘 k 次单位根生成全体 𝑘 k 次方根，就类似于利用齐次线性方程组的解生成非齐次线性方程组的通解一样．

前面讨论的是一般情形．仅对于原根存在的情形，单位根的结构更为简单：

定理

对于模数 𝑚 m，设模 𝑚 m 的原根存在，且 𝑎 a 是模 𝑚 m 的 𝑘 k 次本原单位根．那么，𝑏 b 是模 𝑚 m 的 𝑘 k 次单位根，当且仅当它可以表示为 𝑎 a 的幂次．

证明

设 𝑔 g 是模 𝑚 m 的原根，那么，所有与 𝑚 m 互素的元素都可以表示为 𝑔 g 的幂次．那么，𝑎 a 是模 𝑚 m 的 𝑘 k 次本原单位根，当且仅当

𝛿 𝑚(𝑎)=𝛿 𝑚(𝑔 i n d 𝑔⁡𝑎)=𝜑(𝑚)g c d(𝜑(𝑚),i n d 𝑔⁡𝑎)=𝑘.δ m(a)=δ m(g ind g⁡a)=φ(m)gcd(φ(m),ind g⁡a)=k.

类似地，𝑏 b 是模 𝑚 m 的 𝑘 k 次单位根，当且仅当

𝛿 𝑚(𝑏)=𝛿 𝑚(𝑔 i n d 𝑔⁡𝑏)=𝜑(𝑚)g c d(𝜑(𝑚),i n d 𝑔⁡𝑏)=𝑘′∣𝑘.δ m(b)=δ m(g ind g⁡b)=φ(m)gcd(φ(m),ind g⁡b)=k′∣k.

所以，有

g c d(𝜑(𝑚),i n d 𝑔⁡𝑎)∣g c d(𝜑(𝑚),i n d 𝑔⁡𝑏)∣i n d 𝑔⁡𝑏.gcd(φ(m),ind g⁡a)∣gcd(φ(m),ind g⁡b)∣ind g⁡b.

根据对线性同余方程的 分析 可知，这一条件就等价于方程

(i n d 𝑔⁡𝑎)𝑥≡i n d 𝑔⁡𝑏(m o d 𝜑(𝑚))(ind g⁡a)x≡ind g⁡b(mod φ(m))

有解．将这一条件对 𝑔 g 取幂，就得到 𝑎 𝑥 ≡𝑏(m o d 𝑚)a x≡b(mod m)，亦即 𝑏 b 可以表示为 𝑎 a 的幂次．

这一定理说明，原根存在时，全体 𝑘 k 次单位根呈现 循环群 的结构，而 𝑘 k 次本原单位根则是该循环群的生成元．稍后将会看到，Tonelli–Shanks 算法正是利用这一点，加速了开方运算中离散对数部分的计算．

## 模意义下开方

最后，本文讨论 𝑘 k 次方根的求法．对于 𝑘 =2 k=2 的情形，有 很多高效算法 可以用于模意义下开平方运算．但是，对于一般的 𝑘 k，并没有已知的多项式时间算法．本节将介绍两种常见算法，分别可以在 𝑂(𝑚 1/2)O(m 1/2) 和 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε) 时间内求出一个 𝑘 k 次方根．利用中国剩余定理总是可以将问题转换为素数幂模的情形，因此，本节主要讨论素数幂模情形的解法．

### 朴素算法

前文对于 𝑘 k 次剩余性质的 分析 实际上已经指出了一种求解素数幂模下 𝑘 k 次方根的方法．严格来说，前文解决的情形是被开方数 𝑎 a 与模数 𝑚 m 互素的情形．算法过程总结如下：

- 当 𝑚 =𝑝 𝑒 m=p e 是奇素数幂时，设模 𝑚 m 的一个原根是 𝑔 g．那么，方程 𝑥 𝑘 ≡𝑎(m o d 𝑚)x k≡a(mod m) 可以转化为线性同余方程

  𝑘 𝑦≡i n d 𝑔⁡𝑎(m o d 𝜑(𝑚)).k y≡ind g⁡a(mod φ(m)).

  其中，i n d 𝑔⁡𝑎 ind g⁡a 可以通过 BSGS 算法 求出，而 线性同余方程 的全体解容易求出．由此，就可以得到 𝑎 a 的全部 𝑘 k 次方根 𝑥 ≡𝑔 𝑦(m o d 𝑚)x≡g y(mod m)．

  除此之外，还有另一种相仿的思路．同样是设 𝑥 ≡𝑔 𝑦(m o d 𝑚)x≡g y(mod m)，还可以通过变形

  𝑥 𝑘≡(𝑔 𝑘)𝑦≡𝑎(m o d 𝑚)x k≡(g k)y≡a(mod m)

  转化为求底数为 𝑔 𝑘 g k 时 𝑎 a 的离散对数．这同样可以通过 BSGS 算法找到一组特解．它的通解可以通过前文的解的表达式求出，也就是将特解与全体 𝑘 k 次单位根逐一相乘得到．

  无论采用哪种思路，原根已知时，该算法求出单个解的复杂度都是 𝑂(𝑚 1/2)O(m 1/2)．因为可以在 𝑜(𝑚 1/2)o(m 1/2) 时间内找到一个原根，所以，总的时间复杂度仍然是 𝑂(𝑚 1/2)O(m 1/2)．

- 当 𝑚 =2 𝑒 m=2 e 且 𝑒 ∈𝐍+e∈N+ 时，可以首先求出 𝑎 ≡( −1)𝑠 5 𝑟(m o d 𝑚)a≡(−1)s 5 r(mod m) 中的 𝑠,𝑟 s,r．这两个指数中，𝑠 s 可以在 𝑂(1)O(1) 时间内确定：

  𝑠={0,𝑎≡1(m o d 4),1,𝑎≡3(m o d 4).s={0,a≡1(mod 4),1,a≡3(mod 4).

  而 𝑟 =i n d 5⁡(( −1)𝑠 𝑎)r=ind 5⁡((−1)s a) 可以通过 BSGS 算法在 𝑂(𝑚 1/2)O(m 1/2) 时间内求出．接下来，只需要求解线性同余方程组：

  𝑘 𝑧≡𝑠(m o d 2),𝑘 𝑦≡𝑟(m o d 2 𝑒−2).k z≡s(mod 2),k y≡r(mod 2 e−2).

  这个线性方程组的通解 (𝑧,𝑦)(z,y) 容易求出，而 𝑥 =( −1)𝑧 5 𝑦 x=(−1)z 5 y 就是所求的方根．这一算法求出单个解的复杂度仍然是 𝑂(𝑚 1/2)O(m 1/2)．

当然，对于无解的情形，其实可以通过前文叙述的判别方法在 𝑂(l o g⁡𝑚)O(log⁡m) 时间内快速判断，而无需在求解过程中判断．

求素数模 𝑘 k 次方根的参考实现如下：（代码仅作示意，由于时间复杂度过高，无法通过本题）

模板题 Library Checker - Kth Root (Mod) 参考实现

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    // Submission (TLE): https://judge.yosupo.jp/submission/320582
    #include <algorithm>
    #include <cmath>
    #include <iostream>
    #include <tuple>
    #include <unordered_map>
    #include <vector>

    struct PrimePower {
      int p, e, pe;

      PrimePower(int p, int e, int pe) : p(p), e(e), pe(pe) {}
    };

    // Factorization.
    auto factorize(int n) {
      std::vector<PrimePower> ans;
      for (int x = 2; x * x <= n; ++x) {
        int e = 0, pe = 1;
        for (; n % x == 0; n /= x, ++e, pe *= x);
        if (e) ans.emplace_back(x, e, pe);
      }
      if (n > 1) ans.emplace_back(n, 1, n);
      return ans;
    }

    // Binary exponentiation.
    int pow(int a, int b, int m = 0) {
      int res = 1;
      for (; b; b >>= 1) {
        if (b & 1) res = m ? (long long)res * a % m : res * a;
        a = m ? (long long)a * a % m : a * a;
      }
      return res;
    }

    // Find a primitive root modulo prime.
    int primitive_root(int p) {
      std::vector<int> exp;
      for (auto factor : factorize(p - 1)) {
        exp.push_back((p - 1) / factor.p);
      }
      int ans = 0;
      bool succ = false;
      while (!succ) {
        ++ans;
        succ = true;
        for (int b : exp) {
          if (pow(ans, b, p) == 1) {
            succ = false;
            break;
          }
        }
      }
      return ans;
    }

    // Discrete logarithm. (BSGS Algorithm)
    int log(int g, int a, int m) {
      int b = std::sqrt(m + 0.25l) + 1;
      std::unordered_map<int, int> mp;
      int po0 = a % m, po1 = 1;
      for (int i = 0; i < b; ++i) {
        mp[po0] = i;
        po0 = (long long)po0 * g % m;
      }
      po0 = pow(g, b, m);
      for (int j = 1; j <= b; ++j) {
        po1 = (long long)po1 * po0 % m;
        if (mp.count(po1)) return j * b - mp[po1];
      }
      return -1;
    }

    // Extended Euclidean Algorithm.
    int ex_gcd(int a, int b, int& x, int& y) {
      if (!b) {
        x = 1;
        y = 0;
        return a;
      } else {
        int d = ex_gcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
      }
    }

    // Solves the linear congruence equation: Ax = B mod N.
    // Return the least nonnegative solution and the common difference.
    std::pair<int, int> solve_linear(int a, int b, int n) {
      int x, y;
      int d = ex_gcd(a, n, x, y);
      if (b % d) return {-1, -1};
      n /= d;
      x = ((long long)x * (b / d) % n + n) % n;
      return {x, n};
    }

    // Subroutine: Find a K-th root with a primitive root G known.
    int calc(int g, int k, int a, int p) {
      int ind = log(g, a, p);
      if (ind == -1) return -1;
      int y0, d;
      std::tie(y0, d) = solve_linear(k, ind, p - 1);
      if (y0 == -1) return -1;
      return pow(g, y0, p);
    }

    // Find a K-th root of A modulo prime P.
    int kth_roots_mod_p(int k, int a, int p) {
      a %= p;
      if (k == 0) return a == 1 ? 0 : -1;
      if (a == 0) return 0;
      return calc(primitive_root(p), k, a, p);
    }

    void solve() {
      int k, y, p;
      std::cin >> k >> y >> p;
      std::cout << kth_roots_mod_p(k, y, p) << '\n';
    }

    int main() {
      int t;
      std::cin >> t;
      for (; t; --t) {
        solve();
      }
    }

### 改良 Tonelli–Shanks 算法

将用于模意义下开平方的 Tonelli–Shanks 算法 做适当推广，就可以解决素数幂模下开方运算．一种较为直接的推广方式是 Adleman–Manders–Miller 算法3，但是它的复杂度仍然不够优秀4．本节介绍由 sugarknri、Min_25、37zigen 等人提出的改良 Tonelli–Shanks 算法．它可以在 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε) 时间内求出一个 𝑘 k 次方根．

Tonelli–Shanks 算法的核心想法是，将离散对数的求解放到阶为 2 𝑒 2 e 的群里，进而降低时间复杂度．类似地，对于任意素数幂 𝑝 𝑒 p e 阶群内的离散对数，同样可以较为高效地求解，但是算法的复杂度为 Ω(√𝑝)Ω(p)．Adleman–Manders–Miller 算法将 𝑘 k 次方根的求解分拆为多个素数幂阶群内离散对数的计算，但是受限于 𝑘 k 的最大素因子 𝑝 m a x(𝑘)p max(k) 的大小，算法复杂度仍然为 Ω(√𝑝 m a x(𝑘))Ω(p max(k))．本节算法进一步改良了这一过程，避免了对较大的素因子计算离散对数，进而将整体复杂度控制到 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε)．

#### 过程

考虑素数幂模 𝑚 m 下 𝑎 a 的 𝑘 k 次方根的计算，即求解同余方程：

𝑥 𝑘≡𝑎(m o d 𝑚).x k≡a(mod m).

特别地，对于 𝑚 =2 𝑒 m=2 e 的情形，还需要保证 𝑎 ≡1(m o d 4)a≡1(mod 4)，进而 𝑎 a 可以写成 𝑔 =5 g=5 的幂次．类似前文讨论，模 2 𝑒 2 e 下 𝑘 k 次方根的计算总是可以转化为这样的情形．处理模 2 𝑒 2 e 的情形时，本节提到的 𝜑(𝑚)φ(m) 都应换作 𝛿 𝑚(5) =2 𝑒−2 δ m(5)=2 e−2．

首先，问题可以转化为开方次数整除 𝜑(𝑚)φ(m) 的情形．设 𝑑 =g c d(𝑘,𝜑(𝑚))d=gcd(k,φ(m))．那么，由 𝑘 k 次剩余的性质可知，当 𝑎 a 模 𝑚 m 是 𝑘 k 次剩余时，𝑎 a 总是模 𝑚 m 的 𝜑(𝑚)𝑑 φ(m)d 次单位根．根据单位根的性质，对于任意 ℓ ⟂𝜑(𝑚)𝑑 ℓ⟂φ(m)d，映射 𝑥 ↦𝑥 ℓ x↦x ℓ 都是 𝜑(𝑚)𝑑 φ(m)d 次单位根之间的双射．因此，可以取

ℓ=(𝑘 𝑑)−1 m o d 𝜑(𝑚)𝑑.ℓ=(k d)−1 mod φ(m)d.

将原来的同余方程两侧同时取 ℓ ℓ 次幂，就得到

𝑥 𝑑≡𝑥 𝑘 ℓ≡𝑎 ℓ=:𝑏(m o d 𝑚).x d≡x k ℓ≡a ℓ=:b(mod m).

最左侧同余号利用了 欧拉定理 和如下同余关系：（𝑐 ∈𝐙 c∈Z）

𝑘 ℓ=𝑑(𝑘 𝑑 ℓ)=𝑑(𝑐 𝜑(𝑚)𝑑+1)≡𝑑(m o d 𝜑(𝑚)).k ℓ=d(k d ℓ)=d(c φ(m)d+1)≡d(mod φ(m)).

对于转化后的问题，考虑 𝑑 d 的素因数分解：

𝑑=∏𝑝∈𝐏 𝑝 𝑒.d=∏p∈P p e.

可以从 𝑏 =𝑎 ℓ b=a ℓ 开始，对每个 𝑝 𝑒 ≠1 p e≠1，依次开 𝑝 𝑒 p e 次方，最后就能得到 𝑏 b 的 𝑑 d 次方根，也就是 𝑎 a 的 𝑘 k 次方根．

最后，问题转化为如何求如下方程的解：

𝑥 𝑝 𝑒≡𝑏(m o d 𝑚).x p e≡b(mod m).

不妨设 𝜑(𝑚) =𝑝 𝑠 𝑟 φ(m)=p s r 且 𝑝 ⟂𝑟 p⟂r．设 𝑞 ∈𝐍+q∈N+ 是方程 𝑞 𝑟 ≡ −1(m o d 𝑝 𝑒)q r≡−1(mod p e) 的解．那么，因为 𝑏 b 是 𝑟 𝑝 𝑠−𝑒 r p s−e 次单位根，所以 𝑏 𝑞 𝑟 b q r 一定是 𝑝 𝑠−𝑒 p s−e 次单位根．又设 𝜁 ζ 是模 𝑚 m 的 𝑝 𝑠 p s 次本原单位根．那么，𝜁 𝑝 𝑒 ζ p e 是 𝑝 𝑠−𝑒 p s−e 次本原单位根，进而存在 ℎ ∈𝐍 h∈N 使得 𝑏 𝑞 𝑟 ≡𝜁 ℎ 𝑝 𝑒(m o d 𝑚)b q r≡ζ h p e(mod m)．所以，直接验证可知

𝑥≡𝑏(𝑞 𝑟+1)/𝑝 𝑒 𝜁−ℎ(m o d 𝑚)x≡b(q r+1)/p e ζ−h(mod m)

是 𝑏 b 模 𝑚 m 的 𝑝 𝑒 p e 次方根．

为了计算 𝑥 x，需要找到模 𝑚 m 的一个 𝑝 p 次非剩余 𝜂 η．为此，由前文性质，只需要随机 𝜂 ⟂𝑚 η⟂m 并验证 𝜂 𝜑(𝑚)/𝑝 m o d 𝑚 ≠1 η φ(m)/p mod m≠1 即可．这样的数的密度是

𝜑(𝑚)𝑚(1−1 𝑝)≥1 4.φ(m)m(1−1 p)≥1 4.

因此，期望随机不超过 4 4 个整数就能找到它．注意到，𝜂 𝑟 𝑝 𝑠−1 ≢1(m o d 𝑚)η r p s−1≢1(mod m) 且 𝜂 𝑟 𝑝 𝑠 ≡1(m o d 𝑚)η r p s≡1(mod m)，所以，如果设 𝜁 =𝜂 𝑟 m o d 𝑚 ζ=η r mod m 和 𝜉 =𝜂 𝑟 𝑝 𝑠−1 m o d 𝑚 ξ=η r p s−1 mod m，那么它们分别是 𝑝 𝑠 p s 次和 𝑝 p 次本原单位根．

最后，需要计算 ℎ ∈𝐍 h∈N．显然，可以取 ℎ <𝑝 𝑠−𝑒 h<p s−e．考虑 ℎ h 的 𝑝 p 进制表示：

ℎ=𝑠−𝑒−1∑𝑗=0 ℎ 𝑗 𝑝 𝑗=ℎ 0+ℎ 1 𝑝+ℎ 2 𝑝 2+⋯.h=∑j=0 s−e−1 h j p j=h 0+h 1 p+h 2 p 2+⋯.

逐位计算这些数位．当前 𝑗 j 个数位都计算完成时，必然有

(𝑏 𝑞 𝑟 𝜁−𝑝 𝑒(ℎ 0+ℎ 1 𝑝+⋯+ℎ 𝑗−1 𝑝 𝑗−1))𝑝 𝑠−𝑒−𝑗−1≡𝜁 ℎ 𝑗 𝑝 𝑠−1≡𝜉 ℎ 𝑗(m o d 𝑚).(b q r ζ−p e(h 0+h 1 p+⋯+h j−1 p j−1))p s−e−j−1≡ζ h j p s−1≡ξ h j(mod m).

故而，ℎ 𝑗 h j 可以通过计算关于 𝜉 ξ 的离散对数求出．为了获得更好的时间复杂度，需要使用 BSGS 算法．总共需要计算 (𝑠 −𝑒)(s−e) 次离散对数，设预处理 𝐵 B 个 𝜉 ξ 的幂次，则单次求解离散对数的时间复杂度为 𝑂(𝑝/𝐵)O(p/B)，总的时间复杂度为

𝑂(𝐵+(𝑠−𝑒)𝑝 𝐵).O(B+(s−e)p B).

当 𝐵 =√(𝑠−𝑒)𝑝 B=(s−e)p 时，总的时间复杂度最低，为 𝑂(√(𝑠−𝑒)𝑝)O((s−e)p)．得到 ℎ h 之后，代入前文 𝑥 x 的表达式，就可以找到一个特解．

#### 时间复杂度

这一算法的时间复杂度为 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε)．本节讨论复杂度时，总是假设单次乘法需要 𝑂(1)O(1) 时间，且计算幂次时，总是应用欧拉定理降幂，则涉及的单个幂的计算总是可以在 𝑂(l o g⁡𝑚)O(log⁡m) 时间内完成．

先考虑单个 𝑝 𝑒 p e 次方根的计算．找到 𝑝 p 次非剩余只需要验证期望 𝑂(1)O(1) 个数，总时间复杂度为 𝑂(l o g⁡𝑚)O(log⁡m)．计算 𝑠,𝑟,𝜁,𝜂,𝑏 𝑞 𝑟 s,r,ζ,η,b q r 各只需要 𝑂(l o g⁡𝑚)O(log⁡m) 时间．计算 ℎ h 时，单个数位需要通过 𝑂(l o g⁡𝑚)O(log⁡m) 时间计算幂次，总共 (𝑠 −𝑒)(s−e) 位，故而总的时间复杂度为 𝑂((𝑠 −𝑒)l o g⁡𝑚)O((s−e)log⁡m)．前文已经说明，计算离散对数的部分预处理和 (𝑠 −𝑒)(s−e) 次查询的总时间为 𝑂(√(𝑠−𝑒)𝑝)O((s−e)p)．因为 𝑠 −𝑒 ∈𝑂(l o g⁡𝑚)s−e∈O(log⁡m)，所以单个 𝑝 𝑒 p e 次方根的计算的时间复杂度为 𝑂(𝑝 1/2+𝜀)O(p 1/2+ε)．特别地，当 𝑠 =𝑒 s=e 时，时间复杂度可以进一步减少为 𝑂(l o g⁡𝑚)O(log⁡m)．

进而，可以考虑算法总的时间复杂度．计算 𝜑(𝑚),𝑑,ℓ φ(m),d,ℓ 的时间复杂度均为 𝑂(l o g⁡𝑚)O(log⁡m)．紧接着需要做素因数分解 𝑑 =∏𝑝 𝑝 𝑒 d=∏p p e，这一步利用 Pollard Rho 算法 可以在 𝑂(𝑚 1/4)O(m 1/4) 时间内完成．最后，依次求 𝑝 𝑒 p e 次方根的总时间复杂度为

𝑂(∑𝑒<𝑠 𝑝 1/2+𝜀).O(∑e<s p 1/2+ε).

由于满足 𝑒 <𝑠 e<s 的素因子 𝑝 p 至少在 𝜑(𝑚)φ(m) 中出现 2 2 次，必然有 𝑝 <𝑚 1/2 p<m 1/2．故而，总时间复杂度为 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε)．

事实上，在这一情景中，无需使用 Pollard Rho 算法分解素因数，仍然可以获得 𝑂(𝑚 1/4+𝜀)O(m 1/4+ε) 的时间复杂度．事实上，只需要对 𝑑 d 暴力试除进行分解，并只枚举到不超过 𝑚 1/4 m 1/4 的素因子．设去除这些小素因子后得到的整数为 𝑧 z．那么，对于 𝑧 z 的素因子 𝑝 >𝑚 1/4 p>m 1/4，必然有 𝜈 𝑝(𝜑(𝑚)) <4 ν p(φ(m))<4，其中，𝜈 𝑝(𝑛)ν p(n) 表示 𝑛 n 的素因数分解中 𝑝 p 的次数．由于只需要考虑

1≤𝑒=𝜈 𝑝(𝑑)<𝑠=𝜈 𝑝(𝜑(𝑚))<4 1≤e=ν p(d)<s=ν p(φ(m))<4

的情形，满足该条件的素因子 𝑝 p 至多只能有一个；否则，它们在 𝜑(𝑚)φ(m) 中的次数都不小于 2 2，总的乘积必然超过 𝑚 m．要分离出这个（可能存在的）唯一的大素因子，只需要计算

𝑝⋆=g c d(𝑧,𝜑(𝑚)𝑧)=∏𝑝:𝜈 𝑝(𝑑)<𝜈 𝑝(𝜑(𝑚))𝑝 m i n{𝜈 𝑝(𝑑),𝜈 𝑝(𝜑(𝑚))−𝜈 𝑝(𝑑)}.p⋆=gcd(z,φ(m)z)=∏p:ν p(d)<ν p(φ(m))p min{ν p(d),ν p(φ(m))−ν p(d)}.

枚举 𝜈 𝑝(𝑑),𝜈 𝑝(𝜑(𝑚))ν p(d),ν p(φ(m)) 的所有可能性可知，乘积中 𝑝 p 的次数一定是 1 1，因此这样算出来的就是唯一的大素因子 𝑝⋆p⋆（如果存在的话）．至于剩余的部分 𝑧/𝑝⋆z/p⋆，因为其中只能包含若干满足 𝑒 =𝑠 e=s 的素因子，所以无需继续分解．

求素数模 𝑘 k 次方根的参考实现如下：

模板题 Library Checker - Kth Root (Mod) 参考实现

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    #include <algorithm>
    #include <cmath>
    #include <iostream>
    #include <random>
    #include <tuple>
    #include <unordered_map>
    #include <vector>

    std::mt19937 rng(std::random_device{}());

    // Binary exponentiation.
    int pow(int a, int b, int m = 0) {
      int res = 1;
      for (; b; b >>= 1) {
        if (b & 1) res = m ? (long long)res * a % m : res * a;
        a = m ? (long long)a * a % m : a * a;
      }
      return res;
    }

    // Find a P-th non-residue mod M.
    int non_residue(int p, int m, int phi) {
      std::uniform_int_distribution<int> dis(1, m - 1);
      while (true) {
        int c = dis(rng);
        if (pow(c, phi / p, m) != 1) return c;
      }
      return -1;
    }

    // Euclidean Algorithm.
    int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

    // Extended Euclidean Algorithm.
    int ex_gcd(int a, int b, int& x, int& y) {
      if (!b) {
        x = 1;
        y = 0;
        return a;
      } else {
        int d = ex_gcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
      }
    }

    // Returns the modular inverse of A modulo M.
    // Assumes that gcd(A, M) = 1, so the inverse exists.
    int inv(int a, int m) {
      int x, y;
      ex_gcd(a, m, x, y);
      return (x % m + m) % m;
    }

    // Subroutine: Find a P^E-th root of A mod M.
    int peth_root_mod_m(int p, int e, int a, int m, int phi) {
      int s = 0, r = phi, pe = pow(p, e);
      for (; r % p == 0; r /= p, ++s);
      int q = pe - inv(r, pe);
      int ans = pow(a, ((long long)q * r + 1) / pe % phi, m);
      int eta = non_residue(p, m, phi);
      std::unordered_map<int, int> mp;
      int zeta = pow(eta, r, m);
      int xi = pow(eta, phi / p, m);
      // Precompute powers for BSGS.
      int B = std::sqrt((s - e) * p + 0.25l) + 1;
      int pB = p / B + 1;
      int po0 = pow(xi, pB, m);
      for (int j = 1, po1 = 1; j <= B; ++j) {
        po1 = (long long)po1 * po0 % m;
        mp[po1] = j;
      }
      // Compute p-adic digits of h.
      for (int j = 0; j < s - e; ++j) {
        int err = (long long)pow(ans, pe, m) * inv(a, m) % m;
        int xi_hj = pow(err, pow(p, s - e - j - 1), m);
        long long hj = 0;
        // BSGS query.
        for (int i = 1; i <= pB; ++i) {
          xi_hj = (long long)xi_hj * xi % m;
          if (mp.count(xi_hj)) {
            hj = mp[xi_hj] * pB - i;
            break;
          }
        }
        ans = (long long)ans * pow(zeta, phi - hj * pow(p, j) % phi, m) % m;
      }
      return ans;
    }

    // Find a K-th root of A modulo prime P.
    int kth_root_mod_p(int k, int a, int p) {
      a %= p;
      if (k == 0) return a == 1 ? 0 : -1;
      if (a == 0) return 0;
      int d = gcd(k, p - 1);
      if (pow(a, (p - 1) / d, p) != 1) return -1;
      a = pow(a, inv(k / d, (p - 1) / d), p);
      for (int dp = 2; dp * dp <= d && dp * dp * dp * dp < p; ++dp) {
        if (d % dp == 0) {
          int de = 0;
          for (; d % dp == 0; d /= dp, ++de);
          a = peth_root_mod_m(dp, de, a, p, p - 1);
        }
      }
      if (d != 1) {
        int dp = gcd(d, (p - 1) / d), de = 0;
        if (dp != 1) {
          for (; d % dp == 0; d /= dp, ++de);
          a = peth_root_mod_m(dp, de, a, p, p - 1);
        }
        if (d != 1) a = peth_root_mod_m(d, 1, a, p, p - 1);
      }
      return a;
    }

    void solve() {
      int k, y, p;
      std::cin >> k >> y >> p;
      std::cout << kth_root_mod_p(k, y, p) << '\n';
    }

    int main() {
      int t;
      std::cin >> t;
      for (; t; --t) {
        solve();
      }
    }

### 一般情形的处理

考虑一般的情形，仍然设模数 𝑚 m 是素数幂 𝑝 𝑒 p e，但是 g c d(𝑎,𝑚) >1 gcd(a,m)>1．如果 𝑎 ≡0(m o d 𝑚)a≡0(mod m)，那么

𝑥=𝑝⌈𝑒/𝑘⌉ℓ(m o d 𝑝 𝑒), ℓ=0,1,⋯,𝑝 𝑒−⌈𝑒/𝑘⌉−1 x=p⌈e/k⌉ℓ(mod p e), ℓ=0,1,⋯,p e−⌈e/k⌉−1

都是原方程的解．接下来，考察 𝑎 ≢0(m o d 𝑚)a≢0(mod m) 的情形．设 𝑎 =𝑝 𝑠 𝑎′a=p s a′ 且 𝑝 ⟂𝑎′p⟂a′．于是，设 𝑥 =𝑝 𝑧 𝑥′x=p z x′ 且 𝑝 ⟂𝑥′p⟂x′，就有

𝑥 𝑘=𝑝 𝑘 𝑧(𝑥′)𝑘≡𝑝 𝑠 𝑎′(m o d 𝑝 𝑒).x k=p k z(x′)k≡p s a′(mod p e).

由于 (𝑥′)𝑘 ⟂𝑝(x′)k⟂p，所以该式成立当且仅当 𝑘 𝑧 =𝑠 k z=s 且 (𝑥′)𝑘 ≡𝑎′(m o d 𝑝 𝑒−𝑠)(x′)k≡a′(mod p e−s)．当且仅当 𝑘 ∣𝑠 k∣s 时，第一个方程有解 𝑧 =𝑠 𝑘 z=s k；而第二个方程的求解已经解决．需要注意的是，因为第二个方程的通解的模数与原方程通解的模数并不相同，所以第二个方程的每一个解 𝑥′x′，都对应原方程的若干解：

𝑥≡𝑝 𝑠/𝑘(𝑥′+ℓ 𝑝 𝑒−𝑠)(m o d 𝑝 𝑒), ℓ=0,1,⋯,𝑝 𝑠−𝑠/𝑘−1.x≡p s/k(x′+ℓ p e−s)(mod p e), ℓ=0,1,⋯,p s−s/k−1.

求解任一模数下全体 𝑘 k 次方根的参考实现如下：

模板题 Luogu P5668【模板】N 次剩余 参考代码
朴素算法改良 Tonelli–Shanks 算法

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    #include <algorithm>
    #include <cmath>
    #include <iostream>
    #include <tuple>
    #include <unordered_map>
    #include <vector>

    struct PrimePower {
      int p, e, pe;

      PrimePower(int p, int e, int pe) : p(p), e(e), pe(pe) {}
    };

    // Factorization.
    auto factorize(int n) {
      std::vector<PrimePower> ans;
      for (int x = 2; x * x <= n; ++x) {
        int e = 0, pe = 1;
        for (; n % x == 0; n /= x, ++e, pe *= x);
        if (e) ans.emplace_back(x, e, pe);
      }
      if (n > 1) ans.emplace_back(n, 1, n);
      return ans;
    }

    // Binary exponentiation.
    int pow(int a, int b, int m = 0) {
      int res = 1;
      for (; b; b >>= 1) {
        if (b & 1) res = m ? (long long)res * a % m : res * a;
        a = m ? (long long)a * a % m : a * a;
      }
      return res;
    }

    // Find a primitive root modulo odd prime power.
    int primitive_root(PrimePower pp) {
      std::vector<int> exp;
      int phi = pp.pe / pp.p * (pp.p - 1);
      for (auto factor : factorize(pp.p - 1)) {
        exp.push_back(phi / factor.p);
      }
      if (pp.e != 1) exp.push_back(phi / pp.p);
      int ans = 0;
      bool succ = false;
      while (!succ) {
        ++ans;
        succ = true;
        for (int b : exp) {
          if (pow(ans, b, pp.pe) == 1) {
            succ = false;
            break;
          }
        }
      }
      return ans;
    }

    // Discrete logarithm. (BSGS Algorithm)
    int log(int g, int a, int m) {
      int b = std::sqrt(m + 0.25l) + 1;
      std::unordered_map<int, int> mp;
      int po0 = a % m, po1 = 1;
      for (int i = 0; i < b; ++i) {
        mp[po0] = i;
        po0 = (long long)po0 * g % m;
      }
      po0 = pow(g, b, m);
      for (int j = 1; j <= b; ++j) {
        po1 = (long long)po1 * po0 % m;
        if (mp.count(po1)) return j * b - mp[po1];
      }
      return -1;
    }

    // Extended Euclidean Algorithm.
    int ex_gcd(int a, int b, int& x, int& y) {
      if (!b) {
        x = 1;
        y = 0;
        return a;
      } else {
        int d = ex_gcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
      }
    }

    // Returns the modular inverse of A modulo M.
    // Assumes that gcd(A, M) = 1, so the inverse exists.
    int inv(int a, int m) {
      int x, y;
      ex_gcd(a, m, x, y);
      return (x % m + m) % m;
    }

    // Solves the linear congruence equation: Ax = B mod N.
    // Return the least nonnegative solution and the common difference.
    std::pair<int, int> solve_linear(int a, int b, int n) {
      int x, y;
      int d = ex_gcd(a, n, x, y);
      if (b % d) return {-1, -1};
      n /= d;
      x = ((long long)x * (b / d) % n + n) % n;
      return {x, n};
    }

    // Subroutine: Find all the K-th roots with a primitive root G known.
    std::vector<int> calc(int g, int k, int a, int p, int pe) {
      int ind = log(g, a, pe);
      if (ind == -1) return {};
      int mm = p == 2 ? pe / 4 : pe / p * (p - 1);
      int y0, d;
      std::tie(y0, d) = solve_linear(k, ind, mm);
      if (y0 == -1) return {};
      int ans = pow(g, y0, pe), po = pow(g, d, pe);
      std::vector<int> res(mm / d);
      for (auto& x : res) {
        x = ans;
        ans = (long long)ans * po % pe;
      }
      return res;
    }

    // Find all the K-th roots of A modulo prime power P^E.
    std::vector<int> kth_roots_mod_pe(int k, int a, PrimePower pp) {
      int p = pp.p, e = pp.e, pe = pp.pe;
      a %= pe;
      if (a == 0) {
        int d = pow(p, (e - 1) / k + 1);
        std::vector<int> res(pe / d);
        for (int i = 0; i < pe / d; ++i) {
          res[i] = i * d;
        }
        return res;
      }
      int s = 0;
      for (; a % p == 0; a /= p, ++s);
      if (s % k) return {};
      int psk = pow(p, s / k), pss = pow(p, s - s / k), pes = pow(p, e - s);
      std::vector<int> res;
      if (p != 2) {
        int g = primitive_root(PrimePower(p, e - s, pes));
        res = calc(g, k, a, p, pes);
      } else if (pes == 2) {
        res.push_back(a);
      } else if (k & 1) {
        int z = a % 4 == 3;
        a = z ? pes - a : a;
        res = calc(5, k, a, p, pes);
        if (z) {
          for (auto& x : res) x = pes - x;
        }
      } else {
        if (a % 4 == 3) return {};
        res = calc(5, k, a, p, pes);
        int m = res.size();
        res.reserve(m * 2);
        for (int i = 0; i < m; ++i) {
          res.push_back(pes - res[i]);
        }
      }
      int m = res.size();
      res.reserve(m * pss);
      for (int j = 1; j < pss; ++j) {
        for (int i = 0; i < m; ++i) {
          res.push_back(res.end()[-m] + pes);
        }
      }
      for (auto& x : res) x *= psk;
      return res;
    }

    // Find all the K-th roots of A modulo positive integer M.
    std::vector<int> kth_roots_mod_m(int k, int a, int m) {
      auto factors = factorize(m);
      int m0 = 0;
      std::vector<std::vector<int>> sols;
      for (const auto& pp : factors) {
        sols.push_back(kth_roots_mod_pe(k, a, pp));
        if (sols.back().empty()) return {};
      }
      std::vector<int> ans;
      for (int i = 0; i < (int)factors.size(); ++i) {
        auto pp = factors[i];
        if (!i) {
          m0 = pp.pe;
          ans = sols[i];
        } else {
          long long m1 = pp.pe * inv(pp.pe, m0);
          long long m2 = m0 * inv(m0, pp.pe);
          m0 *= pp.pe;
          std::vector<int> _ans;
          _ans.reserve(ans.size() * sols[i].size());
          for (auto x : ans) {
            for (auto y : sols[i]) {
              _ans.push_back((m1 * x + m2 * y) % m0);
            }
          }
          ans.swap(_ans);
        }
      }
      return ans;
    }

    void solve() {
      int n, m, k;
      std::cin >> n >> m >> k;
      auto ans = kth_roots_mod_m(n, k, m);
      if (ans.empty()) {
        std::cout << 0 << '\n';
        return;
      }
      std::cout << ans.size() << '\n';
      std::sort(ans.begin(), ans.end());
      for (auto x : ans) std::cout << x << ' ';
      std::cout << '\n';
    }

    int main() {
      int t;
      std::cin >> t;
      for (; t; --t) {
        solve();
      }
    }

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    #include <algorithm>
    #include <cmath>
    #include <iostream>
    #include <random>
    #include <tuple>
    #include <unordered_map>
    #include <vector>

    std::mt19937 rng(std::random_device{}());

    struct PrimePower {
      int p, e, pe;

      PrimePower(int p, int e, int pe) : p(p), e(e), pe(pe) {}
    };

    // Factorization.
    auto factorize(int n) {
      std::vector<PrimePower> ans;
      for (int x = 2; x * x <= n; ++x) {
        int e = 0, pe = 1;
        for (; n % x == 0; n /= x, ++e, pe *= x);
        if (e) ans.emplace_back(x, e, pe);
      }
      if (n > 1) ans.emplace_back(n, 1, n);
      return ans;
    }

    // Binary exponentiation.
    int pow(int a, int b, int m = 0) {
      int res = 1;
      for (; b; b >>= 1) {
        if (b & 1) res = m ? (long long)res * a % m : res * a;
        a = m ? (long long)a * a % m : a * a;
      }
      return res;
    }

    // Find a primitive root modulo odd prime power.
    int primitive_root(PrimePower pp) {
      std::vector<int> exp;
      int phi = pp.pe / pp.p * (pp.p - 1);
      for (auto factor : factorize(pp.p - 1)) {
        exp.push_back(phi / factor.p);
      }
      if (pp.e != 1) exp.push_back(phi / pp.p);
      int ans = 0;
      bool succ = false;
      while (!succ) {
        ++ans;
        succ = true;
        for (int b : exp) {
          if (pow(ans, b, pp.pe) == 1) {
            succ = false;
            break;
          }
        }
      }
      return ans;
    }

    // Euclidean Algorithm.
    int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

    // Extended Euclidean Algorithm.
    int ex_gcd(int a, int b, int& x, int& y) {
      if (!b) {
        x = 1;
        y = 0;
        return a;
      } else {
        int d = ex_gcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
      }
    }

    // Returns the modular inverse of A modulo M.
    // Assumes that gcd(A, M) = 1, so the inverse exists.
    int inv(int a, int m) {
      int x, y;
      ex_gcd(a, m, x, y);
      return (x % m + m) % m;
    }

    // Find a P-th non-residue mod M.
    int non_residue(int p, int m, int phi) {
      std::uniform_int_distribution<int> dis(1, m - 1);
      while (true) {
        int c = dis(rng);
        if (gcd(c, m) == 1 && pow(c, phi / p, m) != 1) return c;
      }
      return -1;
    }

    // Subroutine: Find a P^E-th root of A mod M.
    int peth_root_mod_m(int p, int e, int a, int m, int phi) {
      if (m == 2) return 1;
      int s = 0, r = phi, pe = pow(p, e);
      for (; r % p == 0; r /= p, ++s);
      int q = pe - inv(r, pe);
      int ans = pow(a, ((long long)q * r + 1) / pe % phi, m);
      int eta = non_residue(p, m, phi);
      std::unordered_map<int, int> mp;
      int zeta = pow(eta, r, m);
      int xi = pow(eta, phi / p, m);
      // Precompute powers for BSGS.
      int B = std::sqrt((s - e) * p + 0.25l) + 1;
      int pB = pe / B + 1;
      int po0 = pow(xi, pB, m);
      for (int j = 1, po1 = 1; j <= B; ++j) {
        po1 = (long long)po1 * po0 % m;
        mp[po1] = j;
      }
      // Compute p-adic digits of h.
      for (int j = 0; j < s - e; ++j) {
        int err = (long long)pow(ans, pe, m) * inv(a, m) % m;
        int xi_hj = pow(err, pow(p, s - e - j - 1), m);
        long long hj = 0;
        // BSGS query.
        for (int i = 1; i <= pB; ++i) {
          xi_hj = (long long)xi_hj * xi % m;
          if (mp.count(xi_hj)) {
            hj = mp[xi_hj] * pB - i;
            break;
          }
        }
        ans = (long long)ans * pow(zeta, phi - hj * pow(p, j) % phi, m) % m;
      }
      return ans;
    }

    // Find a K-th root of A modulo prime P^E.
    int kth_root_mod_pe(int k, int a, int pe, int phi) {
      a %= pe;
      if (k == 0) return a == 1 ? 0 : -1;
      if (a == 0) return 0;
      int d = gcd(k, phi);
      if (pow(a, phi / d, pe) != 1) return -1;
      a = pow(a, inv(k / d, phi / d), pe);
      for (int dp = 2; dp * dp <= d && dp * dp * dp * dp < pe; ++dp) {
        if (d % dp == 0) {
          int de = 0;
          for (; d % dp == 0; d /= dp, ++de);
          a = peth_root_mod_m(dp, de, a, pe, phi);
        }
      }
      if (d != 1) {
        int dp = gcd(d, phi / d), de = 0;
        if (dp != 1) {
          for (; d % dp == 0; d /= dp, ++de);
          a = peth_root_mod_m(dp, de, a, pe, phi);
        }
        if (d != 1) a = peth_root_mod_m(d, 1, a, pe, phi);
      }
      return a;
    }

    // Subroutine: Find all the K-th roots with a primitive root G known.
    std::vector<int> calc(int g, int k, int a, int p, int pe) {
      int mm = p == 2 ? pe / 4 : pe / p * (p - 1);
      int ans = kth_root_mod_pe(k, a, pe, mm);
      if (ans == -1) return {};
      int d = mm / gcd(k, mm);
      int po = pow(g, d, pe);
      std::vector<int> res(mm / d);
      for (auto& x : res) {
        x = ans;
        ans = (long long)ans * po % pe;
      }
      return res;
    }

    // Find all the K-th roots of A modulo prime power P^E.
    std::vector<int> kth_roots_mod_pe(int k, int a, PrimePower pp) {
      int p = pp.p, e = pp.e, pe = pp.pe;
      a %= pe;
      if (a == 0) {
        int d = pow(p, (e - 1) / k + 1);
        std::vector<int> res(pe / d);
        for (int i = 0; i < pe / d; ++i) {
          res[i] = i * d;
        }
        return res;
      }
      int s = 0;
      for (; a % p == 0; a /= p, ++s);
      if (s % k) return {};
      int psk = pow(p, s / k), pss = pow(p, s - s / k), pes = pow(p, e - s);
      std::vector<int> res;
      if (p != 2) {
        int g = primitive_root(PrimePower(p, e - s, pes));
        res = calc(g, k, a, p, pes);
      } else if (pes == 2) {
        res.push_back(a);
      } else if (k & 1) {
        int z = a % 4 == 3;
        a = z ? pes - a : a;
        res = calc(5, k, a, p, pes);
        if (z) {
          for (auto& x : res) x = pes - x;
        }
      } else {
        if (a % 4 == 3) return {};
        res = calc(5, k, a, p, pes);
        int m = res.size();
        res.reserve(m * 2);
        for (int i = 0; i < m; ++i) {
          res.push_back(pes - res[i]);
        }
      }
      int m = res.size();
      res.reserve(m * pss);
      for (int j = 1; j < pss; ++j) {
        for (int i = 0; i < m; ++i) {
          res.push_back(res.end()[-m] + pes);
        }
      }
      for (auto& x : res) x *= psk;
      return res;
    }

    // Find all the K-th roots of A modulo positive integer M.
    std::vector<int> kth_roots_mod_m(int k, int a, int m) {
      auto factors = factorize(m);
      int m0 = 0;
      std::vector<std::vector<int>> sols;
      for (const auto& pp : factors) {
        sols.push_back(kth_roots_mod_pe(k, a, pp));
        if (sols.back().empty()) return {};
      }
      std::vector<int> ans;
      for (int i = 0; i < (int)factors.size(); ++i) {
        auto pp = factors[i];
        if (!i) {
          m0 = pp.pe;
          ans = sols[i];
        } else {
          long long m1 = pp.pe * inv(pp.pe, m0);
          long long m2 = m0 * inv(m0, pp.pe);
          m0 *= pp.pe;
          std::vector<int> _ans;
          _ans.reserve(ans.size() * sols[i].size());
          for (auto x : ans) {
            for (auto y : sols[i]) {
              _ans.push_back((m1 * x + m2 * y) % m0);
            }
          }
          ans.swap(_ans);
        }
      }
      return ans;
    }

    void solve() {
      int n, m, k;
      std::cin >> n >> m >> k;
      auto ans = kth_roots_mod_m(n, k, m);
      if (ans.empty()) {
        std::cout << 0 << '\n';
        return;
      }
      std::cout << ans.size() << '\n';
      std::sort(ans.begin(), ans.end());
      for (auto x : ans) std::cout << x << ' ';
      std::cout << '\n';
    }

    int main() {
      int t;
      std::cin >> t;
      for (; t; --t) {
        solve();
      }
    }

## 参考资料与注释

- 冯克勤．初等数论及其应用．
- Root of unity modulo n - Wikipedia
- No.981 一般冪乗根 解説 by 37zigen

1. 实际上，模数 𝑚 m 未必是素数．只要 𝑎 a 是模 𝑚 m 的 𝑘 =2 𝑒 k=2 e 次本原单位根，就可以用于模 𝑚 m 的快速数论变换．但是，由于通常需要处理的 2 𝑒 2 e 比较大，这意味着模数 𝑚 m 中的每个素因子都是 𝑐 2 𝑒 +1 c 2 e+1 形式．因此，单个素因子就很大，而模数 𝑚 m 通常会更大，因而一般模数的情形并没有素数模的情形常用． ↩

2. 根据 原根个数相关结论 可知，𝜆 λ‑原根的数量恰为 𝜑(𝜆(𝑚))φ(λ(m))，其中，𝜑( ⋅)φ(⋅) 和 𝜆( ⋅)λ(⋅) 分别是欧拉函数和 Carmichael 函数．因为对于几乎所有整数 𝑚 m，都有 𝜆(𝑚)/𝑚 =e x p⁡(−(1+𝑜(1))l o g⁡l o g⁡𝑚 l o g⁡l o g⁡l o g⁡𝑚)λ(m)/m=exp⁡(−(1+o(1))log⁡log⁡m log⁡log⁡log⁡m)，而存在 𝐶 >0 C>0，使得对于整数 𝑚 >2 m>2，都有 𝜑(𝑚)/𝑚 =𝐶/l o g⁡l o g⁡𝑚 φ(m)/m=C/log⁡log⁡m，所以，对于几乎所有整数 𝑚 m，都有 𝜑(𝜆(𝑚))/𝑚 =e x p⁡(−(1+𝑜(1))l o g⁡l o g⁡𝑚 l o g⁡l o g⁡l o g⁡𝑚)φ(λ(m))/m=exp⁡(−(1+o(1))log⁡log⁡m log⁡log⁡log⁡m)．其中，指数部分系数中的 𝑜(1)o(1) 吸收了因子 𝜑(𝜆(𝑚))/𝜆(𝑚)φ(λ(m))/λ(m) 的贡献．故而，𝜆 λ‑原根可以在期望 e x p⁡((1+𝑜(1))l o g⁡l o g⁡𝑚 l o g⁡l o g⁡l o g⁡𝑚)exp⁡((1+o(1))log⁡log⁡m log⁡log⁡log⁡m) 次内找到．关于欧拉函数的估计，可以参考论文 Rosser, J. Barkley, and Lowell Schoenfeld. "Approximate formulas for some functions of prime numbers." Illinois Journal of Mathematics 6, no. 1 (1962): 64-94．关于 Carmichael 函数的估计，可以参考论文 Erdos, Paul, Carl Pomerance, and Eric Schmutz. "Carmichael’s lambda function." Acta Arith 58, no. 4 (1991): 363-385． ↩

3. 原始论文参见 Adleman, Leonard, Kenneth Manders, and Gary Miller. "On taking roots in finite fields." In 18th Annual Symposium on Foundations of Computer Science (sfcs 1977), pp. 175-178. IEEE Computer Society, 1977．一个更易读的介绍可见于 Cao, Zhengjun, Qian Sha, and Xiao Fan. "Adleman-Manders-Miller root extraction method revisited." In International Conference on Information Security and Cryptology, pp. 77-85. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011． ↩

4. 由于这一算法要求 𝑘 k 是素数，所以最差情形中，它需要对 𝜑(𝑚)φ(m) 的最大素因子 𝑝 p 求 𝑎 a 模 𝑚 m 的 𝑝 p 次方根．这一过程中，需要对 𝑝 p 次本原单位根求 𝑎 a 模 𝑚 m 的离散对数．即使应用 BSGS 算法，这一过程也需要 𝑂(√𝑝)O(p) 时间．但是，论文 Fouvry, Étienne. "Theoreme de Brun-Titchmarsh; application au theoreme de Fermat." Inventiones mathematicae 79, no. 2 (1985): 383-407 指出，存在正密度的素数 𝑚 m，使得 𝜑(𝑚) =𝑚 −1 φ(m)=m−1 的最大素因子 𝑝 =Ω(𝑚 2/3)p=Ω(m 2/3)．这意味着这一算法的复杂度至少为 Ω(𝑚 1/3)Ω(m 1/3)，劣于文中介绍的改良 Tonelli–Shanks 算法． ↩

> 本页面最近更新：2026/1/7 08:56:54，更新历史
> 发现错误？想一起完善？ 在 GitHub 上编辑此页！
> 本页面贡献者：Great-designer, Tiphereth-A, c-forrest, ChungZH, iamtwz, Xeonacid
> 本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用