浅谈算法竞赛中的初等数论1-----素数，素数筛，欧拉函数等（比较详细）

liujassin

于 2024-02-07 15:11:56 发布

阅读量1.3k

点赞数 39

分类专栏：数论文章标签： c++ 算法

本文链接：https://blog.csdn.net/liujassin/article/details/136052692

版权

数论专栏收录该内容

1 篇文章 0 订阅

订阅专栏

# 非短篇预警 #

前言

研究正整数的性质都可以叫数论，整数是数学中最简单的结构，但数论中所产生的问题在OI中产生的问题也是最多最复杂的（即使代码能力再强），本文将讲述数论中最简单的板块——素数

前置知识

整除

定义：如果 $\frac{a}{b}$ ∈Z，则称b整除a或a被b整除，记为a|b,此时a称为b的倍数，b为a的约数；

注意：0能被任何整数整除

取整

$\left \lfloor \frac{a}{b} \right \rfloor$ 表示向下取整，在c++中通常用floor表示

floor(a/b)

$\left \lceil \frac{a}{b } \right \rceil$ 表示向上取整，在c++中通常使用ceil表示

ceil(a/b)

$\left \lceil \frac{a}{b } \right \rceil$ = $\left \lfloor \frac{a+b-1}{b} \right \rfloor$ ,a%b=a- $\left \lfloor \frac{a}{b} \right \rfloor$ b;

最大公因数

在信息学竞赛中通常使用gcd(a,b)来表示a和b最大公因数，同时用lcm(a,b)表示a,b的最小公倍数

lcm(a,b)=ab/gcd(a,b),gcd(a,b-a),gcd(a,0)=a,若c|a,c|b,则gcd(a,b)=cgcd(a/c,b/c);

以上为最大公因数的常用性质；

求最大公因数的方法

欧几里得算法（辗转相除法）

原理：gcd(a,b)=gcd(b,a%b) 证明略

时间复杂度：0（log(max(a,b))）

代码实现

//法一
int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}
//法二
int gcd(int a,int b)
{
    if(b)
    {
        return gcd(b,a%b);
    }
    else return a;
}

此方法缺点：取余（%）不好计算（比如高精度）

更相减损数

若a,b均为偶数 gcd(a,b)=2gcd(a/2,b/2)

若只有a为偶数 gcd(a,b)=gcd(a/2,b),只有b为偶数 gcd(a,b)=gcd(a,b/2）

若均不为偶数，gcd(a,b)=gcd(a,a-b)(a>b)

[SDOI2009] SuperGCD - 洛谷 GCD LCM - 洛谷

前者较难后者较易。

至此，前置知识基本结束

素数的定义

顾名思义，素数指的就是只能被1和其本身向整除的数（此数大于2且为整数），素数理论上有无数个。

素数的判定

我们可以通过枚举2-n判断是否存在n的因数，由此便得到了判断素数的朴素版

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	bool vis=1;
	cin>>n;
	if(n==1)   //特判1不为质数 
	{
		cout<<"NO"<<endl;
		return 0;
	}
	if(n==2)  //特判2是质数 
	{
		cout<<"YES"<<endl;
		return 0;
	}
	for(int i=2;i<=n;i++)//从2开始枚举 
	{
		if(n%i==0)
		{
			vis=false;
			break;
		}
	}
	if(vis==false)
	{
		cout<<"NO"<<endl;
	}
	else
	{
		cout<<"YES"<<endl;
	}
	return 0;
}

此时的时间复杂度为O(n) 当数据大时容易超时，so我们要进行优化

我们可以轻松知道不超过n的素数有 $\frac{n}{logn }$ 个，合数一定有不超过 $\sqrt{n}$ 个因数，由此我们可以进行优化只枚举1- $\sqrt{n}$ 。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	bool vis=1;
	cin>>n;
	if(n==1)   //ÌØÅÐ1²»ÎªÖÊÊý 
	{
		cout<<"NO"<<endl;
		return 0;
	}
	for(int i=2;i*i<=n;i++)//´Ó2¿ªÊ¼Ã¶¾Ù 
	{
		if(n%i==0)
		{
			vis=false;
			break;
		}
	}
	if(vis==false)
	{
		cout<<"NO"<<endl;
	}
	else
	{
		cout<<"YES"<<endl;
	}
	return 0;
}

此时时间复杂度为 $\sqrt{n}$

唯一分解定理（俗称分解质因数）

此处只讲定义：任意一个正整数N一定能唯一的写成 N= $p1^{a1}*p2^{a2}...*pn^{an}$ ~~至于证明小学老师应该讲过，此处不讲~~

分解质因数的原理不用过多阐述，直接上代码：

int pi[N],pcnt[N],tot; //pi表示质因子，pcnt表示其指数，tot表示个数 
void decompose(int x)
{
	for(int i=2;i*i<=x;i++)
	{
		if(x%i==0)
		{
			pi[++tot]=i;
			while(x%i==0) ++pcnt[tot],x/=i; //求该质数的指数 
		}
	}
	if(x>1) pl[++tot]=x,pcnt[tot]=1;//若剩余为质数则需要加入 
}

求解1-n的质数个数

埃氏筛

原理：用已知质数和已知合数去筛取其倍数，最终得到的个数即为质数个数。以2（质数）为例，在循环中删去4,6,8.......

代码如下，可结合代码来理解

int np[N],pl[N],tot;//np表示此数是否被标记，最终结果就是求1-n中哪些np[i]的值为0 
void aishi()
{
	np[1]=1;
	for(int i=2;i<=n;i++)
	{
		if(!np[i])
		{
			pl[++tot]=i;
			for(int j=2*i;j<=n;j+=i)//将1-n中所以其倍数筛去 
			{
				np[j]=1;
			}
		}
	}
}

通过代码我们可以明显感觉到这个算法的时间复杂度较大，理由是：很多数都被筛了多变，比如（8），循环“2”和“4”时都筛去该数增加了时间复杂度。

我们该如何优化呢？就是改为线性计算，每个合数都有且只被筛去一边由此我们便引出了著名的线性筛法——“欧拉筛”

欧拉筛

~~由于本人讲的太菜~~，此处讲解摘自《算法竞赛进阶指南》李煜东：

摘毕；

用本人的话来理解就是：该算法通过质因子来优化筛法从而达到线性来减小时间复杂度，即每个合数被且只被最小的质因数筛去。

代码如下可结合代码理解：

int np[N],pl[N],cnt;
void oula(int n)
{
	np[1]=1;
	for(int i=2;i<=n;i++)
	{
		if(!np[i]) 
		{
			pl[++cnt]=i;
		}
		int x;
		for(int j=1;x*pl[j]<=n;j++)
		{
			np[x]=1;
			if(i%pl[j]==0) break;
		}
	}
}

欧拉筛的重要性

欧拉筛的重要性不言而喻，该代码可以求出最小质因数，且因为欧拉筛为一个线性筛法，因此此份代码为线性筛的基础模版，未来有很多的线性筛法本质是由该算法衍生而成（例如求解1-n的莫比乌斯函数，欧拉函数等等）。

欧拉函数

从上文知道欧拉筛可用于求解1-n的欧拉函数，在此，我们讲解一下欧拉函数。

欧拉函数 $\varphi (n )$ 定义为不超过n的正整数中与n互质的数的个数

通过该定义我们可以知道 $\varphi (n )$ =n* $\prod_{p\in{prime},p|n}^{ }{\frac{p-1}{p} }$ ，此公式中p表示n的质因子。有该式子，我们可以知道如何求解1个数的欧拉函数，代码如下：

int oula(int n)
{
	int res=n,t=n;
	for(int i=2;i*i<=t;i++)
	{
		if(t%i== 0)
		{
			res=res/i*(i-1);
			while(t%i==0) t=t/i;
		}
	}
	if(t>1) res=res/t*(t-1);
	return res;
}

通常情况下我们一般很少求解1个数的欧拉函数，一般求解1-n的欧拉函数值，如果在循环n次，时间复杂度就变得很大了，此处就要求我们的计算要为线性计算，所以我们就引出了欧拉函数的线性筛；

欧拉函数的线性筛

通过上文 $\varphi (n )$ =n* $\prod_{p\in{prime},p|n}^{ }{\frac{p-1}{p} }$ 这个式子，我们得到了求解1个数的欧拉函数值，俗话说“万变不离其宗”，所以求解1-n的欧拉函数也要通过这个式子来求解，对这个式子进行轻微的变形，我们便可以得到下面的式子：

$\varphi (pn)=\left\{\begin{matrix} p-1&n=1\\ p\varphi (n) &p|n \\ (p-1)\varphi (n)& otherwise\end{matrix}\right.$ 注意:otherwise表示其余，以后会经常使用

通过上文所提及的线性欧拉筛，我们便可以得到p的值（p仍表示质因子），从而可以在接近O（n）的时间复杂度下进行预处理，代码如下：

#include<bits/stdc++.h>
using namespace std;
conat int N=1e5;
int phi[N],primes[N];
bool vis[N]
void init(long long n)
{
    vis[1]=1;
	phi[1]=1;
    for(long long i=2;i<=n;i++)
    {
        if(!vis[i])primes[++cnt]=i,phi[i]=i-1;
        for(long long j=1;j<=cnt&&i*primes[j]<=n;j++)
        {
            vis[i*primes[j]]=1;
            phi[i*primes[j]]=phi[i]*(primes[j]-1);
            if(i%primes[j]==0)
        	{
               phi[i*primes[j]]=phi[i]*primes[j];
               break;
            }
        }
    }
}

代码应该很好理解，我们仔细观看该代码，不难发现这代码和上文所述的欧拉筛有那么亿点点相似，这也从侧面论证了欧拉筛为基础的线性筛的说法。

至此有关素数的内容就到此为止了。