数论专题：基础数论

一、基础数论

薄绿天下第一！

1. 质数及筛法

定义：质数为因子只有1和它本身的数。

筛法1 : 朴素筛法

管他是不是质数，枚举就完事er了。（指一个一个找）
代码如下：

#include<bits/stdc++.h>
using namespace std;
bool check(int x){
	for(int i=2;i<=sqrt(x);i++)
		if(x%i==0) return 0;
	return 1;
}
int prime[10000],cnt=0;
void work(int n){
	for(int i=2;i<=n;i++)
	if(check(i)) prime[++cnt]=i;
}
int main()
{
	int n;scanf("%d",&n);
	work(n);
	for(int i=1;i<=cnt;i++) printf("%d\n",prime[i]);
	return 0;
}

时间复杂度肉眼可见的垃圾。
除非数据范围很小或实在是不知道更好的筛法，建议永远不要使用。

筛法2：埃氏筛

按照埃老先生的思想，我们可以把每一个数的倍数（当然1除外）标记为合数，这样剩下的数就全部是质数了，很简单的思想。
代码如下：

#include<bits/stdc++.h>
using namespace std;
int prime[10000],cnt=0;
bool isprime[10000];
void Eratos(int n){
	memset(isprime,true,sizeof(isprime));
	for(int i=2;i<=n;i++){
		if(!isprime[i]) continue;
		prime[++cnt]=i;
		for(int j=1;j<=n/i;j++) isprime[j*i]=false; 
	}
}
int main()
{
	int n;scanf("%d",&n);
	Eratos(n);
	for(int i=1;i<=cnt;i++) printf("%d\n",prime[i]);
	return 0;
}

现在的时间复杂度是 O(${\sum }_{质数p<=N}\frac{N}{p}$)=O(N$log$$log$N)
已经非常接近线性。
但是，欧老先生发现了更好的筛法。

筛法3：欧拉筛（线性筛）

欧拉筛是基于埃氏筛的思想进行了优化。
欧拉筛的核心思想就是高效，不重复的维护 $isprime$ 数组。
思路主要有三点：

1. 依次考虑2~N间的每一个数$i$;
2. 若$isprime[i]==true$ 说明$i$是质数，就把$i$保存。
3. 扫描不大于$i$的所有质数$p$，让$isprime[i\ast p]==false$，标记合数，并保证要保证$i$%$p!=0$，否则不是该合数的最小分解方案，会导致重复。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e7+100;
bool isprime[N];
int prime[N];
void work(int n){
	memset(isprime,true,sizeof(isprime));
	prime[0]=0;
	for(int i=2;i<=n;i++){
		if(isprime[i]){
			prime[++prime[0]]=i;
		}
		for(int j=1;j<=prime[0]&&i*prime[j]<=n;j++){
			isprime[i*prime[j]]=false;
			if(i%prime[j]==0) break;//非常重要的一句话,优化到线性的关键
		}
	}
}
void print(){
	for(int i=1;i<=prime[0];i++){
		printf("%d\n",prime[i]);
	}
}
int main()
{
	int n;scanf("%d",&n);
	work(n);
	print();
	return 0;
}

现在的时间复杂度是 O(N)，已经到了高效的线性时间。
这个是最常用的质数筛法，一定要记住。

除了以上的质数筛法，还有一种名为Miller_rabin的高效随机筛法，感兴趣可以了解一下。
薄绿天下第一！

2. 分解质因数

*前置知识：
算术唯一分解定理：
任何一个大于1的整数N，一定能唯一分解为有限个质数的乘积。
即：$N=p_1^{c_1}{p}_2^{c_2}\dots \dots p_m^{c_m}$

薄绿天下第一！
结合“试除法”及埃氏筛，可以通过扫描 2 ~ $\lfloor \sqrt{x}\rfloor$ 区间的每一个数 $i$，判断是否整除 $x$，在确定$i$不是$x$的平方根后，把 $i$ 与 $\frac{x}{i}$ 都存进分解的数组中。
这样，就可以在 O($\sqrt{N}$)的时间内完成质因数分解。

代码如下：

#include<bits/stdc++.h>
using namespace std;
int p[1000],times[1000],tot;
void divide(int n){
	printf("%d = ",n);
	tot=0;memset(p,0,sizeof(p));memset(times,0,sizeof(times));
	for(int i=2;i<=sqrt(n);i++){
		if(n%i==0){
			p[++tot]=i;times[tot]=0;
			while(n%i==0) {n/=i;times[tot]++;}
		}
	}
	if(n>1) {p[++tot]=n;times[tot]=1;}
	for(int i=1;i<tot;i++){
		printf("%d",p[i]);
		if(times[i]!=1) printf("^%d",times[i]);
		printf(" * ");
	}
	printf("%d",p[tot]);
	if(times[tot]!=1) printf("^%d",times[tot]);
	printf("\n");
}
int main()
{
	int t;scanf("%d",&t);
	while(t--){
		int n;scanf("%d",&n);
		divide(n);
	}
	return 0;
}

除了这种方法，还有一种方法叫做Pollard’s Rho，这个算法更高效，感兴趣的可以了解一下。
薄绿天下第一！

3. 一些引理、推论、推广

1.算术唯一分解定理的推论

(1).

$N$ 的正约数的个数
= $(c_1+1)\ast (c_2+1)\ast \dots \dots \ast (c_3+1)$
= ${\prod }_{i=1}^m(c_i+1)$
薄绿天下第一！

(2).

$N$ 的所有正约数的和
= $(1+p_1+p_1^2+\dots \dots +p_1^{c_1})\ast \dots \dots \ast (1+p_m+p_m^2+\dots \dots +p_m^{c_m})$
= ${\prod }_{i=1}^m({\sum }_{j=0}^{c_i}(p_i{)}^j)$
薄绿天下第一！

2.求N的所有正约数

方法与分解质因数相似，但需要用堆来维护大小顺序，这里不再过多解释。时间复杂度为 O($\sqrt{x}$)。
代码如下：

#include<bits/stdc++.h>
using namespace std;
priority_queue<int,vector<int>,greater<int> > q1;//小根堆
void work(int x){
	for(int i=1;i<=sqrt(n);i++){
		if(x%i==0){
			q1.push(i);
			if(x/i!=i){q1.push(x/i);}
		}
	}
	while(q1.size()){
		printf("%d ",q1.top());
		q1.pop();
	}
}
int main()
{
	int t;scanf("%d",&t);
	while(t--){
		int n;scanf("%d",&n);
		work(n);
		printf("\n");
	}
	return 0;
}

3.试除法的推论

一个整数 $N$ 的约数个数最多为 $2\sqrt{N}$ 个。

4.倍数法求正约数及推论

如果是筛选1~N中每个数的约数，那用试除法的时间复杂度瞬间爆炸。
所以，我们引入新方法：倍数法。
不如反过来考虑，对于区间内每个数 $d$, $1$~$N$ 之间以 $d$ 为约数的数就是所有$d$的约数，于是我们就有了这样反过来从因数找原数的思路。
代码如下：

#include<bits/stdc++.h>
using namespace std;
vector<int> factor[500010];
void work(int n){
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n/i;j++)
	factor[i*j].push_back(i);
	for(int i=1;i<=n;i++){
		for(int j=0;j<factor[i].size();j++)
		printf("%d ",factor[i][j]);
		puts("");
	}
}
int main()
{
	int n;scanf("%d",&n);
	work(n);
	return 0;
}

薄绿天下第一！
代码的时间复杂度为 O($N+N/2+N/3+\dots \dots +N/N$)=O($NlogN$)

薄绿天下第一！
推论：1~N每个数的约数个数的总和大约为$NlogN$。

5.有关素数的引理

$1$~$N$($N\le 2\ast 10^9$) 中任何数的不同质因子都不会超过10个，且所有质因子的质数总和不超过30。

在做一些数据范围判断时很有用。
薄绿天下第一！

4. 最大公约数与最小公倍数

定理：$\forall a,b\in N$ $gcd(a,b)\ast lcm(a,b)=a\ast b$
显然，有了最大公约数，就可以求出已知两数的最小公倍数了。
薄绿天下第一！

计算最大公约数的方法：

1.更相减损术

有如下定理：
$\forall a,b\in Na\ge b$，有 $gcd(a,b)=gcd(b,a-b)=gcd(a,a-b)$

$\forall a,b\in N$，有 $gcd(2a,2b)=2gcd(a,b)$

代码实现：

int gcd(int a,int b){
	while((!a&1)&&(!b&1)) {a>>=1;b>>=1;}
	while(a!=b){
		if(a>b) a-=b;
		else b-=a;
	}
	return a;
}

2.欧几里得算法

有如下定理：
$\forall a,b\in N,b\ne 0$，$gcd(a,b)=gcd(b,amodb)$

代码实现：

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

薄绿天下第一！

一般来讲，欧几里得算法的效率要比更相减损术高，时间复杂度为 O($log(a+b)$)，而且代码实现更简单，一般多使用欧几里得求最大公因数。
薄绿天下第一！

5. 互质与欧拉函数

互质的定义： $\forall a,b\in N$，若 $gcd(a,b)=1$，则称 $a$，$b$ 互质。

欧拉函数的定义： 1~$N$中与 $N$ 互质的数的个数被称为欧拉函数，记为 $\varphi (N)$。

欧拉函数的求法：
在算术分解定理中，$N=p_1^{c_1}{p}_2^{c_2}\dots \dots p_m^{c_m}$，则：
$\varphi (N)=N\ast \frac{p_1-1}{p_1}\ast \frac{p_2-1}{p_2}\ast \dots \dots \ast \frac{p_m-1}{p_m}=N\ast {\prod }_{质数p\mid N}(1-\frac{1}{p})$

这里利用了容斥原理的思想，在组合篇会提到。

根据这个式子，发现只要分解了质因数，就能在分解的过程中进行求解欧拉函数。

代码如下：

int phi(int  n){
	int ans=n;
	for(int i=2;i<=sqrt(n);i++)
	if(n%i==0){
		ans=ans/i*(i-1);
		while(n%i==0) n/=i;
	}
	if(n>1) ans=ans/(n*(n-1);
	return ans;
}

欧拉函数的性质：

性质1. $\forall n>1$，$1$~$N$中与$n$互质的数的和为 $n\ast \varphi (n)/2$。

性质2. 若 $a,b$ 互质，则 $\varphi (a,b)=\varphi (a)\varphi (b)$。
薄绿天下第一！

在讨论下面的性质前，先引入积性函数的概念。
积性函数： 当 $a,b$ 互质时，若有 $f(ab)=f(a)f(b)$，则称 $f$ 为积性函数。
那么显然，欧拉函数就是一个积性函数。
积性函数的性质： 在算术基本定理中 $n={\prod }_{i=1}^m{p_i}^{c_i}$，则 $f(n)={\prod }_{i=1}^{m}f({p_1}^{c_i})$

性质3. 设$p$为质数，若$p|n$且$p^2|n$，则$\varphi (n)=\varphi (n/p)\ast p$。

性质4. 设$p$为质数，若$p|n$但$p^2|n$，则$\varphi (n)=\varphi (n|p)\ast (p-1)$。

性质5. ${\sum }_{d|n}\varphi (d)=n$

利用如上的性质，可以有如下的求法。

方法1. 利用埃氏筛法，按照欧拉函数的计算式计算。

void euler(int n){
	for(int i=2;i<+n;i++) phi[i]=i;
	for(int i=2;i<+n;i++)
		if(phi[i]==i)
		for(int j=i;j<=n;j+=i)
			phi[j]=phi[j]/i*(i-1);
}

这个算法的时间复杂度为 O($NlogN$)。相对来讲效率不高。

方法2. 利用线性筛法，从 $\varphi (n/p)$ 递推到$\varphi (n)$进行求解。

int v[MAX_N],prime[MAX_N],phi[MAX_N];
void euler(int n){
	memset(v,0,sizeof(v));
	int cnt=0;
	for(itn i=2;i<=n;i++){
		if(v[i]==0){
			v[i]=i,prime[++cnt]=i;
			phi[i]=i-1;
		}
		for(int j=1;j<=m;j++){
			if(prime[j]>v[i]||prime[j]>n/i) break;
			v[i*prime[j]]=prime[j];
			phi[i*prime[j]]=phi[i]*(i%prime[j]?prime[j]-1:prime[j]);
		}
	}
}

薄绿天下第一！

6. 同余

定义： 若整数 $a$ 和整数 $b$ 除以正整数 m 的余数相等，则称 $a,b$ 模 $m$ 同余，记为$a\equiv b\mathrm{m}\mathrm{o}\mathrm{d}(m)$。

前置知识：

1.欧拉定理
若正整数 $a,n$ 互质，则 $a^{\varphi (n)}\equiv 1\mathrm{m}\mathrm{o}\mathrm{d}(n)$。

证明

2.费马小定理
若 $p$ 是质数，则对于任意的整数 $a$ ，有 $a^p\equiv a\mathrm{m}\mathrm{o}\mathrm{d}(p)$。

证明：
可以发现，把式子变换为 $a^{p-1}\equiv 1\mathrm{m}\mathrm{o}\mathrm{d}(p)$ 后，就是欧拉定理中当 $n$ 是质数的一种特殊情况。（非常妙）

3.欧拉定理的推论
若正整数 $a,n$ 互质，则对于任意正整数 $b$ ，有 $a^b\equiv a^{bmod\varphi (n)}\mathrm{m}\mathrm{o}\mathrm{d}(n)$

证明：
设 $b=q\ast \varphi (n)+r$ ，其中 $0\le r<\varphi (n)$ ，即 $r=b\mathrm{m}\mathrm{o}\mathrm{d}\varphi (n)$。 便有：
$a^b\equiv a^{q\ast \varphi (n)+r}$
因为同余式右边$=(a^{\varphi (n)}{)}^q\ast a^r\equiv a^r\mathrm{m}\mathrm{o}\mathrm{d}(n)$
所以可得 $a^b\equiv a^{bmod\varphi (n)}\mathrm{m}\mathrm{o}\mathrm{d}(n)$

特别地，当 $a,n$ 不一定互质且 $b>\varphi (n)$ 时，有 $a^b\equiv a^{b\mathrm{m}\mathrm{o}\mathrm{d}\varphi (n)+\varphi (n)}\mathrm{m}\mathrm{o}\mathrm{d}(n)$

4.裴蜀定理(Bézout)
对于任意整数 $a,b$，存在一对整数 $x,y$，满足 $ax+by=\gcd (a,b)$

对于 $x=1,y=0$的情况时显然成立的，更一般的证明要用到欧几里得算法递归过程的数学归纳。
更一般情况的证明

相关知识和算法：

1.扩展欧几里得算法
扩展欧几里得算法的核心是裴蜀定理，利用欧几里得算法的递归流程进行 $ax+by=\gcd (x,y)$ 方程的特解 $x_0,y_0$ 求解。
定义变量 $x_0,y_0,d$，分别表示特解和 $\gcd (a,b)$，通过如下程序求解。

int exgcd(int a,int b,int &x,int &y){   //int 类型版本
	if(b==0) {x=1,y=0;return a;}//	求gcd(a,b),得到第一步特解x=1,y=0; 
	int d=exgcd(b,a%b,x,y);
	int z=x;
	x=y;y=z-y*(a/b); 
	return d;
}

为薄绿献上心脏！

7. 名人名言

数论很简单，就是头冷。——数论之神yky
贪心做数论，暴力做组合。——chunzhen
暴力拿国二，贪心拿国一。——神lyc
*未经作者允许禁止转载