如何求出在区间 $\mathrm{[L, R]}$ 中最小的 $p$ 的倍数

1. $\lceil \frac{L}{p} \rceil \times p \quad \Rightarrow \quad$ ceil((double)L / p) * p

2. $\lfloor \frac{L + p - 1}{p} \rfloor \times p \quad \Rightarrow \quad$ (L + p - 1) / p * p

如何筛出在区间 $\mathrm{[L, R]}$ 中的所有素数（$0 \le L,R \le 10^9$，$0 \le R - L \le 10^6$）

数据范围在 $10^8$ 之上，因此不能直接使用筛素数的方法。

观察到区间长度在 $10^6$ ，这是一大突破口。

如果单纯使用试除法筛出 $\mathrm{[L, R]}$，时间复杂度为 $\mathrm{O(n\log \sqrt{m})} \approx 10^{10}$
(其中n为区间长度${10^6}$，m为数字大小${10^9}$)

因此我们需要深入分析:

考虑对于任意一个合数 $x$，他必定存在一个最小的质因子 $d$，且这个最小的质因子 $d \le \sqrt{x}$。

那么我们去筛区间 $\mathrm{[L, R]}$ 的素数时候，可以把该区间所有的合数用他们的最小质因子筛掉。

对于该范围内任意一个合数的质因子 $x$，有 $0\le x \le \sqrt{10^9} \approx 10^5$

因此我们的思路就是：

1. 先把 $[1, 10^5]$ 内所有的素数筛出

2. 对于任意 $d \in \mathrm{[1, 10^5]}$，我们把 $\mathrm{[L, R]}$ 内所有以 $d$ 作为最小质因子的合数用 $d$ 筛掉

如此一来，对于任意 $n \in \mathrm{[L, R]}$，如果 $n$ 是合数，则他必定会被 $n$ 的最小质因子 $d$ 筛掉
该算法是合理的。

Code

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

typedef long long LL;

//sqrt(2^31 - 1)
const int N = 1e6 + 10;

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

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

int main() {
    int l, r;
    while (~scanf("%d%d", &l, &r)) {
        get_primes(50000);

        //把[l,r]区间内所有的合数用他们的最小质因子筛掉
        memset(st, 0, sizeof st);
        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;
        }

        //剩下的所有的都是素数了
        cnt = 0;
        for (int i = 0; i <= r - l; ++ i)
            if (!st[i] && i + l > 1)
                primes[cnt ++ ] = i + l;

        if (cnt < 2) printf("There are no adjacent primes.\n");
        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;
}