LeetCode（python）204. 计数质数

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

输入：n = 0
输出：0
示例 3：

输入：n = 1
输出：0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-primes

自己的做法没有通过，对照了官方的代码，想不通为啥自己代码会超时，自己的解法和官方的枚举法感觉一样，但是通过不了，可能毕竟是暴力解法

class Solution {
    public int countPrimes(int n) {
        if(n < 3){
            //0,1,2
            return 0;
        }
        int num = 1;//至少包含2这个质数
        int flag = 0;
        for(int i = 3; i < n; i = i + 2){
            flag = 0;
            for(int j = 2; j*j <= i; j++){
                if(i % j == 0){
                    flag = 1;
                    break;
                }
            }
            if(flag != 1){
                //System.out.print(i);
                num++;
            }
        }
        return num;
    }
}

官方方法一：枚举法 $$时：O(n\ast n^{1/2})；空：O(1)$$

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;
    }
}
//这里一开始想用sqrt(n)来开方，
//不过不借助函数，使用i*i<=n也可以达到同样的目的，能自己解决还是不要麻烦别人

官方方法二：埃氏法 $$时：O(n\ast loglogn)；空：O(n)$$
如果x是质数，那么2x,3x,4x…都是合数，即大于x的x的倍数都是合数
在进行标记时，应该从x*x开始标记，因为2x,3x,4x…都被比x小的数标记了，他们被2的倍数，3的倍数等等已经标记了

class Solution {
    public int countPrimes(int n) {
        if(n < 3) {
            return 0;//自己加的，这个if可以不要
        }
        int [] isPrime = new int[n];//Java定义数组
        Arrays.fill(isPrime, 1);//初始化数组，都为1
        int res = 0;
        for(int i = 2; i < n; i++){
            if(isPrime[i] == 1){
                res++;//isPrime[i] == 1说明为质数
                if((long)i*i < n){//先判断一次，以防数太大
                    for(int j = i * i; j < n;j = j + i) {
                        //从i*i开始进行标注
                        isPrime[j] = 0;
                    }
                }

            }
        }
        return res;
    }
}

官方方法二：线性法$$时：O(n)；空：O(n)$$
比埃氏法多了一个存储质数的数组primes，对于primes里面的每个元素的倍数都是合数。
标记时对于x,不管x是否是质数，x*primes[i]一定是合数，且在x mod primes[i] == 0 时结束，这样可以保证每个合数被他【最小质因数】标记，即每个数只被标记一次。
详解见官方 https://leetcode-cn.com/problems/count-primes/solution/ji-shu-zhi-shu-by-leetcode-solution/

class Solution {
    public int countPrimes(int n) {
        List<Integer> primes = new ArrayList<Integer>();
        //创建链表来存储质数数组，可动态添加
        int[] isPrime = new int[n];//创建数组
        Arrays.fill(isPrime, 1);//初始化数组，都为1
        for (int i = 2; i < n; ++i) {
            if (isPrime[i] == 1) {
                primes.add(i);//.add()；添加元素i
            }
            //这里的条件有j<primes.size(),链表的大小；同时i * primes.get(j) < n
            for (int j = 0; j < primes.size() && i * primes.get(j) < n; ++j) {
                isPrime[i * primes.get(j)] = 0;//primes.get(j)获取第j个元素
                if (i % primes.get(j) == 0) {
                    break;
                }
            }
        }
        return primes.size();//primes.size()，链表的大小
    }
}