数论进阶总结

稍微进阶一些，比昨天难（除了类欧）

先说说欧拉函数

欧拉函数$\phi (n)$表示与n互质的正整数个数
显然，当$p$为质数时，$\phi (p)=p-1$

给一个定理：$\phi (p^a)=p^a-p^{a-1}$

证明：
显然$\gcd (x,p^a)=1$可以推出$\gcd (x,p)=1$

在$[1,p^a]$中，只有$\gcd (p,kp)̸=1,k\in [1,p^{a-1}]$

则在$[1,p^a]$中，有$p^{a-1}$个数和$p^a$不互质

故$\phi (p^a)=p^a-p^{a-1}$

大家都知道欧拉函数是积性函数，那怎证明？

除了大力推公式，我提供一种新的方法：

观察下表：

$\begin{array}{ccccc}1& m+1& 2m+1& ...& (n-1)m+1\\ 2& m+2& 2m+2& ...& (n-1)m+2\\ ...& ...& ...& & ...\\ r& m+r& 2m+r& ...& (n-1)m+r\\ ...& ...& ...& & ...\\ m& 2m& 3m& ...& nm\end{array}$

若$\gcd (r,m)=d>1$,则第$r$行与$mn$没有互质的元素（显然）

这是因为第$r$行元素形式为$km+r$,而$d|m,d|r$，所以$d|(km+r)$

若$\gcd (r,m)=1$,则第$r$行元素都与$m$互质

假设$k_{2}m+r\equiv k_{2}m+r(modn)$，则$(k_1-k_2)m\equiv 0(modn)$，得到$k_1=k_2$

所以第$r$行元素模$n$两两不同余，故$\phi (n)$个数与$n$互质

满足$\gcd (r,m)=1$的行号$r$有$\phi (m)$个，故表中与nm互质的数有$\phi (n)\phi (m)$个

即$\phi (nm)=\phi (n)\phi (m)$

证明了欧拉函数的积性，加上$\phi (p^a)=p^a-p^{a-1}$（$p$为素数）

设n的质因子分解式为${\prod }_{}{p_i}^{q_i}$，则$\phi (n)=n{\prod }_{}\frac{p_i-1}{p_i}$

证明：

$\phi (n)=\phi ({\prod }_{}{p_i}^{q_i})={\prod }_{}\phi ({p_i}^{q_i})={\prod }_{}(p_i^{q_i})(1-\frac{1}{p_i})=n{\prod }_{}(1-\frac{1}{p_i})=n{\prod }_{}\frac{p_i-1}{p_i}$

欧拉函数还有一个重要的性质：

$n=\sum _{d|n}\phi (d)$

证明：

设$f(n)=\sum _{d|n}\phi (d)$
则$f({p_i}^{q_i})=\sum _{e=0}^{q_i}\phi ({p_i}^e)=1+p_i-1+...+{p_i}^{q_i}={p_i}^{q_i-1}={p_i}^{q_i}$

因为$\phi$是积性函数，所以$f$也是积性函数

所以$f(n)=f({\prod }_{}{p_i}^{q_i})={\prod }_{}{p_i}^{q_i}=n$

线性筛积性函数

线性筛可以筛积性函数

对于积性函数$f(x)$,我们可以使用线性筛快速预处理
具体操作一般是：

1. 对于素数$p$，根据定义式直接求出$f(p)$
2. 若$i\%prime[j]̸=0$，则$f(i\ast prime[j])=f(i)\ast f(prime[j])$
3. 若$i\%prime[j]=0$，则根据定义推出$f(i\ast prime[j])$与$f(i)$的关系

线性筛筛欧拉函数

根据上述规则，我们能够清晰的知道流程：

1. 对于素数$i$，根据定义式直接求出$\phi (i)=i-1$
2. 若$i\%prime[j]̸=0$，则$\phi (i\ast prime[j])=\phi (i)\ast (prime[j]-1)$
3. 若$i\%prime[j]=0$，则$\phi (i\ast prime[j])=\phi (i)\ast prime[j]$

上面的2，3如何说明？

大概就是对于$i\ast prime[j]$，如果$prim{e}_j$是第一次出现，那么他就会产生$i$个数字和他不互质。如果已经出现，那么就什么也不用动，因为相当于它没有用

代码：

void sieve() {
	clr(f) ; cnt = 0 ; phi[1] = 1 ;
	rep(i, 2, N) {
		if (!f[i]) {
			prime[++cnt] = i ;
			phi[i] = i - 1 ; // 素数
		}
		for (int j = 1; j <= cnt && prime[j] * i <= N; j++) {
			f[i * prime[j]] = 1 ;
			if (i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j] - 1) ;
			else {
				phi[i * prime[j]] = phi[i] * prime[j] ;
				break ;
			}
		}
	}
}

之后说一说欧拉函数在OI中的应用（多题预警）

然后是一道讲烂的题目 [SDOI2008]仪仗队

我们从0开始标号
显然，能够被看到的学生的坐标应该满足$\gcd (x,y)=1$

于是问题就是求$2+\sum _{i=1}^{n-1}\sum _{j=1}^{n-1}[\gcd (i,j)=1]=3+2\sum _{i=1}^n\sum _{j=1}^{i-1}[\gcd (i,j)=1]=3+2\sum _{i=2}^n\phi (i)=1+2\sum _{i=1}^n\phi (i)$

注意要特判一下$n=1$的情况

int f[N], prime[N], phi[N] ;
int n, cnt ;
ll ans ;

void sieve() {
	clr(f) ;
	phi[1] = 1 ;
	rep(i, 2, n) {
		if (!f[i]) {
			prime[++cnt] = i ;
			phi[i] = i - 1 ;
		}
		for (int j = 1; j <= cnt && i * prime[j] <= n; j++) {
			f[i * prime[j]] = 1 ;
			if (i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j] - 1) ;
			else {
				phi[i * prime[j]] = phi[i] * prime[j] ;
				break ;
			}
		}
	}
}

signed main(){
	scanf("%d", &n) ;
	if (n == 1) print(0) ;
	sieve() ;
	rep(i, 1, n - 1) ans += 2 * phi[i] ;
	printf("%lld\n", ans + 1) ;
	return 0 ;
}

之后是 [SDOI2012]Longge的问题

求$\sum _{i=1}^n\gcd (i,n)$

这类问题常见的操作就是枚举贡献,然后再通过除以权值转化成我们能够解决的形式

我们假设枚举$k$表示某些$\gcd (i,n)$的值为k，那我们只需要知道一共有多少个

推一下式子：

$\sum _{i=1}^n\gcd (i,n)=\sum _{k|n}k\sum _{i=1}^n[\gcd (i,n)=k]=\sum _{k|n}k\sum _{i=1}^{\frac{n}{k}}[\gcd (i,\frac{n}{k})=1]=\sum _{k|n}k\phi (\frac{n}{k})$

求解欧拉函数直接通过定义去推导，时间复杂度$O(\sqrt{n})$，总时间复杂度$O(n)$

被两个细节坑了：有可能是平方数要特判；n要开ll

int n ;
ll ans ;

int calc(int x) { // 计算φ(x)
	int res = x ;
	for (int i = 2; i * i <= x; i++)
	if (x % i == 0) {
		res = res / i * (i - 1) ;
		while (x % i == 0) x /= i ;
	}
	if (x > 1) res = res / x * (x - 1) ;
	return res ;
}

signed main(){
	scanf("%lld", &n) ;
	for (int i = 1; i * i <= n; i++)
	if (n % i == 0) {
		ans += i * calc(n / i) ;
		if (i != n / i) ans += (n / i) * calc(i) ;
	}
	printf("%lld\n", ans) ;
	return 0 ;
}

之后是一个类似的题目，可以先不看下面想一想 GCD

还是上一题的套路，我们枚举贡献

$\sum _{i=1}^n\sum _{j=1}^n[\gcd (i,j)\in prime]=\sum _{k=1}^n[k\in prime]\sum _{i=1}^n\sum _{j=1}^n[\gcd (i,j)=k]=\sum _{k=1}^n[k\in prime]\sum _{i=1}^{\lfloor \frac{n}{k}\rfloor }\sum _{j=1}^{\lfloor \frac{n}{k}\rfloor }[\gcd (i,j)=1]=\sum _{k=1}^n[k\in prime](2\ast sum[\lfloor \frac{n}{k}\rfloor ]-1)$

其中$sum$用前缀和统计欧拉函数值

int n, cnt ;
int phi[N], prime[N], f[N] ;
ll sum[N], ans ;

void sieve(){
	clr(f) ; cnt = 0 ;
	phi[1] = 1 ;
	for (int i = 2; i <= n; i++) {
		if (!f[i]) {
			prime[++cnt] = i ;
			phi[i] = i - 1 ;
		}
		for (int j = 1; j <= cnt && i * prime[j] <= n; j++) {
			f[prime[j] * i] = 1 ;
			if (i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j] - 1) ;
			else {
				phi[i * prime[j]] = phi[i] * prime[j] ;
				break ;
			}
		}
	}
}

signed main(){
	scanf("%d", &n) ;
	sieve() ;
	for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + phi[i] ;
	rep(i, 1, cnt) ans += 2 * sum[(int)ceil(1ll * n / prime[i])] ;
	printf("%lld\n", ans - cnt) ;
	return 0 ;
}

之后是一个毒瘤题 [SDOI2008]沙拉公主的困惑

简化问题，其实就是让你求$\sum _{i=1}^{n!}[\gcd (i,m!)=1]$,$m\le n$

很明显，我们发现这个式子能够转化成$ans=\frac{n!}{m!}\phi (m!)$

继续化简:$ans=\frac{n!}{m!}m!\prod _{p|m}\frac{p-1}{p}=n!\frac{{\prod }_{}(p-1)}{{\prod }_{}p}$，p为质数且$p<=m$

注意，不能直接处理阶乘，逆元，因为有可能会有消掉的

正解应该是对$n>=R$的$n!$消去一个$R$，对$m>=R$的${\prod }_{}p$同时消去一个$R$才对

具体实现看代码

int f[N], prime[N / 10], inv[N], phi[N / 10], sum[N / 10], fac[N], pos[N] ;
int T, MOD, n, m, cnt ;

void init() {
	f[0] = f[1] = 1 ;
	rep(i, 2, N - 10) {
		if (!f[i]) prime[++cnt] = i ;
		for (int j = 1; j <= cnt && prime[j] * i <= N - 10; j++) {
			f[prime[j] * i] = 1 ;
			if (i % prime[j] == 0) break ;
		}
	}
	inv[1] = 1 ;
	for (int i = 2; i < MOD && i <= N - 10; i++)
	inv[i] = 1ll * (MOD - MOD / i) * inv[MOD % i] % MOD ;
	phi[0] = 1 ;
	rep(i, 1, cnt) phi[i] = 1ll * phi[i - 1] * (prime[i] - 1) % MOD ;
	sum[0] = 1 ;
	rep(i, 1, cnt)
	if (prime[i] != MOD) sum[i] = 1ll * sum[i - 1] * inv[prime[i] % MOD] % MOD ;
	else sum[i] = sum[i - 1] ;
	fac[0] = 1 ;
	rep(i, 1, N - 10)
	if (i != MOD) fac[i] = 1ll * fac[i - 1] * i % MOD ;
	else fac[i] = fac[i - 1] ;
	rep(i, 2, N - 10)
	if (f[i]) pos[i] = pos[i - 1] ;
	else pos[i] = pos[i - 1] + 1 ;
}

signed main() {
	scanf("%d%d", &T, &MOD) ;
	init() ;
	while (T--){
		scanf("%d%d", &n, &m) ;
		if(n >= MOD && m < MOD) puts("0") ;
		else printf("%d\n", 1ll * fac[n] * phi[pos[m]] % MOD * sum[pos[m]] % MOD) ;
	}
	return 0 ;
}

之后是 HAOI2012 火星人

给定一个数N，问你这个数取多少次欧拉函数后变成1

用代数表示就是 $\phi (\phi (...\phi (N)))=1$

我们发现，要操作为1，必须在最后使得N变成2

根据$\phi (\prod _{i=1}^m{p_i}^{q_i})=\prod _{i=1}^m(p_i-1)\ast {p_i}^{q_i-1}$，我们没次操作会把上次操作的答案中的一个因子2变成1，所以，求操作过程会产多少个因子2就好了

对于$2^n$，显然操作次数为$n$

若一开始一个是一个质数，我们第一次操作不会讲其中的因子$2$变成$1$，所以答案要加$1$

哦对，还有线性筛筛的不是欧拉函数值而是操作次数

int T, n, ans = 1, cnt = 0 ;
int phi[N], prime[N], f[N] ;

void sieve() {
	phi[1] = 1 ;
	rep(i, 2, N - 10) {
		if (!f[i]) prime[++cnt] = i, phi[i] = phi[i - 1] ;
		for (int j = 1; j <= cnt && prime[j] * i <= N - 10; j++) {
			f[prime[j] * i] = 1 ;
			phi[i * prime[j]] = phi[i] + phi[prime[j]] ;
			if (i % prime[j] == 0) break ;
		}
	}
}

signed main(){
	sieve() ;
	scanf("%d", &T) ;
	while (T--){
		scanf("%d", &n) ;
		rep(i, 1, n) {
			int p, q ;
			scanf("%d%d", &p, &q) ;
			if (p == 2) ans-- ;
			ans += phi[p] * q ;
		}
		printf("%lld\n", ans) ;
		ans = 1 ;
	}
	return 0 ;
}

欧拉函数就讲这么多吧，毕竟已经有5个题了

之后将三定理

首先是欧拉定理

若$\gcd (a,p)=1,则a^{\phi (p)}\equiv 1(modp)$

为何要满足$\gcd (a,p)=1$?

转化同余方程为丢番图方程 $a^{\phi (p)}+bp=1$

在数论初步中我们已经推过这个方程有解的必要条件是$\gcd (a,p)=1$

根据定理，我们可以发现一些方便的性质：

$a^b\equiv a^{k\phi (p)}{a}^{b\%\phi (p)}\equiv a^{b\%\phi (p)}(modp)$

扩展欧拉定理： 若$b>\phi (p),a^b\equiv a^{b\%\phi (p)+\phi (p)}(modp)$

给一个例题练练手

上帝与集合的正确用法

求$2^{2^{2^{...}}}\%p$的值：

设$p$为形如$2^k\ast q$的数，$q$为奇数

则:$ans=2^k(2^{2^{2^{...}}-k}modq)=2^k(2^{(2^{2^{...}}-k)\%\phi (q)}modq)$

总有一天$\phi (q)=1$,则就可以算出答案，反着退回去就行了

程序用递归实现

int phi[N], prime[N], f[N] ;
int n, T, cnt ;

void sieve() {
	f[0] = f[1] = 1 ; phi[1] = 1 ;
	rep(i, 2, N - 10) {
		if (!f[i]) prime[++cnt] = i, phi[i] = i - 1 ;
		for (int j = 1; j <= cnt && prime[j] * i <= N - 10; j++) {
			f[i * prime[j]] = 1 ;
			if (i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j] - 1) ;
			else {
				phi[i * prime[j]] = phi[i] * prime[j] ;
				break ;
			}
		}
	}
}

int mul(int a, int b, int MOD) {
	int res = 0 ;
	for (; b; b >>= 1, a = (a + a) % MOD) if (b & 1) res = (res + a) % MOD ;
	return res ;
}

int pw(int a, int b, int MOD) {
	int res = 1 ;
	for(; b; b >>= 1, a = mul(a, a, MOD)) if (b & 1) res = mul(res, a, MOD) ;
	return res ;
}

int work(int x) {
	return x == 1 ? 0 : pw(2, work(phi[x]) + phi[x], x) ;
}

signed main(){
	sieve() ;
    scanf("%d", &T) ;
	while (T--) {
		scanf("%d", &n) ;
		printf("%d\n", work(n)) ;
	}
	return 0 ;
}

费马小定理：

当p为质数时，$a^{p-1}\equiv 1(modp)$

将$\phi (p)=p-1$代入欧拉定理即可

常用于求解逆元

威尔逊定理

$(p-1)!\equiv -1(modp)$

证明：

当$p=2$时显然成立

当$p>2$时，根据逆元的唯一性，$2(p-2)$两两配对互为逆元

故结论成立

之后是Miller-Rabin素数测试和Pollard-Rho因数分解

因为都是随机算法所以一起讲了

首先，我们可以通过费马小定理测试是否是质数

我们可以找一些$a$一一验证，判断$p$是否为素数

但是总有一些强伪素数能够通过测试，为提高测试的准确率，我们引入了一个叫做二次探测定理的玩野

对于某素数$p$，则 $\forall x\in (0,p),x^2\equiv 1(modp)$的解总为$\pm 1$

证明很简单，直接平方差就是了

对于每个测试是否是素数的数$a$，我们可以把$a^{p-1}$不断开方，如果开放的结果为$-1$,则p通过测试，否则继续

具体实现上可能有一些不一样，代码上有详细注释。

bool miller(ll p, int a) {
// 判定p是否是质数，用a^(p-1)≡1(mod p) 和二次检测判定
	if (p == 2) return 1 ;
	if (p % 2 == 0 || p == 1) return 0 ; // 奇
	ll d = p - 1 ; while (d % 2 == 0) d /= 2 ; // 把能开方的部分开掉
	// 根据二次检测，判定 (x=a^d)是否同余1(mod p)
	int m = pw(a, d, p) ;
	if (m == 1) return 1 ; // 出现1，通过二次检测
	for (; d - 1 <= p; d *= 2, m = 1ll * m * m % p) if (m == p - 1) return 1 ;
	// 出现-1，通过二次检测
	return 0 ; // 合数
}

rep(i, 0, 8) {
	if (x == prime[i]) { // x 是被判定的数
		puts("Prime") ;
		break ;
	}
	if (!miller(x, prime[i])) {
		puts("Not prime.") ;
		break ;
	}
}

之后是Pollard-Rho算法

设有一个大合数,我们要求他的素因数分解式

假设$n=pq$,我们要求$p$和$q$，怎么做？

先看一个暴力方法：${\mathfrak{I}}^{\prime }\mathfrak{m}\mathfrak{f}\mathfrak{e}\mathfrak{l}\mathfrak{l}\mathfrak{i}\mathfrak{n}\mathfrak{g}\mathfrak{l}\mathfrak{u}\mathfrak{c}\mathfrak{k}\mathfrak{y}\mathfrak{a}\mathfrak{l}\mathfrak{g}\mathfrak{o}\mathfrak{r}\mathfrak{i}\mathfrak{t}\mathfrak{h}\mathfrak{m}$

每次随机一个$[2,n]$,然后进行判断，可惜成功的概率比中奖还低。。。

我们要提到一种简单而且十分有用的提高效率的技巧，叫做$\mathfrak{B}\mathfrak{i}\mathfrak{r}\mathfrak{t}\mathfrak{h}\mathfrak{d}\mathfrak{a}\mathfrak{y}\mathfrak{T}\mathfrak{r}\mathfrak{i}\mathfrak{c}\mathfrak{k}$

举个例子来说明这个小$\mathfrak{T}\mathfrak{r}\mathfrak{i}\mathfrak{c}\mathfrak{k}$：

从$[1,1000]$中选一个数$i$，使得$P(i=100)=\frac{1}{1000}$

从$[1,1000]$中选一个数$i，j$，使得$P(abs(i-j)=100)=\frac{1}{500}$

发现成功概率增长了1倍！！！

那么我们选出$x_1,x_2,...,x_k$，满足$abs(x_i-x_j)=100$的概率又是多少呢？

用数据说话：

我们发现，当$k=30$的时候，成功的概率已经接近一半，而$k=100$时，几乎确保成功

这就叫 $生日悖论$

我们尝试通过生日悖论来优化${\mathfrak{I}}^{\prime }\mathfrak{m}\mathfrak{f}\mathfrak{e}\mathfrak{l}\mathfrak{l}\mathfrak{i}\mathfrak{n}\mathfrak{g}\mathfrak{l}\mathfrak{u}\mathfrak{c}\mathfrak{k}\mathfrak{y}\mathfrak{a}\mathfrak{l}\mathfrak{g}\mathfrak{o}\mathfrak{r}\mathfrak{i}\mathfrak{t}\mathfrak{h}\mathfrak{m}$

我们把不再选一个数，而是选k个数，并判断$(x_i-x_j)|n$

取$k=\sqrt{n}$，就可以吧可行性提高到$50\%$

因此，对于一个10位数，我们只需要选取$k=10^5$个随机数而不是$10^{10}$

不幸的是，我们并没有节省我们的开销，我们仍要做$k^2=10^{10}$次比较和除法

但是幸运的是，我们有更优秀的办法

我们可以选出$k$个数$x_1,x_2,...,x_k$，判断是否存在$\gcd (abs(x_i-x_j),n)>1$的情况

若存在，则$\gcd (abs(x_i-x_j),n)$就是$n$的一个因子

但我们要选取的数是很多的，不能存在内存中

我们不生成$k$个数进行比较，而是一个一个生成并检查连续的两个数

$f(x)=(x^2+c)\%n$来生成伪随机数（c输一个钦定随机的数）

并不是所有函数都可以这样做，根据前辈的经验这个函数可以

我们从$x_1=2$开始，$x_{n+1}=f(x_n)$

对于大部分的数据这个算法能够正常运行

但是对于某些毒瘤数据，TA将会进入无限循环，这个环就是算法名称的由来

遇到环的时候，算法就是用了，需要改变$c$的值

我们如何检测环的存在？

这是 $Floyd$ 发明的算法：

假设我们在一个很长的圆形轨道上行走，我们如何知道已经走完了一圈呢？

让 $A$ 和 $B$ 按照 $B$ 的速度是 $A$ 的速度两倍的设定从同一起点开始往前走

当 $B$ 第一次追上 $A$ 时，我们知道，$A$ 已经走了一圈了
这种方法称为 $Floyd$ 周期检测策略

代码锅了不发了

之后是两个东西：次数和原根

定义：若$\gcd (a,p)=1$，存在正整数$x$使得$a^x\equiv 1(modp)$，则称最小的$x$称为$a$模$P$的次数，记做${Or{d}_p}^a$

定理：若正整数$n$满足$a^n\equiv 1(modp)$,则$x={Or{d}_p}^a$

证明：假设定理不成立，记$x={Or{d}_p}^a$

那么必有两正整数$k,r$，使得$n=kx+r$且$0<r<x$

而$a^n=a^{kx+r}=a^{kx}\ast a^r\equiv 1(modp)$

可以推出$a^r\equiv 1(modp)$

这与次数$x$的定义矛盾

推论：${Or{d}_p}^a|\phi (p)$

定理：设$x={Or{d}_p}^a，则1,a,a^2,...a^{x-1}$两两不同余

证明：假设定理不成立

则$a^{k-j}\equiv 1(modp)$

而 $0<k-j<x$

这与次数$x$的定义矛盾

定义：若${Or{d}_p}^g=\phi (p)$，则称$g$为模$P$意义下的原根

求法：${Or{d}_p}^g=\phi (p)$的意思就是方程$g^x\equiv 1(modp)$的最小正整数解释$\phi (p)$

而$g^{\phi (p)}\equiv 1(modp)$是一定成立的

那么我们就可以从$2$到$n-1$枚举$g$，检验$g^x\equiv 1(modp)$ 在区间$1<x<\phi (p)$中是恒不成立即可

而满足$g^x\equiv 1(modp)$的$x$必定是$\phi (p)$的约数

所以我们只需要枚举$\phi (p)$的因子即可

模板代码：

int fj[N] ;

int pw(int a, int b, int MOD) {
	int res = 0 ;
	for (; b; b >>= 1, a = 1ll * a * a % MOD) if (b & 1) res = 1ll * res * a % MOD ;
	return res ;
}

int proots(int n) {
	int tmp = n - 1, cnt = 0 ;
	for (int i = 2; i * i <= n; i++)
	if (tmp % i == 0) {
		fj[++cnt] = i ;
		while (tmp % i == 0) tmp /= i ; // 只需要枚举n-1的因数
	}
	if (tmp > 1) fj[++cnt] = tmp ;
	for (int i = 2; i < n; i++) { // 枚举g
		int flag = 1 ;
		for (int j = 1; j <= cnt; j++) // 逐一判断φ(p)的因子是否可行即可
		if (pw(i, (n - 1) / fj[j], n) == 1) {
			flag = 0 ;
			break ;
		}
		if (flag) return i ;
	}
}

之后来讲一下大步小步(BSGS)算法

离散对数问题就是要求解决高次同余方程$a^x\equiv b(modp)$的$x$的最小整数解

我们可以用大步小步法（BSGS）解决

我们先讨论$P$为质数时的问题

算法的主要思想是分块

设$x=A\sqrt{p}-B$（其中$0\le A,B<\sqrt{p}$）

$d^{A\sqrt{p}-B}\equiv b(modp)\Rightarrow d^{A\sqrt{p}}\equiv b\ast a^B(modp)$

我们只需要求出$A$和$B$就能够算出$x$

枚举$B$的值把右边的式子存入哈希表中，然后枚举$A$值去哈希表中查找左值是否存在，时间复杂度$O(\sqrt{p})$

一道模板题 [SDOI2011]计算器

mii hsh ;
int T, ty, a, b, p, ans ;

void bad() {
    puts("Orz, I cannot find x!") ;
}

int gcd(int a, int b) {
    return !b ? a : gcd(b, a % b) ;
}

int pw(int a, int b, int MOD) {
    int res = 1 ;
    for (; b; b >>= 1, a = 1ll * a * a % MOD) if (b & 1) res = 1ll *res * a % MOD ;
    return res ;
}

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1 ; y = 0 ;
        return a ;
    }
    int d = exgcd(b, a % b, y, x) ;
    y -= (a / b) * x ;
    return d ;
}

int BSGS(int a, int b, int MOD) {
    if (b % gcd(a, MOD)) return -1 ;
    a %= MOD, b %= MOD, hsh.clear() ;
    int m = ceil(sqrt(MOD)) ;
    for (int i = 0; i <= m; i++, b = 1ll * b * a % MOD) hsh[b] = i ;
    // 先枚举B(i)的值将其插入哈希表
    for (int i = 1, j = a = pw(a, m, MOD); i <= m; i++, j = 1ll * j * a % MOD) {
        if (hsh.find(j) != hsh.end() && i * m >= hsh[j]) return i * m - hsh[j] ;
    } // 再枚举A(i)的值判断是否存在，而且需要保证A*sqrt(p)-B(hsh[j])>=0
    return -1 ;
}

void work(int a, int b, int p) {
    ans = 0 ;
    if (ty == 1) ans = pw(a, b, p) ;
    if (ty == 2) { // ax≡b(mod p)->ax+py=b
        if (a == 0 && b != 0) bad(), ans = -2 ;
        int x, y ;
        int d = exgcd(a, p, x, y) ; // ax+py=d(gcd(a,p))
        if (b % d) bad(), ans = -2 ;
        if (ans != -2) ans = ((b / d * x % p) + p) % (p / d) ;
    }
    if (ty == 3) ans = BSGS(a, b, p) ;
    if (ans == -1) bad() ;
    else if (ans != -2) printf("%lld\n", ans) ;
}

signed main(){
    scanf("%lld%lld", &T, &ty) ;
    while (T--) {
        int a, b, p ; scanf("%lld%lld%lld", &a, &b, &p) ;
        work(a, b, p) ;
    }

    return 0 ;
}

那么当P不是质数的时候怎么办？

我们依然将原方程展开：

$a^x+kp=b(k\in \mathbb{Z})$

设$g=\gcd (a,p)$，若$b$不能整出$g$，则方程无解

否则可以得到$\frac{a}{g}{a}^{x-1}\equiv \frac{b}{g}(mod\frac{p}{g})$

很明显通过换元我们能够得到一个新的高次同余方程

原方程的解就是该方程的解$+1$

我们不断进行下去总有一天$\gcd (a,p)=1$

那么就转化成了BSGS了

模板题 SP3105 MOD

map <int, int> hsh ;

int gcd(int a, int b) {
	return !b ? a : gcd(b, a % b) ;
}

int pw(int a, int b, int MOD) {
	int res = 1 ;
	for (; b; b >>= 1, a = 1ll * a * a % MOD) if (b & 1) res = 1ll * res * a % MOD ;
	return res ;
}

int exBSGS(int a, int b, int p) {
	if (b == 1) return 0 ;
	int tim = 0, d, k = 1 ;
	while ((d = gcd(a, p)) ^ 1) { // 不停地做
		if (b % d) return -1 ; // 不整除，无解
		b /= d, p /= d, ++tim ; // a^(x-1)≡(b/d) *inv(a/d) (mod p/d)
		k = 1ll * k * (a / d) % p ;
		if (k == b) return tim ; // 发现 k^x≡b(k)(mod ~)
	}
	hsh.clear() ;
	int m = sqrt(p) + 1, kt = 1 ;
	for (int i = 0; i < m; i++) {
		hsh[1ll * kt * b % p] = i ;
		kt = 1ll * kt * a % p ;
	}
	k = 1ll * k * kt % p ;
	rep(i, 1, m) {
		if (hsh.find(k) != hsh.end()) return i * m - hsh[k] + tim ;
		k = 1ll * k * kt % p ;
	}
	return -1 ;
}

signed main(){
	int a, b, p ;
	while (scanf("%lld%lld%lld", &a, &p, &b) != EOF && a && b && p) { // a^x≡b(mod p)
		int ans = exBSGS(a, b, p) ;
		if (ans == -1) puts("No Solution") ;
		else printf("%lld\n", ans) ;
	}
	return 0 ;
}

还需填坑：二次剩余