算法竞赛进阶指南 数学知识 0x31 质数

定义

若一个整数无法被除了1和它自身之外的任何自然数整除，则称该数为质数（素数），否则称该正整数为合数

在整个自然数集合中，质数的数量不多，分布比较稀疏，对于一个足够大的整数N，不超过N的质数大约有$N/lnN$个，即每lnN个数中大约有1个质数

质数的判定

1、试除法

若一个正整数N为合数，则存在一个能整除N的数T，其中$2\le T\le \sqrt{N}$

我们需要特判0和1这两个整数，它们既不是质数，也不是合数

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

质数的筛选

给定一个整数N，求出1～N之间的所有质数，称为质数的筛选问题

1、Eratosthenes筛法

Eratosthenes筛法基于这样的想法：任意整数x的倍数 2x，3x，…都不是质数

我们可以从2开始，由小到大扫描每个数x，把它的倍数 2x, 3x, …, $\lfloor N/x\rfloor \ast x$标记为合数。当扫描到一个数时，若它尚未被标记，则它不能被2～x - 1之间的任何数整除，该数就是质数

另外，我们可以发现，2和3都会把6标记为合数。实际上，小于$x^2$的x的倍数在扫描更小的数时就已经被标记过了。因此，我们可以对Eratosthenes筛法进行优化，对于每个数x，我们只需要从$x^2$开始，把$x^2$, (x + 1) * x, … , $\lfloor N/x\rfloor \ast x$ 标记为合数即可

void primes(int n) {
    memset(v, 0, sizeof v);
    for (int i = 2; i <= n; ++ i) {
        if (v[i]) continue;
        cout << i << endl;
        for (int j = i; j <= n / i; ++ j) v[i * j] = 1;
    }
}

Eratosthenes筛法的时间复杂度为$O({\sum }_{质数p\le N}\frac{N}{P})=O(NloglogN)$，效率已经非常接近于线性，是算法竞赛中最常用的质数筛法

2、线性筛法

即使在优化后（从$x^2$开始），Eratosthenes筛法仍然会重复标记合数。例如12既会被2又会被3标记，在标记2的倍数时，12 = 6 * 2，在标记3的倍数时，12 = 4 * 3。其根本原因是我们没有确定出唯一的产生12的方式

线性筛法通过“从大到小累积质因子”的方式标记每个合数，即让12只有3 * 2 * 2一种产生方式，设数组v记录每个数的最小质因子，我们按照以下步骤维护v
1、依次考虑2～N之间的每一个数i
2、若 v[i] = i，说明i是质数，把它保存下来
3、扫描不大于v[i]的每个质数p，令v[i * p] = p。也就是在i的基础上累积一个质因子p，因为$p\le v[i]$，所以p就是合数i * p的最小质因子

每个合数i * p只会被它的最小质因子p筛一次，时间复杂度为$O(N)$

下面例题一中提供了线性筛法的另一种写法

int v[N], primes[N];
void primes(int n) {
    memset(v, 0, sizeof v); // 最小质因子
    int m = 0; // 质数数量
    for (int i = 2; i <= n; ++ i) {
        if (v[i] == 0) { // i是质数
            v[i] = i;
            primes[m ++ ] = i;
        }
        // 给当前的数i乘上一个质因子
        for (int j = 0; j < m; ++ j) {
            // i有比primes[j]更小的质因子，或者超出n的范围，停止循环
            if (primes[j] > v[i] || primes[j] > n / i) break;
            // primes[j]是合数i * primes[j]的最小质因子
            v[i * primes[j]] = primes[j];
        }
    }
    for (int i = 0; i < m; ++ i) cout << primes[i] << endl;
}

质因数分解

1、算术基本定理

任何一个大于1的正整数都能唯一分解为有限个质数的乘积，可写作：
$N=p_1^{c_1}{p}_2^{c_2}...p_m^{c_m}$
其中，c_i都是正整数，p_i都是质数，且满足$p_1<p_2<...<p_m$

2、试除法

结合质数判定的“试除法”和质数筛选的“Eratosthenes筛法“，我们可以扫描 2 ~ $\lfloor \sqrt{N}\rfloor$的每个数d，若d能整除N，则从N中除掉所有的因子d，同时累积除去的d的个数

因为一个合数的因子一定在扫描到这个合数之前就从N中被除掉了，所以在上述过程中能整除N的一定是质数。最终就得到了质因数分解的结果，易知时间复杂度为$O(\lfloor \sqrt{N}\rfloor )$

特别地，若N没有被任何 2 ~ $\lfloor \sqrt{N}\rfloor$的数整除，则N是质数，无需分解

void divide(int n) {
	m = 0;
    for (int i = 2; i <= sqrt(n); ++ i) {
        if (n % i == 0) {
            p[m] = i; c[m] = 0;
            while (n % i == 0) n /= i, c[m] ++ ;
            m ++ ;
        }
    }
    // n是质数
    if (n > 1) {
        p[m] = n; c[m ++ ] = 1;
    }
    for (int i = 0; i < m; ++ i)
        cout << p[i] << '^' << c[i] << endl;
}

AcWing 196. 质数距离

题意 ：

• 给定两个整数 L 和 U，你需要在闭区间 [L,U] 内找到距离最接近的两个相邻质数 C1 和 C2（即 C2−C1 是最小的），如果存在相同距离的其他相邻质数对，则输出第一对。
• 同时，你还需要找到距离最远的两个相邻质数 D1 和 D2（即 D1−D2 是最大的），如果存在相同距离的其他相邻质数对，则输出第一对。
• 1≤L<U≤2^{31}−1
• 每行输入两个整数 L 和 U，其中 L 和 U 的差值不会超过 10^6。

思路 ：

• L，R的范围很大，任何已知算法都无法在规定时间内生成[1, R]中的所有质数。但是R - L的值很小，并且任何一个合数n必定包含一个不超过$\sqrt{n}$的质因子
• 所以，我们只需要用筛法求出2～$\sqrt{R}$之间的所有质数。对于每个质数p，把[L, R]中能被p整除的数标记，即标记i * p($\lceil \frac{L}{p}\rceil \le i\le \lfloor \frac{R}{p}\rfloor$)为合数
• 最终所有未被标记的数就是[L, R]中的质数。对相邻的质数两两比较，找出差最大的即可
• 时间复杂度为$O({\sum }_{质数p\le \sqrt{R}}\frac{R-L}{p})=O(\sqrt{R}loglog\sqrt{R}+(R-L)loglogR)$

#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long ll;
const int N = 1e6 + 10, M = 5e4 + 10;

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

void get_primes() {
    memset(st, 0, sizeof st);
    for (int i = 2; i < M; ++ i) {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] * i < M; ++ j) {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    long long l, r;
    while (cin >> l >> r) {
        cnt = 0;
        get_primes();
        memset(st, 0, sizeof st);
        for (int i = 0; i < cnt; ++ i) {
            int p = primes[i];
            for (long long j = max(2ll * p, (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 > 1) {
                primes[cnt ++ ] = l + i;
            }
        }
        if (cnt < 2) {
            puts("There are no adjacent primes.");
            continue;
        }
        int minp = -1, maxp = -1;
        for (int i = 0; i + 1 < cnt; ++ i) {
            int d = primes[i + 1] - primes[i];
            if (minp == -1 || primes[minp + 1] - primes[minp] > d) minp = i;
            if (maxp == -1 || primes[maxp + 1] - primes[maxp] < d) maxp = i;
        }
        printf("%d,%d are closest, %d,%d are most distant.\n", primes[minp], primes[minp + 1], primes[maxp], primes[maxp + 1]);
    }
}

AcWing 197. 阶乘分解

题意 ：

• 给定整数 N，试把阶乘 N! 分解质因数，按照算术基本定理的形式输出分解结果中的 pi 和 ci 即可。
• 3≤N≤10^6

思路 ：

• 若把1～N每个数分别分解质因数，再把结果合并，时间复杂度过高，为$O(N\sqrt{N})$。显然，N！的每个质因子都不会超过N，我们可以先筛选出1～N的每个质数p，然后考虑阶乘N！中一共包含多少个质因子p
• N！中质因子p的个数就等于1～N每个数包含质因子p的个数之和。在1～N中，p的倍数，即至少包含1个质因子p的显然有$\lceil N/p\rceil$个。而$p^2$的倍数，即至少包含2个质因子p的有$\lceil N/p^2\rceil$个。不过其中的1个质因子已经在$\lceil N/p\rceil$里统计过，所以只需要再统计第2个质因子，即累加上$\lceil N/p^2\rceil$，而不是$2\ast \lceil N/p^2\rceil$
• 综上所述，N！中质因子p的个数为：
  $\lfloor N/p\rfloor +\lfloor N/p^2\rfloor +\lfloor N/p^3\rfloor +...+\lfloor N/p^{\lfloor lo{g}_{p}N\rfloor }\rfloor ={\sum }_{p^k\le N}\lfloor N/p^k\rfloor$
• 对于每个p，只需要$O(logN)$的时间计算上述和式。故对整个N！分解质因数的时间复杂度为$O(NlogN)$

#include <iostream>
using namespace std;
const int N = 1e6 + 10;

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

void get_primes(int n) {
    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 n;
    scanf("%d", &n);
    get_primes(n);
    
    for (int i = 0; i < cnt; ++ i) {
        int p = primes[i];
        int s = 0;
        for (int j = p; j <= n; j *= p) {
            s += n / j;
            if (j > n / p) break; // j * p > n，下一次就大于n，s就加0了，因此直接break，这样写是防止j * p溢出
        }
        cout << p << ' ' << s << endl;
    }
}