素数知识总结

素数

一、素数的定义：

​ 素数又称质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

​ ◼ 素数有无限个 如2、3、5、7、11、13、17、19…

​ ◼ 所有素数只有两个约数 ：1和它本身 素数没有真约数

​ ◼ 和 1 既不是素数也不是合数 最小的素数是 2

二、素数的判定方法：

(1)试除法：若自然数n不能被[2, 𝑛]内的所有数整除，则n是素数

​ ◼ 加速技巧：大于4的素数总是等于 6x+1 或 6x-1

​ ◼ 如何证明：约数一定是成对出现，d 和 n/d

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

// 试除法 加速版
bool is_prime(int x){
    if(x<=3){
        return x>1;
    }
    if(x%6!=1 && x%6!=5){
        return false;
    }
    for(int i=5;i<=x/i;i+=6){
        if(x%i==0 || x%(i+2)==0){
            return false;
        }
    }
    return true;
}

(2) 大素数的判定算法：

​ ◼ 费马小定理 xp=x(mod p)，Miller-Rabin算法

三、素数筛法：

一、埃式筛法：求区间 [2, n] 内所有的素数

(1)、 算法思想：

​ ◼ 初始数列：{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, …, n}

​ ◼ 输出最小的素数 {2}，筛掉2的倍数，剩下 {3，5，7，9，11，13，…}

​ ◼ 输出素数 {2,3}，筛掉3的倍数，剩下 {5，7，11，13，…}

​ ◼ 输出素数 {2,3,5}，筛掉5的倍数，剩下 {7，11，13，…}

​ ◼ 继续以上步骤，直到n

(2)、复杂度分析：O(n*log logn)

​ ◼ 筛选次数：n/2+n/3+…+n/n = n(1/2+1/3+…+1/n)

​ ◼ 调和级数:
Font metrics not found for font: .
​ ◼ 素数分布：π(x) ≈ x/lnx

void get_primes(int n)
{
	for(int i=2;i<=n;i++)
	{
		is_prime[i]=true;
	}
	for(int i=2;i<=n;i++)
	{
		if(is_prime[i])
		{
			for(int j=2;i*j<=n;j++)
				is_prime[i*j]=false;
		}
	}
 }

​

二、线性筛法(欧拉筛)：O(n)

算法思想：在埃式筛的基础上保证每个合数仅被它最小的质因数筛去

const int N=1e6+10;
int primes[N],cnt;
bool st[N];
void get_primes(int n){
    memset(st,0,sizeof(st));
    cnt = 0;
    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]=true;
            if(i%primes[j]==0){
                break;
            }
        }
    }
}

​

四、例题：素数距离

一、算法思想 ：

​ ◼ 由于1<=L,R<=2^31-1;无法直接用筛法筛出所有既超空间 又超时

​ ◼ 无法筛出区间内的素数个数所以

​ ◼ 由于约数是成对存在的对于[l,r]之间的所有合数必然有一个约数是在[1~50000]

​ ◼ 对每一个测试样例1~sqrt(2^31)-1 ≈ 50000 所以先晒出50000以内的所有素数(质因子)

​ ◼ 再将筛出来的每一个质因子在[l,r]内的所有倍数筛去

​ ◼ 最后遍历一遍[l,r]区间即可得出答案

#include <iostream>
#include <algorithm>
#include <cstring>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int primes[N], cnt;
bool st[N];
void get_primes(int n)
{
    // 每次筛质因数要清空一次
    memset(st, 0, sizeof(st));
    cnt = 0;
    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] = true;
            if (i % primes[j]==0)
            {
                break;
            }
        }
    }
}
int main()
{
    int l, r;
    while (~scanf("%d%d", &l, &r))
    {
        // 先筛出 50000 内所有质因数
        get_primes(50000);
        memset(st, 0, sizeof(st));
        // 用50000内所有的质数 在[l,r]内的所有倍数筛掉 剩下的就是[l,r]内的质数
        for (int i = 0; i < cnt; i++)
        {
            LL p = primes[i];
            for (LL j = max(2 * p, (l + p - 1) / p * p); j <= r; j += p)
            {
                st[j - l] = true;
            }
        }
        // 复用primes[]
        cnt = 0;
        for (int i = 0; i <= r - l; i++)
        {
            if (!st[i] && (i + l) >= 2)
            {
                primes[cnt++] = i+l;
            }
        }
        // 没有素数对([l,r]之间只有一个素数)
        if (cnt < 2)
        {
            puts("There are no adjacent primes.");
        }
        else
        {
            // min1(max1)存当前最小(大)距离素数对中第一个数的下标
            LL min1 = 0, max1 = 0;
            for (int i = 0; i < cnt - 1; i++)
            {
                LL d = primes[i + 1] - primes[i];
                if (d < (primes[min1 + 1] - primes[min1]))
                {
                    min1 = i;
                }
                if (d > (primes[max1 + 1] - primes[max1]))
                {
                    max1 = i;
                }
            }
            printf("%d,%d are closest, %d,%d are most distant.\n", primes[min1], primes[min1 + 1], primes[max1], primes[max1 + 1]);
        }
    }
    return 0;
}