质数打表的四种方式

---

不多聊，开始。

---

朴素打表

---

  一种朴素的想法，就是把每个数对它可能的因数取余，判断是否不存在能将其分解的数，并将其记录在表中。

    public boolean[] makeCharts(int n) {
    
    
        boolean[] charts = new boolean[n + 1];
        for (int i = 2; i <= n; i++) {
    
    
            boolean flag = false;
            for (int k = 2; k * k <= i; k++)
                if (flag = i % k == 0)
                    break;
            charts[i] = !flag;
        }
        return charts;
    }

  这里解释一下k * k <= i这个点。

  如果存在大于 $\sqrt{i}$ 的数 $k_1$ 能作为 $i$ 的因数，这里写作 $i÷k_1=k_2$，即 $k_1{k}_2=i$，我们将两遍同时除以一个 $\sqrt{i}$，得 $\frac{k_1}{\sqrt{i}}{k}_2=\sqrt{i}$，由于 $k_1>\sqrt{i}$，所以 $\frac{k_1}{\sqrt{i}}>1$，故 $k_2<\sqrt{i}$，所以与 $k_2$ 在顺序枚举时，会在 $\sqrt{i}$ 之前出现，因此这种写法的正确性有了保障。

  整个算法的时间复杂度为 $O(\sqrt{n^3})$。

---

朴素改进

---

  把这里做的改进单独列为一种的原因是，

  我们打出一个质数表，场景通常是高频的判断，或者使用，使用布尔数组为区间内的质数打上标记固然使得判断速度大幅提升，但同时我们要使用一个范围内的质数时，似乎没有什么高效的方式可以实现。

  在高频使用的场景，我们可以对朴素打表的方法做出一点小小的更改，把打上标记这一操作更变为将质数加入一个序列，但这里要给出的不是这种简单的变更，而是基于操作变更后的一定小改进。

    public List<Integer> makeCharts(int n) {
    
    
        List<Integer> charts = new ArrayList();
        if (n >= 2) charts.add(2);
        for (int i = 3; i <= n; i++) {
    
    
            boolean flag = false;
            for (int k : charts)
                if (k * k > i || (flag = i % k == 0)) break;
            if (!flag) charts.add(i);
        }
        return charts;
    }

  在朴素打表中，我们知道只需要枚举 $\sqrt{i}$ 内的所有正整数，就能判断一个数是否为质数，而基本算术定理又能告诉我们，每个大于 $1$ 的自然数都能分解成若干质数的幂的乘积，而在整个打表过程中，我们又能快速的遍历小于 $i$ 的质数的集合，总和起来就是这个改进的全貌。

  这里使用 $\frac{n}{\ln n}$ 近似质数分布，该算法时间复杂度为 $O(\frac{\sqrt{n^3}}{\log \sqrt{n}})$。

---

Eratosthenes 筛法

---

  又称埃氏筛、爱氏筛、质数筛、普通筛法，是较为简单的质数筛法之一。

  一个大于 $1$ 的自然数要么是质数，要么是合数，如果我们将 $n$ 以内的自然数集中，所有小于$\sqrt{n}$ 的质数的倍数全部筛选出来，剩下数的数集就是我们要的质数表。

    public boolean[] makeCharts(int n) {
    
    
        boolean[] charts = new boolean[n + 1];
        for (int i = 2; i <= n; i++)
            charts[i] = true;
        for (int i = 2; i <= n; i++)
            if (charts[i])
                for (int k = i << 1; k <= n; k += i)
                    charts[k] = false;
        return charts;
    }

  复杂度可以简单的考虑如下：

  内层循环执行 $\frac{n}{p}-1$，$p$ 为质数。

  时间复杂度为 $O(\sum _{p\le \sqrt{n}}\frac{n}{p}-1)$，即 $O(n\sum _{p\le \sqrt{n}}\frac{1}{p}-\frac{1}{n})$。

  为了方便计算，引入质数分布定理，$\pi (x)$ 为小于 $x$ 的质数个数，$\pi (x)\approx \frac{x}{\ln x}$，第 $i$ 个质数约为 $i\ln i$。

  $原式=O(nI)$，$I=\frac{1}{2}+\sum _{i=2}^{\frac{n}{\ln n}}(\frac{1}{i\ln i}-\frac{1}{n})$，这里把第一个质数拿了出来。

  积分估计一下 $I$ 的值，$f(x)=\frac{1}{x\ln x}$，求${\int }_2^{\frac{n}{\ln n}}f(i)di-{\int }_2^{\frac{n}{\ln n}}\frac{1}{n}+\frac{1}{2}$

  上牛茨公式，$F(x)=\ln \ln x$，$I=F(\frac{n}{\ln n})-F(2)-{\int }_2^{\frac{n}{\ln n}}\frac{1}{n}+\frac{1}{2}=\ln \ln n-\ln \ln \ln n-\ln \ln 2-\frac{n-2\ln n}{n\ln n}+\frac{1}{2}$

  综上，埃氏筛时间复杂度为 $O(n\log \log n)$。

---

欧拉筛法

---

  同样是筛出合数，欧拉筛法的策略相较于埃氏筛有很大不同。

  当遍历到任意数 $n_i$ 时，我们将所有 $p_j{n}_i$，$p_j\in primes$ 筛掉，

  首先要讨论的是这一步的完全性，对于将要访问的合数 $n_k$，我们可以将其表示为 $p_j{m}_k$，其中 $p_j$ 为 $n_k$ 的最小质因数，这是因为，对于一个合数，我们总是能表示成一个最小因数和另一个数的乘积，而最小因数总是一个质数。

  因此 $p_j\le m_k$，而我们在遍历到 $m_k$ 时，$p_j$ 已经加入了 $primes$ 集合，故这种策略是完全的。

  其次要讨论的是在 $n_i\mathrm{m}\mathrm{o}\mathrm{d}{p}_j=0$ 时不再继续筛选的正确性，当 $n_i$ 是 $p_j$ 的整数倍时，我们记 $m_i$ 为 $m_i=n_i÷p_j$，对于新的合数 $n_k$ 我们可以记为 $n_k=n_i\times p_{j+1}=m_i\times p_j\times p_{j+1}$，这说明 $n_i\times p_{j+1}$ 是 $p_j$ 的整数倍，现在不继续筛选，遍历到 $n_k$ 前也会被 $m_i\times p_{j+1}$ 继续筛选。

    public List<Integer> makeCharts(int n) {
    
    
        List<Integer> charts = new ArrayList();
        boolean[] marked = new boolean[n + 1];
        for (int i = 2; i <= n; i++) {
    
    
            if (!marked[i]) charts.add(i);
            for (int p : charts) {
    
    
                if (i * p > n) break;
                marked[i * p] = true;
                if (i % p == 0)break;
            }
        }
        return charts;
    }

每个合数只被筛选一次，故算法时间复杂度为 $O(n)$。

也因此，欧拉筛也被称为线性筛。