质数基本概念

质数就是大于1的整数中只有1和本身两种因子的整数，或者叫素数

质数的判定（试除法）

定义判断

简单的根据定义进行判断即可，判断两个条件，第一是否大于1，第二是否满足只有1和本身两种因子
时间复杂度是O(n)的，由于因子是成对出现的，因此只需要遍历前半部分因子就行，也就是只需要遍历到sqrt(n)，将时间复杂度降为O(根号n)，数据量稍大也容易超时
(1)但是直接用sqrt(n)这个函数是比较慢的，不推荐，会容易超时，要么就先算出来，要么不用
(2)写作ii<=n，也不行，ii可能会爆int，
(3)写作i<=n/i比较稳妥
代码：

bool sushu(int a)
{
    if(a==1||a==0) return false;   //不满足第一个定义
    for(int i=2;i<=a/i;i++)     //到sqrt(a)就能遍历完所有因子了
    {
        if(a%i==0) return false;
    }
    return true;
}

分解质因数

对于任何一个正整数n，都可以分解成多个质数因子相乘，即p1,p2,p3…pk是质数因子，
n =p1^a1 * p2^a2 * p3^a3 * …*pk^ak，pk作为质数底数，ak作为该质数的指数
刷题链接：https://www.acwing.com/problem/content/869/
求解思路：枚举所有素数因子，并且对每个因子循环求一下指数就行，
代码：

注意一个点，在枚举的时候不需要判断当前枚举到的因子是否是质数，因为当枚举到i时，说明a的2~i-1的因子已经都被除干净了，a中就不包含2 ~ i-1中的因子了，这时候如果i是a的因子，表示i中也不包含2 ~ i-1中的因子了（倍数都不包含，其中一个因子肯定也不包含啊），那么根据定义，当前i不包含2 ~ i-1中的任何因子，因此当前i就是一个质数，因此每次就不需要再多余判断了，不然用普通的定义法或者离线筛法都会超时
超时写法：

#include<iostream>
#include<math.h>
#include<map>
using namespace std;
const int N=200005;
map<int,int>sushu;
//先给质数打个表
void init()
{
	//0表示是素数，1表示不是素数
	sushu[1]=1;sushu[0]=1; 
	sushu[2]=0;
	for(int i=2;i<=N;i++)
	{
		if(sushu[i]) continue;  //如果已经被标记为不是素数了，后面的倍数肯定也被标记了不是素数 
		for(int j=i*2;j<=N;j+=i)
		{
			if(!sushu[j]) sushu[j]=1;
		}
	} 
} 
int n,a;
int main()
{
	init();
	cin>>n;
	while(n--)
	{
		cin>>a;
		while(a>1)
		{
			for(int i=2;i<=a;i++)     
			{
				if((a%i==0)&&(sushu[i]==0))   //是因子，并且是素数 
				{
				    int t=0; 
				    while(a%i==0)  //求最多能除以多少个i 
				    {
				    	t++; a/=i;
				    }
				    cout<<i<<" "<<t<<endl;
				}
			}
		}
		cout<<endl;
	}
	return 0;
} 

AC代码：

#include<iostream>
#include<math.h>
using namespace std;
int n,a;
int main()
{
	cin>>n;
	while(n--)
	{
		cin>>a;
		for(int i=2;i<=a/i;i++)    //也是只需要枚举到根号a就行了
		{
			if(a%i==0)   //这个时候就已经能保证i是质数了，不需要多余一个判断 
			{
				int t=0; 
			    while(a%i==0)  //求最多能除以多少个i 
			    {
			    	t++; a/=i;
			    }
			    cout<<i<<" "<<t<<endl;
			}
		} 
		//a中最多只包含一个大于根号a的质因子，前面只枚举到根号a，如果最后剩下的值a大于1说明还存在这个大于根号a的质因子，单独输出，如果不存在，a除光了所有的因子，自己肯定是1了
		if(a>1) cout<<a<<' '<<1<<endl;
		cout<<endl;
	}
	return 0;
} 

注意一点，虽然定义法求素数和分解质因子的时间复杂度都是O(sqrt(n))，但是两者是不一样的，定义法一定会循环sqrt(n)词，但是分解质因子的a是不断地减小的，假如a是2^k次方，第一次除以k次2的时候出来a就变为1了，就结束了，因此分解质因子的时间复杂度严格来说应该是O(logn~sqrt(n))，比定义法的会快一点

筛法求素数

上面的直接遍历所有数，判断每个数是不是当前n的因子的时间复杂度O(n)还是有点高的，如果有m个数需要判断，时间复杂度就会是O(m*n)，这种情况下有一种打表的标记素数的方式，筛法求素数提前把所需要的数据范围N内的素数全部标记一下，然后对m个数直接if判断就行，由于范围N内的每个数只会被标记一次，因此时间复杂度降为O(N+n)
但是对于每个数的取值范围N很大的情况也不友好，
比如这道题：https://www.acwing.com/problem/content/868/ ，数据范围达到了2³²，筛一遍肯定超时了
但是对于这道题：https://www.acwing.com/problem/content/870/，数据范围就是1e6，就能把O(n^2)时间复杂度降为O(1e6+n)，达到优化的效果

筛法求素数也有多种求法，但是大致的思路都是先假定所有的数都是素数，然后再将那些不是素数的数筛出去，st[i]=true|1表示不是素数，st[i]=false|0表示是素数,初始时候让所有的元素的st都等于0，都是素数，然后再逐步地将不是素数的标记为1

1.最普通的筛法 O(nlogn)

从前往后遍历数据范围N内的所有数，每次遍历都把当前数的倍数都给筛出去。
简单证明：假如当前要筛选的数为p，如果2 ~ p-1的数没能把p筛出去，就说明p不是2~p-1中任意一个数的倍数，也就是是回归定义，p在2 ~ p-1不存在因子 ,因此p是质数
时间复杂度：n/2+n/3+…n/n =nln(n)=nlogn

void get_primes2(){
    for(int i=2;i<=n;i++){
        if(!st[i]) primes[cnt++]=i;//把素数存起来
        for(int j=i;j<=n;j+=i){//不管是合数还是质数，都用来筛掉后面它的倍数
            st[j]=true;
        }
    }
}

2.诶氏筛法 O(nloglogn)粗略等于O(n)

只需要用质数来将它的倍数都筛掉，因为如果对合数也筛掉它的倍数的话，实际在前面他的因子已经将这个合数以及这个合数的所有倍数都筛出去了，不需要再筛一遍了，重复。能比普通筛法快3倍左右

void get_primes1(){
    for(int i=2;i<=n;i++){
        if(!st[i]){
            primes[cnt++]=i;
            for(int j=i;j<=n;j+=i) st[j]=true;//可以用质数就把所有的合数都筛掉；
        }
    }
}

3.线性筛法 O(n)

当数据范围达到1e7的情况下，线性筛法的速度能达到埃氏筛法的一倍左右
前面的两种筛法对每个合数进行筛除的时候可能存在重复筛除的情况，比如在埃氏筛法中15就会被3和5两个质数进行筛除，在普通筛法中每个数还会被合数因子筛除。
线性筛法就保证了每个数只会被自己的最小质因子筛除，不存在重复筛除的情况，会减少时间复杂度
代码：

void get_primes()
{
	for(int i=2;i<=n;i++)
	{
		if(!st[i])   	primes[cnt++]=i;   //标记为是质数 
		for(int j=0;primes[j]<=n/i;j++)   //从小到达遍历当前已有质数 ，结束的条件看做是保证下面的st[primes[j]*i]数组下标不越界，也就是只需要标记到第n个数
		{   //不需要加j<cnt的条件，因为循环一定会在if(i%primes[j]==0) break;的时候跳出，因为如果i是合数，一定会存在最小质因子使条件满足，如果i是质数，在枚举到primes[j]=i的时候也就跳出了
			st[primes[j]*i]=true;  //标记为不是质数
			if(i%primes[j]==0) break;    //这时候primes[j]一定是i的最小质因子，因为是从前往后遍历所有质数，到达一个因子就跳出 
		}
	}
}

先记住模板，然后我们再来证明为什么每个合数只会被他的最小质因子筛除，并且还要证明所有的合数都会被筛除，最后剩下的就全都是质数了。
证明一：每个合数只会被他的最小质因子筛除
在循环里的 st[primes[j]*i]=true; 进行筛除的时候，存在两种情况
第一种情况：i%primes[j] == 0 , 由于是从小到大遍历所有的质数，因此表示primes[j]是i的最小质因子，也就说明primes[j]是primes[j]*i的最小质因子
第二种情况：i%primes[j] != 0的时候 ,表示primes[j]小于i的最小质因子，也就说明primes[j]是primes[j]*i的最小质因子
得证，每次筛除primes[j]*i（合数）的时候都是用其最小质因子筛除的

证明二：所有合数都会被筛除
易知任何一个约数x，都会在循环遍历到它之前被筛出，因为在遍历到它之前，总会出现primes[j]*i=x（每个合数都存在一个最小质因子）

因此从上可以看出，由于每个数只有一个最小质因子，每个数只会被自己的最小质因子筛除，因此每个数只会被筛一次，时间复杂度保证了是O(n)线性的

革命尚未成功，同志仍需努力…