【Leetcode】204. Count Primes

题目地址：

https://leetcode.com/problems/count-primes/

给定$n$非负，问小于$n$的素数个数。

法1：埃拉托斯特尼筛法（Sieve of Eratosthenes）。开一个长度为$n$的boolean数组记录每个数是否是素数。首先全填充为true，将$0$和$1$置为false。接着开始找第一个是true的数，是$2$，接着把$2$的比自己大的倍数全标记为false；接着再向后找是true的数，然后重复上面的操作。这样小于$n$的所有非素数就全被标记为false了，剩下的就是素数。最后数一下即可。代码如下：

import java.util.Arrays;

public class Solution {
    public int countPrimes(int n) {
        if (n <= 2) {
            return 0;
        }
        
        boolean[] isPrime = new boolean[n];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        
        for (int i = 2; i <= Math.sqrt(n - 1); i++) {
        	// 遇到素数就筛掉它的比它大的倍数
            if (isPrime[i]) {
                for (int j = 2; i * j < n; j++) {
                    isPrime[i * j] = false;
                }
            }
        }
        
        // 最后数一下还有哪些数没被筛掉
        int res = 0;
        for (boolean p : isPrime) {
            if (p) {
                res++;
            }
        }
        
        return res;
    }
}

时间复杂度$O(n\log \log n)$，空间$O(n)$。

时间复杂度证明依赖于一个式子：$$\sum _{p<n}\frac{1}{p}=\log \log n$$有了这个式子，时间复杂度是显然的。

法2：欧拉筛。这种筛法时间复杂度是线性的，优于埃拉托斯特尼筛法。它的主要改进在于，让每个合数被筛的时候，只被它的最小素因子筛。这样就能保证每个合数只会被筛一次，而不像埃氏筛法，同一个数可能被多次筛。代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public int countPrimes(int n) {
        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);
        // 要把素数存下来
        List<Integer> primes = new ArrayList<>();
    
        for (int i = 2; i < n; i++) {
            if (isPrime[i]) {
                primes.add(i);
            }
            
            for (int j = 0; i * primes.get(j) < n; j++) {
                isPrime[i * primes.get(j)] = false;
                if (i % primes.get(j) == 0) {
                    break;
                }
            }
        }
        
        return primes.size();
    }
}

时空复杂度$O(n)$。

算法正确性证明：
假设有个合数$N$，其最小素因子是$p$，那么由于$p$是素数，所以当外层循环的$i$取$p$的时候，isPrime[i * primes.get(j)] = false;这句话在之前的所有循环中都没把$p$给筛掉，所以一进循环的时候$p$就被加入了primes的列表中。接下来循环进行到$i=\frac{N}{p}\ge p$的时候，由于$i$的最小素因子不会小于$p$，所以不会提前break出来，因此$N$会被筛掉。

算法时间复杂度证明：
只需证明每个合数$N$只会被筛一遍，也就是$i=\frac{N}{p}$的那一遍。首先，在isPrime[i * primes.get(j)] = false;的时候，$p_j$一定小于等于$i$的所有素因子，否则就会被提前break出去。而这种情况下，$p_j$也是$i{p}_j$的最小素因子，也就是说，当$N$被筛的时候，一定有$p_j=p$，所以也一定有$i=\frac{N}{p}$，而$i$取$\frac{N}{p}$并且$p_j$取$p$两者一起只会发生一次，所以$N$也只会被筛一次。

C++：

class Solution {
 public:
  int countPrimes(int n) {
    if (!n) return 0;
    bool st[n];
    memset(st, 0, sizeof st);
    int p[n], idx = 0;
    for (int i = 2; i < n; i++) {
      if (!st[i]) p[idx++] = i;
      for (int j = 0; p[j] * i < n; j++) {
        st[p[j] * i] = true;
        if (i % p[j] == 0) break;
      }
    }

    return idx;
  }
};

时空复杂度$O(n)$。