基础数论指南 QwQ

数论

同余

同余是指：

• $a\times b\equiv (a\mathrm{mod}p)\times (b\mathrm{mod}p)(\mathrm{mod}p)$
• $a+b\equiv (a\mathrm{mod}p)+(b\mathrm{mod}p)(\mathrm{mod}p)$
• $a-b\equiv (a\mathrm{mod}p)-(b\mathrm{mod}p)(\mathrm{mod}p)$

这个性质有助于我们推导数论公式和简化题目。比如有的题目要求答案对 $10^9+7$ 取模，但是计算的过程中随时可能爆 long long，如果计算答案的过程中只包含 $+$、$-$、$\times$，就可以用同余来规避开高精度。

注意，$÷$ 并不满足同余性质，如果涉及到 $÷$ 的同余，那么就需要乘法逆元。

欧拉函数

欧拉函数是 $\phi$ 函数，为 $1$ 到 $n$ 之内有多少个数与 $n$ 互质。即 $\phi (n)={\sum }_{i=1}^n[\gcd (i,n)=1]$。

$\phi$ 具有如下性质。

• 积性，即对于任意的 $p,q\in Prime$，都有 $\phi (p)\times \phi (q)=\phi (p\times q)$。
• 有这个性质：$({\sum }_{d\mid n}\phi (d))=n$。
• 欧拉定理，在后面会详解。

第一个性质可以用欧拉函数的求解方法来证明。$\phi (p)=p-1$ 且仅当 $p\in Prime$。因为在 $[1,p]$ 之间，只有 $\gcd (p,p)=p$。

如果有 $n=p^2,p\in Prime$，那么 $\phi (n)=p\times (p-1)$。因为有 $p$ 个数 $q$，$\gcd (n,q)=p$，所以是 $n-p$ 即 $p\times (p-1)$。

如果有 $n=p\times q,p,q\in Prime$，则可以用容斥原理证明。在 $[1,n]$ 中有 $\frac{n}{p}=q$ 个 $p$ 的倍数，$\frac{n}{q}=p$ 个 $q$ 的倍数，减去这些，发现有 $\frac{n}{p\times q}=1$ 个数要加上，即 $p\times q-p-q+1$，就是 $(p-1)\times (q-1)$，故得证。

再推得深入一些，如果 $n=q\times q\times r,p,q,r\in Prime$，那么就是 $n-\frac{n}{q}-\frac{n}{p}-\frac{n}{r}+\frac{n}{p\times q}+\frac{n}{p\times r}+\frac{n}{q\times r}-\frac{n}{p\times q\times r}=n-p\times q-p\times r-q\times r+p+q+r-1=(p-1)\times (q-1)\times (r-1)$。那么，我们可以推出公式，设唯一分解定理是：$n={\Pi }_{p_i\in Prime}^m{p}_i^{c_i}$，那么则有 $\phi (n)=n\times {\Pi }_{p_i\in Prime}^m(\frac{p_i-1}{p_i})$，所以欧拉函数可以用欧拉筛法筛出来。

int phi[MAXN];
bool flag[MAXN];
vector<int> prim;
inline void prework(){
	flag[1]=true;
    phi[1]=1;
	for(int i=2;i<MAXN;++i){
		if(!flag[i]){
			prim.push_back(i);
			phi[i]=i-1;//p in Prime，则  phi(p)=p-1 
		}
		for(int j=0;j<prim.size()&&i*prim[j]<MAXN;++j){//欧拉筛法 
			flag[i*prim[j]]=true;
			if(i%prim[j]){
				phi[i*prim[j]]=phi[i]*(prim[j]-1);//计算公式 
			}else{
				phi[i*prim[j]]=phi[i]*prim[j];//不是重复的质数 
				break;
			}
		}
	} 
}

如何证明 $({\sum }_{d\mid n}\phi (d))=n$？

很明显，$[\gcd (n,m)=d]=[\gcd (\frac{n}{d},\frac{m}{d})=1]$，设 $f(x)={\sum }_{i=1}^n[\gcd (i,n)=x]$，很明显，$n={\sum }_{d\mid n}f(i)$。那么 $f(x)={\sum }_{i=1}^{\lfloor \frac{n}{x}\rfloor }[\gcd (i,\lfloor \frac{n}{d}\rfloor )=1]$，那么就是 $f(x)=\phi (\lfloor \frac{n}{x}\rfloor )$，故得证。这个性质可以用在欧拉反演中。

欧拉反演

我们利用性质 $2$：
$$n=\sum _{d\mid n}\phi (d)$$
把 $n$ 替换成 $\gcd$：
$$\gcd (i,j)=\sum _{d\mid \gcd (i,j)}\phi (d)$$
换成两个 $\sum$：
$$\gcd (i,j)=\sum _{d\mid i}\sum _{d\mid j}\phi (d)$$
求 $\sum \gcd$：
$$\sum _{i=1}^n\gcd (i,n)=\sum _{d\mid n}\sum _{i=1}^n\sum _{d\mid i}\phi (d)$$
再演化一下：
$$\sum _{i=1}^n\gcd (i,n)=\sum _{d\mid n}\phi (d)\times \frac{n}{d}$$
得出结论，这就是欧拉反演。

例题

就是求出 ${\sum }_{i=1}^n{\sum }_{j=1}^n[\gcd (i,j)=1]$，不妨转化一下，变成 $({\sum }_{i=1}^n{\sum }_{j=1}^i[\gcd (i,j)=1])\times 2-1$，这就变成了 $({\sum }_{i=1}^{n-1}\phi (i))\times 2+1$，求出 $\phi$ 的前缀和就可以了。

#include<bits/stdc++.h>
#define MAXN 40004
using namespace std;
typedef long long ll;
int phi[MAXN];
ll pre[MAXN];
bool flag[MAXN];
vector<int> prim;
inline void prework(){
	flag[1]=true;
	phi[1]=1;
	for(int i=2;i<MAXN;++i){
		if(!flag[i]){
			prim.push_back(i);
			phi[i]=i-1;
		}
		for(int j=0;j<prim.size()&&i*prim[j]<MAXN;++j){
			flag[i*prim[j]]=true;
			if(i%prim[j]){
				phi[i*prim[j]]=phi[i]*(prim[j]-1);
			}else{
				phi[i*prim[j]]=phi[i]*prim[j];
				break;
			}
		}
	}
	for(int i=1;i<MAXN;++i){
		pre[i]=pre[i-1]+phi[i];
	}
}
int main(){
	prework();
	int n;
	scanf("%d",&n);
	printf("%lld",n==1?0ll:pre[n-1]<<1|1);
	return 0;
}

欧拉定理

欧拉定理是指如果 $\gcd (n,m)=1$，则有 $n^{\phi (m)}\equiv 1(\mathrm{mod}m)$。

证明：构造一个集合 $S=1,2,3\dots \phi (m)$，那么则有 ${\Pi }_{i=1}^{\phi (m)-1}{S}_i\equiv {\Pi }_{i=1}^{\phi (m)-1}(S_i\times n)(\mathrm{mod}m)$，因为 $\gcd (\phi (m),S_i)=1$，所以只有 $n$ 的影响。而 $\gcd (n,m)=1$，所以 $n$ 也没有影响。然后，同时消掉 ${\Pi }_{i=1}^{\phi (m)-1}{S}_i$，则得 $n^{\phi (m)}\equiv 1(\mathrm{mod}m)$。

乘法逆元

如果 $a\times b\equiv 1(\mathrm{mod}p)$，则称 $a$ 为 $b$ 模 $p$ 意义下的逆元，记作 $b^{-1}$。在模 $p$ 意义下，$a\times \frac{1}{b}\equiv a\times b^{-1}(\mathrm{mod}p)$。$a$ 在模 $p$ 意义下有逆元存在且仅当 $\gcd (a,p)=1$。求乘法逆元有很多种方法。

快速幂求逆元

根据欧拉定理：
$$a^{p-1}\equiv a\times b^{-1}(\mathrm{mod}p)$$
同时除以 $a$：
$$a^{p-2}\equiv b^{-1}(\mathrm{mod}p)$$
所以 $b^{-1}=a^{p-2}$，可以使用快速幂求。当 $\gcd (a,p-2)=1$ 的时候，可以用欧拉定理优化。

线性求逆元

这是递推求逆元的方式。很显然，$in{v}_1=1$。因为在任意模数下都有 $1\times 1\equiv 1÷1(\mathrm{mod}p)$。对于其他情况，我们令 $div=\lfloor \frac{p}{i}\rfloor$，$mod=p\mathrm{mod}i$。
$$div\times i+mod\equiv 0(\mathrm{mod}p)$$
两边同时乘以 $i^{-1}\times mo{d}^{-1}$，即 $\frac{1}{i\times mod}$：
$$div\times mo{d}^{-1}+i^{-1}\equiv 0(\mathrm{mod}p)$$
同时减去 $div\times mo{d}^{-1}$：
$$i^{-1}\equiv div\times mo{d}^{-1}\equiv (\mathrm{mod}p)$$
带入式子：
$$i^{-1}\equiv -\lfloor \frac{p}{i}\rfloor \times (p\mathrm{mod}i{)}^{-1}(\mathrm{mod}p)$$
可以知道 $p\mathrm{mod}i<i$，所以可以应用之前求过的逆元，即：
$$in{v}_i\equiv -\lfloor \frac{p}{i}\rfloor \times in{v}_{p\mathrm{mod}i}(\mathrm{mod}p)$$

ll inv[MAXN];
inline void prework(int mod){//模数 
	inv[1]=1;//inv[1]=1 证明过 
	for(int i=2;i<MAXN;++i){//递推 
		inv[i]=((-(mod/i)*inv[mod%i])%mod+mod)%mod;//递推式 
	}
}

裴蜀定理

对于任意的整数 $a,b$ 和 $x,y$，满足 $\gcd (a,b)\mid a\times x+b\times y$，且存在 $x,y$ 满足 $a\times x+b\times y=\gcd (a,b)$。

对于第一点，一定满足 $\gcd (a,b)\mid a,b$，所以对于整数 $x,y$ 一定满足。

对于第二点，如果 $a\times b=0$，则 $\gcd (a,b)=\max (a,b)$， { x , y } = { 1 , 0 } \{x,y\}=\{1,0\} {x,y}={1,0} 一定满足。

如果 $a\times b\ne 0$，则同时除以 $-\gcd (a,b)$，得 $(-a)\times x+(-b)\times y=1$。当 $\gcd (a,b)=1$ 的时候，可以证明消掉 $(x-y)\times (a-b)$，等于 $(a-b)\times (x-y)$，这一定是可以等于 $1$ 的。

这个定理对于 $n$ 个数一定也是正确的。

扩展欧几里得算法

和裴蜀定理类似，写作 $exgcd$，用于求裴蜀定理中的 $x$ 和 $y$。

这可以模拟 $\gcd$ 的过程。首先，$\gcd (a,b)=\gcd (a,a\mathrm{mod}b)$，那么可以将 $x$ 和 $y$ 往回代：$a\times x+(a\mathrm{mod}b)\times y=\gcd (a,b)$。

由于 $a\mathrm{mod}b=a-\lfloor \frac{a}{b}\rfloor \times b$，那么再代入式中：$a\times x+(a-\lfloor \frac{a}{b}\rfloor \times b)\times y=\gcd (a,b)$，演化一下：
$$a\times (x+y)-\lfloor \frac{a}{b}\rfloor \times b\times y=\gcd (a,b)$$

之后，就可以带入求 $exgcd$ 了。

void exgcd(ll a,ll b,ll &x,ll &y){
	if(!b){
		x=1;
		y=0;
		return;//可行解 
	}
	exgcd(b,a%b);//带入 gcd 
	ll t=x;
	x=y;
	y=t-a/b*y;//带入式子 
}

这一个性质也可以帮助我们求逆元，但是过于复杂而且有同样复杂度 $\log n$ 的快速幂，所以这里不展开介绍。

组合数学

多重集问题

先从最基础的开始。比如给你 $n$ 个数，要求从中选择 $m$ 个数，分顺序，有多少种选择？很明显，这个是 ${\Pi }_{i=m}^{n}i$ 种选择方案，即 $\frac{n!}{(n-m)!}$。我们称排列 $A_n^m=\frac{n!}{(n-m)!}$。

假如给你 $n$ 个数，要求从中选择 $m$ 个数，有多少种不同的选择方案？考虑化繁为简。首先，分顺序的是 $A_n^m$ 种，然后要除以顺序所带来的价值，也就是 $m$ 个数从中选择 $m-1$ 个数，即 $A_{m-1}^m=m!$，那么得出 $C_n^m=\frac{A_n^m}{A_m^1}=\frac{n!}{m!\times (n-m)!}$。

那么假如有 $k$ 个集合，每一个集合都有 $c_i$ 个 $p_i$，那么这 $n$ 个集合的并集中选出 $m$ 个数的个数。设 $n={\sum }_{i=1}^k{c}_i$，那么第一项肯定是 $A_n^m$。接下来，要依次按照上面的做法除以 $A_{c_i}^1$，所以就是 $\frac{A_n^m}{{\Pi }_{i=1}^k{A}_{c_i}^1}$。

当然，还有一种题型叫做插板法，就是在 $n$ 个元素内插入 $m$ 个板子，将这 $n$ 个元素分成 $m+1$ 个块，求方案数。

由于元素完全相同，所以可以直接得出答案为 $C_m^n$。这是一个结论，和欧拉反演的结论一样，都是助于把题目转换为插板法的形式，进行更优秀的解答。

如何求出 $C$？有几种方法。

$C$ 递推式

很明显，可以看出 $C$ 就是杨辉三角，可以使用杨辉三角进行递推。

ll C[MAXN][MAXN];
inline void prework(){
	C[1][1]=1;
	for(int i=2;i<MAXN;++i){
		C[i][1]=C[i][i]=1;//两端为 1 
		for(int j=2;j<i;++j){
			C[i][j]=C[i-1][j-1]+C[i-1][j];//杨辉三角 
		}
	}
}

阶乘逆元递推式

可以直接套用公式，如果要取模并且可以使用逆元，那就可以用逆元。

ll inv[MAXN],frac[MAXN];//有时候是只能够现场求逆元和阶乘，因为逆元存不下
inline ll C(int n,int m){
	if(n<m){
		return 0;//特判 
	}
	return frac[n]*inv[frac[m]]%MOD*inv[frac[n-m]]%MOD;//公式 
}

鸽巢原理

鸽巢原理是指有 $m$ 个鸽巢和 $n$ 只鸽子，每一只鸽子要飞进鸽巢中，至少有 $1$ 个鸽巢至少有 $\lceil \frac{n}{m}\rceil$ 只鸽子。

考虑反证法。如果每一个鸽巢最多有 $\lfloor \frac{n}{m}\rfloor$ 只鸽子，那么最多有 $\lfloor \frac{n}{m}\rfloor \times m$ 只鸽子。但是这可能不是 $n$，多以矛盾。

容斥原理

容斥原理适用于求多个集合的集合并的大小用的。假如有 $n$ 个集合 $S_i$，那么要求 $|S_1\cup S_2\cup S_3\dots S_n|$，首先可以把所有元素的大小加和，即 ${\sum }_{i=1}^n|S_i|$，可以得其中有元素重复了，那么减去一些元素的交集，$|S1\cap S_2|+|S_2\cap S_3|\dots |S_n\cap S_1|$，则有一些元素多减了。再加上 $|S_1\cap S_2\cap S_3|\dots |S_{n-1}\cap S_n\cap S_1|$，又发现有一些多加了，重复执行此操作直至发现 ${\cap }_{i=1}^n{S}_i$ 多加或者多减。通过上述过程证明：
$$|{\cup }_{i=1}^n{S}_i|=\sum _{m=1}^n(-1{)}^{(m-1)}\times (\sum _{a_i<a_{i+1}})|{\cap }_{i=1}^m{S}_{a_i}|$$
其中，每一个 $a_i$ 代表枚举顺序。

容斥原理的难点在于枚举顺序和确定 $|S_i|$。有的时候，$|S_i|$ 为 dp 式。有的时候，$|S_i|$ 为函数。容斥原理比 dp 更加难操作和推理，非常棘手。

例题

题目要求求出：
$$\sum _{a_i=x}^y[\gcd (a_i)=x][\mathrm{lcm}(a_i)=y]$$

不难发现，每一个数必须在 $x$ 到 $y$ 之间，每一个数可以表示为 $t\times \frac{y}{x}(t\le x)$。不同的就是这一个 $t$。

设 $t=\frac{y}{x}$，并且设 $t={\Pi }_{i=1}^k{p}_i^{c_i}(p_i\in Prime)$，那么可以证明，要求 $\gcd$ 为 $x$，那么至少要有一个数，其 $c_i$ 为 $0$。要求 $\mathrm{lcm}$ 为 $y$，那么至少要有一个数，其 $c_i$ 为 $c_i$。答案为 $(c_i+1{)}^n$。

那么，发现是至少，因此要减去所有 $c_i$ 为 $[1,c_i]$ 的情况，$c_i$ 为 $[0,c_i-1]$ 的情况同理，要减一次。

再发现 $[1,c_i-1]$ 被减了两次，那么加回来，得答案为 $(c_i+1{)}^n-2\times (c_i{)}^n+(c_i-1{)}^n$。之后对于 $p_i$ 不同考虑乘起来即可。

#include<bits/stdc++.h>
#define MAXN 350000
#define MOD 998244353
using namespace std;
typedef long long ll;
int n,x,y,top,p[MAXN],c[MAXN];
bool flag[MAXN];
vector<int> prim;
inline void prework(){
	flag[1]=true;
	for(int i=2;i<MAXN;++i){
		if(!flag[i]){
			prim.push_back(i);
		}
		for(int j=0;j<prim.size()&&i*prim[j]<MAXN;++j){
			flag[i*prim[j]]=true;
			if(i%prim[j]==0){
				break;
			}
		}
	} 
}
inline bool check(int x){
	if(x<=1){
		return false;
	}
	for(int i=2;i*i<=x;++i){
		if(x%i==0){
			return false;
		}
	}
	return true;
}
inline ll power(ll x,ll y){
	ll res=1;
	while(y){
		if(y&1){
			(res*=x)%=MOD;
		}
		(x*=x)%=MOD;
		y>>=1;
	}
	return res;
}
inline void split(int x){
	top=0;
	for(int i=0;i<prim.size()&&x!=1;++i){
		if(x%prim[i]==0){
			p[++top]=prim[i];
			c[top]=0;
			while(x%prim[i]==0){
				x/=prim[i];
				++c[top];
			}
		}
	}
	if(check(x)){
		p[++top]=x;
		c[top]=1;
	}
}
int main(){
	prework();
	int t;
	scanf("%d",&t);
	while(t--){
		scanf("%d %d %d",&x,&y,&n);
		int t=y/x;
		split(t);
		ll ans=1;
		for(int i=1;i<=top;++i){
			ll a=power(c[i]+1,n);
			ll b=power(c[i],n);
			ll d=power(c[i]-1,n);
			(ans*=((a-2ll*b+d)%MOD+MOD)%MOD)%=MOD;
		}
		printf("%lld\n",ans);
	} 
	return 0;
}

卢卡斯定理

卢卡斯定理是用于求 $C$ 的。假如要求 $C_n^m\mathrm{mod}p$，并且 $p$ 为质数，那么则有 $C_n^m\equiv C_{n\mathrm{mod}p}^{m\mathrm{mod}p}\times C_{\lfloor \frac{n}{p}\rfloor }^{\lfloor \frac{m}{p}\rfloor }(\mathrm{mod}p)$。我们发现，如果 $n$ 和 $m$ 非常大的时候，可以用卢卡斯定理缩小 $n$ 和 $m$，右边的除法式还可以继续用卢卡斯，时间复杂度为 ${\log }_{p}n$。

证明右转 OI Wiki，我不会告诉你我不会证明。

扩展卢卡斯定理

这是在 $p$ 不是质数的情况下使用的。主要思想是将 $p$ 分解质因数，分别 $lucas$，然后用中国剩余定理合并答案。

例题

很明显，题目要求的是具有小根堆性质的数列。设 $d{p}_i$ 为 $i$ 个数的排列中满足小根堆性质的个数。设 $i$ 为根节点，那么有 $i-1$ 个点是子节点。那么从 $i-1$ 个节点中选择 $l$ 个节点为左子节点，为 $C_{i-1}^l$，那么得出 $d{p}_i=C_{so{n}_i-1}^{so{n}_{\lfloor \frac{i}{2}\rfloor }}\times d{p}_{i\times 2}\times d{p}_{i\times 2+1}$。其中，$so{n}_i$ 表示在二叉树下 $i$ 的子节点个数。

#include<bits/stdc++.h>
#define MAXN 2000002
using namespace std;
typedef long long ll;
int n,p,son[MAXN];
ll frac[MAXN],pre[MAXN],dp[MAXN];
inline void prework(){
	frac[0]=1;
	for(int i=1;i<MAXN;++i){
		dp[i]=1;
		frac[i]=frac[i-1]*i%p;
	}
	for(int i=n;i>=2;--i){
		++son[i];
		son[i>>1]+=son[i];
	}
	++son[1];
}
inline ll power(ll x,ll y){
	ll res=1;
	while(y){
		if(y&1){
			(res*=x)%=p;
		}
		(x*=x)%=p;
		y>>=1;
	}
	return res;
}
ll C(int n,int m){
	if(m>n){
		return 0;
	}
	return frac[n]*power(frac[m],p-2)%p*power(frac[n-m],p-2)%p;
}
ll lucas(int n,int m){
	if(!m){
		return 1;
	}
	return C(n%p,m%p)*lucas(n/p,m/p)%p;
}
int main(){
    scanf("%d %d",&n,&p);
 	prework();
   	for(int i=n;i>=1;--i){
    	dp[i]=lucas(son[i]-1,son[i<<1])*dp[i<<1]%p*dp[i<<1|1]%p;
	}
    printf("%lld",dp[1]);
}