204. 计数质数

题目

统计所有小于非负整数 n 的质数的数量。

示例 1：

输入：n = 10
输出：4
解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

示例 2：

输入：n = 0
输出：0

示例 3：

输入：n = 1
输出：0

官方题解

方法一：枚举

很直观的思路是我们枚举每个数判断其是不是质数。

考虑质数的定义：在大于 11 的自然数中，除了 11 和它本身以外不再有其他因数的自然数。因此对于每个数 x，我们可以从小到大枚举 [2,x-1] 中的每个数 y，判断 yy 是否为 x 的因数。但这样判断一个数是否为质数的时间复杂度最差情况下会到 O(n)，无法通过所有测试数据。

class Solution {
    public int countPrimes(int n) {
        int ans = 0;
        for (int i = 2; i < n; ++i) {
            ans += isPrime(i) ? 1 : 0;
        }
        return ans;
    }

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

复杂度分析

• 时间复杂度：O(n√n)。单个数检查的时间复杂度为 O(√n)，一共要检查 O(n) 个数，因此总时间复杂度为 O(n√n)。

• 空间复杂度：O(1)。

我傻了，这也太慢了吧

方法二：埃氏筛

枚举没有考虑到数与数的关联性，因此难以再继续优化时间复杂度。接下来我们介绍一个常见的算法，该算法由希腊数学家厄拉多塞（\rm EratosthenesEratosthenes）提出，称为厄拉多塞筛法，简称埃氏筛。

class Solution {
    public int countPrimes(int n) {
        int[] isPrime = new int[n];
        Arrays.fill(isPrime, 1);
        int ans = 0;
        for (int i = 2; i < n; ++i) {
            if (isPrime[i] == 1) {
                ans += 1;
                if ((long) i * i < n) {
                    for (int j = i * i; j < n; j += i) {
                        isPrime[j] = 0;
                    }
                }
            }
        }
        return ans;
    }
}

复杂度分析

• 时间复杂度：O(nloglogn)。
• 空间复杂度：O(n)。

方法三：线性筛

此方法不属于面试范围范畴。

class Solution {
    public int countPrimes(int n) {
        List<Integer> primes = new ArrayList<Integer>();
        int[] isPrime = new int[n];
        Arrays.fill(isPrime, 1);
        for (int i = 2; i < n; ++i) {
            if (isPrime[i] == 1) {
                primes.add(i);
            }
            for (int j = 0; j < primes.size() && i * primes.get(j) < n; ++j) {
                isPrime[i * primes.get(j)] = 0;
                if (i % primes.get(j) == 0) {
                    break;
                }
            }
        }
        return primes.size();
    }
}

复杂度分析

• 时间复杂度：O(n)。
• 空间复杂度：O(n)。

关于埃氏筛法详解

一个判断素数的高效算法

https://blog.csdn.net/luoyangIT/article/details/102565413

大佬解法

https://leetcode-cn.com/problems/count-primes/solution/javadai-ma-liang-chong-jie-jue-fang-shi-by-sdwwld/

1，暴力求解

最简单的一种方式就是暴力求解，一个个判断

    public int countPrimes(int n) {
        if (n < 3)
            return 0;
        int count = 1;
        //i+=2是要过滤掉偶数
        for (int i = 3; i < n; i += 2) {
            count += isPrimes(i) ? 1 : 0;
        }
        return count;
    }

    //判断是否是素数
    private boolean isPrimes(int i) {
        int sqrt = (int) Math.sqrt(i);
        //一个素数永远都不可能被偶数整除，所以这里是j+=2
        for (int j = 3; j <= sqrt; j += 2) {
            if (i % j == 0)
                return false;
        }
        return true;
    }

也是类似枚举，不过优化了好多

2，非暴力求解

任何合数都可以分解成m个素数的乘积，我们反过来想，任何一个素数比如a，他的n（n>=2）倍一定不是素数，也就是a2，a3……都不在是素数。我们可以申请一个长度为length的数组用来存储对应的数是不是素数。然后在用一个变量count来统计素数的个数，如果是合数就不需要统计，如果是素数，count就加1，然后再把素数的2倍，3倍……都标记为非素数，看下代码

    public int countPrimes(int n) {
        boolean[] notPrimes = new boolean[n];
        int count = 0;
        for (int i = 2; i < n; i++) {
            //如果是合数就不需要统计
            if (notPrimes[i])
                continue;
            count++;
            //到这一步说明不是素数，直接让他的2倍，3倍……都标记为非负数即可
            for (int j = i; j < n; j += i)
                notPrimes[j] = true;
        }
        return count;
    }

厉害