2021-07-10

什么是质数？

一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数，又称素数；一个大于1的整数，如果除了1和它本身以外，还有其他的约数，这样的数就叫作合数。

如何判断一个数是不是质数

一个数的因数都是成对出现的：例如12的因数有3和4,2和6
根据定义来说，一个质数能被1和它自身外整除，所以我们可以只枚举较小的那一个，假设较小的为d，较大的为n/d；从二开始枚举，小于等于较大的因子，即n/i。那我可以得出这个算法的复杂度 O(sqrt(n)),代码如下：

//试除法
bool is_prime(int n)
{
    if(n<2)  return false;
    for(int i=2;i<=n/i;i++)
    	if(n%i==0) 
    	return false;
    return true;
}

筛质数

给定一个正整数 n，请你求出 1∼n 中质数的个数。
朴素筛法：
把1~n中2的倍数，3的倍数， 4的倍数……都删除，那么剩下的数就都是质数了。
那么代码可以这么写

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e6 + 5;
int n, x;
int primes[N], res;
bool st[N];

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i]) res ++ ;
        for(int j = i + i; j <= n; j += i)//把小于等于n内，倍数都删除
                st[j] = 1;
    }
}

int main()
{
    cin >> n;
    get_primes(n);
    cout << res << endl;
    return 0;
}

让我们分析一下这个算法的复杂度
当i=2时，循环次数 ：n/2
当i=3时，循环次数 ：n/3
当i=4时，循环次数 ：n/4
…
当i=n时，循环次数 ：n/n

我们所以循环次数相加可以得到：n*(1/2+1/3+1/4…)，令t=(1/2+1/3+1/4…)，由于根据高等数学的知识我们知道，这是一个调和级数，等n趋近于正无穷的时候，t=ln(n),所以我们可以得出我们的复杂度为O(nlogn)

那么可不可以更优化一下呢？
我们发现其实一个合数可以有质数相加得到，那么我们就可以只筛质数的倍数，，这个算法，称为诶氏筛法，我们再来分析一下这个算法的时间复杂度，根据质数定理，1-n中，质数的个数大约有n/ln(n)个，再根据之前的算法复杂度，诶氏筛法的复杂应该为：nlog(log(n))

上代码

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;//可以用质数就把所有的合数都筛掉；
        }
    }
}

很优秀了，不是？那可不可以再优化一下呢？
可以的，于是，线性筛诞生了
核心思想：每个数字都被它的最小质因数筛掉

void get_prime(int n) 
{
    for (int i = 2; i <= n; ++i) 
    {
        if (!st[i]) prime[cnt++] = i; // 如果这个数字没有被记录，那么这个数字必然为素数，记录一下
        for (int j = 0; prime[j] <= n/i; ++j) 
        {
            st[prime[j] * i] = true;  // 筛掉pj*i这个合数
            if (i % prime[j] == 0)  
            break; // i%pj==0，说明prime[j]是i的最小素因子，因此i*素数的最小素因子也是prime[j]，在i递增的时候也会被筛掉，因此不需要在这里判断
        }                
    }
}

以上代码的二层循环
1)当i%primes[j]!=0时,说明此时遍历到的primes[j]不是i的质因子，那么只可能是此时的primes[j]<i的最小质因子,所以primes[j]*i的最小质因子就是primes[j];
2)当有i%primes[j]==0时,说明i的最小质因子是primes[j],因此primes[j]*i的最小质因子也就应该是prime[j]，之后接着用st[primes[j+1]*i]=true去筛合数时，就不是用最小质因子去更新了,因为i有最小质因子primes[j]<primes[j+1],此时的primes[j+1]不是primes[j+1]*i的最小质因子，此时就应该退出循环，避免之后重复进行筛选。
所以综上所述这个算法的算法复杂度为0(n);