开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第26天，点击查看活动详情

一、题目描述：

给你两个整数 left 和 right ，在闭区间 [left, right] 范围内，统计并返回计算置位位数为质数的整数个数。

计算置位位数就是二进制表示中 1 的个数。

例如， 21 的二进制表示 10101 有 3 个计算置位。

示例 1：

输入：left = 6, right = 10
输出：4
解释：
6 -> 110 (2 个计算置位，2 是质数)
7 -> 111 (3 个计算置位，3 是质数)
9 -> 1001 (2 个计算置位，2 是质数)
10-> 1010 (2 个计算置位，2 是质数)
共计 4 个计算置位为质数的数字。

示例 2：

输入：left = 10, right = 15
输出：5
解释：
10 -> 1010 (2 个计算置位, 2 是质数)
11 -> 1011 (3 个计算置位, 3 是质数)
12 -> 1100 (2 个计算置位, 2 是质数)
13 -> 1101 (3 个计算置位, 3 是质数)
14 -> 1110 (3 个计算置位, 3 是质数)
15 -> 1111 (4 个计算置位, 4 不是质数)
共计 5 个计算置位为质数的数字。

提示：

1 <= left <= right <= 10^6
0 <= right - left <= 10^4

二、思路分析：

用bitset可以把数据放在栈上，对cache更友好。

判断质数的时候有几个优化的点：

除2之外，其他质数都是奇数，所以非2的偶数都可以排除当需要判断的数值不太大时，可以把判断质数的结果缓存起来，vector< bool >内部已经做了位压缩，不会非常浪费内存。另外把从2开始已知的质数缓存起来也有用（见第3条）。检测一个数的因子，只需要从2开始检测到其平方根即可，严格大于其平方根的因子不用再做检测。而且在这个范围内，也只需要检测质数（质因子），而质数的分布是比较稀疏的，所以可以跳过很多因子判断。所以在需要判断的数不太大时，可以把质数缓存起来，有点类似动态规划的做法。

三、AC 代码：

class Solution {
public:
    int countPrimeSetBits(int L, int R) {
        const bitset< 21 > isprime( "010100010100010101100" );
        int result= 0;
        int last_count= 0;
        for( int value= L; value<=R; ++value ){
            int count= 0;
            if( value != L && value & 1 != 0 ){
                count= last_count + 1;
            }else{
                auto tmp= value;
                while( tmp != 0 ){
                    tmp &= tmp - 1;
                    ++count;
                }
            }
            if( isprime[ count ] ){
                ++result;
            }
            last_count= count;
        }
        return result;
    }
    
private:
    static bool is_prime( int num )
    {
        static vector< bool > num2isprime= {
            false,
            false,
            true,
            true,
            false,
            true,
            false,
            true,
            false,
            false,
            false,
            true,
            false,
            true,
            false,
            false,
            false,
            true,
            false,
            true,
            false,
        };
        static vector< int > prime_factors= {
            2,
            3,
            5,
            7,
            11,
            13,
            17,
            19,
        };
        if( num <= 1 ){
            return false;
        }else if( num == 2 ){
            return true;
        }else if( num & 1 == 0 ){
            return false;
        }
        if( num < num2isprime.size() ){
            return num2isprime[num];
        }
        num2isprime.reserve( 24 );
        prime_factors.reserve( 16 );
        for( int i= num2isprime.size(); i<=num; ++i ){
            auto i_is_prime= true;
            for( auto prime_factor : prime_factors ){
                if( prime_factor*prime_factor > i ){
                    break;
                }
                if( i % prime_factor == 0 ){
                    i_is_prime= false;
                    break;
                }
            }
            num2isprime.emplace_back( i_is_prime );
            if( i_is_prime ){
                prime_factors.emplace_back( i );
            }
        }
        return num2isprime[num];
    }
    
};

leetcode算法762. 二进制表示中质数个计算置位

一、题目描述：

二、思路分析：

三、AC 代码：