数学知识1.1-质数

一、简述

本文章主要介绍有关质数的基础算法。

二、质数

• 质数和合数是针对所有大于1的自然数来定义的，小于等于1的整数既不是质数也不是合数。
• 质数的因子只有1和它本身。

三、质数的判定——试除法

设一个数 n，因为质数的因子只有1和它本身，我们可以使用枚举从2 ~ n-1的方式，判断其中的数是否为 n 的因子，若存在 n 的因子，则不是质数，否则是质数。这样算法的时间复杂度是 O(n)。

bool isPrime(int x)
{
    if(x <= 1) return false;
    for(int i = 2; i < x; i ++)
        if(x % i == 0) return false;
    return true;
}

不过，如果对于一个数 n，若存在 d | n(d 整除 n)，则 $\frac{d}{n}$ | n，基于此，我们可以对上面的算法进行优化，使得时间复杂度降到 O($\sqrt{n}$)。

bool isPrime(int x)
{
    if(x <= 1) return false;
    for(int i = 2; i <= x / i; i ++)
        if(x % i == 0) return false;
    return true;
}

模板题AcWing866.试除法判定质数

题目描述

给定 n 个正整数 a_i，判定每个数是否是质数。

输入格式

第一行包含整数 n。
接下来 n 行，每行包含一个正整数 a_i。

输出格式

共 n 行，其中第 i 行输出第 i 个正整数 a_i 是否为质数，是则输出Yes，否则输出No。

数据范围

1≤ n ≤100，1≤ a_i ≤2³¹−1。

输入样例

2
2
6

输出样例

Yes
No

解题思路

试除法。

C++代码

#include <bits/stdc++.h>
using namespace std;
const int N = 110;

int n;

bool isPrime(int x)
{
    if(x <= 1) return false;
    for(int i = 2; i <= x / i; i ++)
        if(x % i == 0) return false;
    return true;
}

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        int x;
        scanf("%d", &x);
        if(isPrime(x)) puts("Yes");
        else puts("No");
    }
    return 0;
}

四、分解质因数——试除法

• 任何一个大于1的自然数 ，如果 N 不为质数，都可以唯一分解成有限个质数的乘积。
  N = $P{}_1^{a^1}$$P{}_2^{a^2}$$P{}_3^{a^3}$⋅⋅⋅$P{}_n^{a^n}$，这里 P₁ < P₂ < ⋅⋅⋅ < P_n 且均为质数，其指数均是正整数。
• 一个数 N 最多只有一个因子大于 $\sqrt{N}$(证明：反证法。假设有两个，则两个的乘积大于 N)。
• 试除法的时间复杂度为 O($\sqrt{n}$)；最好时间复杂度为 O(logn)，所有因子均为2。

void divide(int x)
{
    for(int i = 2; i <= x / i; i ++)
    {
        if(x % i == 0)
        {
            int s = 0;//统计质因子个数
            while(x % i == 0)
            {
                x /= i;
                s ++;
            }
            printf("%d %d\n", i, s);
        }
    }
    if(x > 1) printf("%d 1\n", x);
    printf("\n");
}

对于 x 的任意一个合数因子假设为 y，在枚举到它之前就已经将它从 x 中除去，因为 y 的质因子必是 x 的质因子，而这些质因子早已被枚举并除掉了。当枚举到某一个数 i 的时候，x的因子里面已经不包含[2，i−1]里面的数。

模板题AcWing867.分解质因数

题目描述

给定 n 个正整数 a_i，将每个数分解质因数，并按照质因数从小到大的顺序输出每个质因数的底数和指数。

输入格式

第一行包含整数 n。
接下来 n 行，每行包含一个正整数 a_i。

输出格式

对于每个正整数 a_i，按照从小到大的顺序输出其分解质因数后，每个质因数的底数和指数，每个底数和指数占一行。
每个正整数的质因数全部输出完毕后，输出一个空行。

数据范围

1≤ n ≤100，2≤ a_i ≤2×10⁹。

输入样例

2
6
8

输出样例

2 1
3 1

2 3

解题思路

试除法。

C++代码

#include <bits/stdc++.h>
using namespace std;

int n;

void divide(int x)
{
    for(int i = 2; i <= x / i; i ++)
    {
        if(x % i == 0)
        {
            int s = 0;
            while(x % i == 0)
            {
                x /= i;
                s ++;
            }
            printf("%d %d\n", i, s);
        }
    }
    if(x > 1) printf("%d 1\n", x);
    printf("\n");
}

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        int x;
        scanf("%d", &x);
        divide(x);
    }
    return 0;
}

五、质数筛

朴素筛

• 举例：比如我们要筛出1~16里的所有质数。
  初始数据：2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  • 枚举2的倍数，则4、6、8、10、12、14、16被筛掉。
    剩余数据：2 3 5 7 9 11 13 15
  • 枚举3的倍数，则6、9、12、15被筛掉。
    剩余数据：2 3 5 7 11 13
  • 以此类推，最后剩余的数据2、3、5、7、11、13都是质数。因为我们枚举到 i 时，2到 i-1中一定不含 i 的因子，否则它早就被筛掉了。
• 时间复杂度分析：枚举2的倍数 O($\frac{n}{2}$)，枚举3的倍数 O($\frac{n}{3}$)，...，枚举 n 的倍数 O(1)。调和级数 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/n=lnn + c(c 是欧拉常数，约等于0.577)。而 lnn < logn，故时间复杂度为 O(nlogn)。

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(st[i]) continue;//筛掉了
        primes[cnt ++] = i;
        for(int j = i + i; j <= n; j += i)//枚举倍数
            st[j] = true;
    }
}

埃氏筛

观察上述的朴素筛，我们可以发现，我们在枚举是，有许多数被重复筛掉了，因此我们希望只将质数的倍数筛掉即可。

• 质数定理：1~n 中有 $\frac{n}{lnn}$ 个质数。
• 时间复杂度 O(nlog(logn))。

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i])//质数
        {
            primes[cnt ++] = i;
            for(int j = i + i; j <= n; j += i)
                st[j] = true;
        }
    }
}

线性筛

• 核心思路：每个数都只会被它的最小质因子筛掉。
• 1～n 之间的任何一个合数一定会被筛掉，而且筛的时候只用最小质因子来筛，然后每一个数都只有一个最小质因子，因此每个数都只会被筛一次，因此线性筛法是线性的。

void get_primes(int n)
{
    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;
        }
    }
}

• 关于 i % primes[j]
  • i % primes[j] == 0，则说明 primes[j] 一定是 i 的最小质因子( j 是从0开始枚举的)，则 primes[j] 一定是 primes[j] * i 的最小质因子。
  • i % primes[j] != 0，则说明 primes[j] 一定小于 i 的所有质因子，primes[j] 一定是 primes[j] * i 的最小质因子。

模板题AcWing868.筛质数

题目描述

给定一个正整数 n，请你求出 1∼n 中质数的个数。

输入格式

共一行，包含整数 n。

输出格式

共一行，包含一个整数，表示 1∼n 中质数的个数。

数据范围

1≤n≤10⁶。

输入样例

8

输出样例

4

C++代码

#include <iostream>
using namespace std;
const int N = 1000010;

int n;
int primes[N], cnt;
bool st[N];

/*朴素筛
void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(st[i]) continue;
        primes[cnt ++] = i;
        for(int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}
*/

/*埃氏筛
void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i])
        {
            primes[cnt ++] = i;
            for(int j = i + i; j <= n; j += i)
                st[j] = true;
        }
    }
}
*/

//线性筛
void get_primes(int n)
{
    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()
{
    scanf("%d", &n);
    get_primes(n);
    printf("%d", cnt);
    return 0;
}

六、一个例题

AcWing196.质数距离

题目描述

给定两个整数 $L$ 和 $U$，你需要在闭区间 $[L,U]$ 内找到距离最接近的两个相邻质数 $C_1$ 和 $C_2$（即 $C_2-C_1$ 是最小的），如果存在相同距离的其他相邻质数对，则输出第一对。

同时，你还需要找到距离最远的两个相邻质数 $D_1$ 和 $D_2$（即 $D_1-D_2$ 是最大的），如果存在相同距离的其他相邻质数对，则输出第一对。

输入格式

每行输入两个整数 $L$ 和 $U$，其中 $L$ 和 $U$ 的差值不会超过 ${10}^6$。

输出格式

对于每个 $L$ 和 $U$，输出一个结果，结果占一行。

结果包括距离最近的相邻质数对和距离最远的相邻质数对。（具体格式参照样例）

如果 $L$ 和 $U$ 之间不存在质数对，则输出 There are no adjacent primes.。

数据范围

$1\le L<U\le 2^{31}-1$

输入样例

2 17
14 17

输出样例

2,3 are closest, 7,11 are most distant.
There are no adjacent primes.

解题思路

首先，区间的范围是不超过 ${10}^6$，但是区间的左右端点范围很大，显然我们不能预处理出 $2^{31}-1$ 范围内的质数。那么我们就需要挖掘一些性。首先，如果一个数 $x$ 是合数，那么 $x$ 可以分解为两数相乘的形式，且其中一个数可以为质数， $x=a\ast b$，我们假定 $a<b$，那么 $a<\sqrt{x}$。也就有对于 $2^{31}-1$ 及小于其的合数，都含有小于等于 $sqrt(2^{31}-1)$ 的质因子。那么我们大概就可以处理 $[2,50000]$ 的质因子即可。再一个，处理出质数，我们使用筛法将 $[L,U]$ 区间的内的处理的质数的至少二倍数都排除掉，那么剩余的就是 $[L,U]$ 的质数了。然后我们将这些质数存下来，依次遍历取答案即可。

C++代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
typedef long long LL;

int primes[N], cnt;
bool st[N];

void init(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] * i <= n; j ++)
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0)
                break;
        }
    }
}

int main()
{
    int l, r;
    while (cin >> l >> r)
    {
        init(50000);
        memset(st, 0, sizeof st);
        for (int i = 0; i < cnt; i ++)
        {
            LL p = primes[i];
            for (LL j = max(p * 2, (l + p - 1) / p * p); j <= r; j += p)
                st[j - l] = true;
        }
        cnt = 0;
        for (int i = 0; i <= r - l; i ++)
            if (!st[i] && i + l >= 2)
                primes[cnt ++] = i + l;
        if (cnt < 2)
            puts("There are no adjacent primes.");
        else
        {
            int minp = 0, maxp = 0;
            for (int i = 0; i + 1 < cnt; i ++)
            {
                int d = primes[i + 1] - primes[i];
                if (d < primes[minp + 1] - primes[minp])
                    minp = i;
                if (d > primes[maxp + 1] - primes[maxp])
                    maxp = i;
            }
            printf("%d,%d are closest, %d,%d are most distant.\n",
                primes[minp], primes[minp + 1], primes[maxp], primes[maxp + 1]);
        }
    }
    return 0;
}