线性筛质数最快（没有之一）

筛选质数：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 10000010;

int primes[N],cnt;
bool st[N];

void get_primes(int n)
{
   
    for(int i=2;i<=n;i++)
    {
        if(!st[i])
        primes[cnt++]=i;
        for(int j=0;primes[j]*i<=n;j++)
        {
            st[primes[j]*i]=true;
            if(i%primes[j]==0) break;
        }
    }
}

int main()
{
    int n;
    cin >> n;
    get_primes(n);
    cout << cnt<< endl;
    return 0;
}

非素数个数： 

---

#include <iostream> 

using namespace std; 

const int N = 1e7+10; // 定义常量 N，表示最大范围

bool st[N]; // st 数组用于标记是否为素数
int primes[N], cnt, s[N]; // primes 数组存储素数，cnt 表示素数个数，s 数组用于存储前缀和

// 函数：获取小于等于 n 的所有素数
void get_primes(int n)
{
    // 遍历范围 [2, n] 内的所有数
    for(int i = 2; i <= n; i++)
    {
        // 如果当前数不是合数（即素数），将其加入 primes 数组，并增加素数计数 cnt
        if(!st[i])
            primes[cnt++] = i;
        
        // 再次遍历已知素数 primes[j] 与当前数 i 的乘积
        for(int j = 0; primes[j] * i <= n; j++)
        {
            // 将当前数的倍数标记为合数
            st[primes[j] * i] = true;
            
            // 如果当前数能整除 primes[j]，说明它是合数，跳出内层循环
            if(i % primes[j] == 0)
                break;
        }
    }
    
    // 计算前缀和数组 s
    for(int i = 2; i <= n; i++)
    {
        // s[i] 表示小于等于 i 的素数个数
        s[i] = s[i-1];
        // 如果当前数是合数，则前缀和加 1
        if(st[i])
            s[i]++;
    }
}

int main()
{
    // 调用函数获取素数列表
    get_primes(N-1);
    int a, b;
    // 不断读取输入，直到文件结束
    while(cin >> a >> b)
    {
        // 输出区间 [a, b] 内的素数个数（利用前缀和数组计算）
        cout << s[b] - s[a-1] << endl;
    }
    return 0;
}

详细解释bool数组：

在以上代码中，bool数组st[N]用于标记某个数是否为合数（非素数）。以下是bool数组st内元素值的变化过程：

1. 初始状态：数组st中的所有元素均为false，表示所有数都是素数。

2. 在get_primes函数中，通过遍历范围[2, n]内的所有数，标记合数的过程如下：

   • 当i为素数时，将st[i]标记为false，表示i为素数。
   • 当i为合数时，将st[i]标记为true，表示i为合数。

3. 通过遍历已知素数primes[j]与当前数i的乘积来标记合数：

   • 如果primes[j]能整除i（即i是primes[j]的倍数），则将st[i]标记为true，表示i为合数。
   • 同时，通过i%primes[j]==0来判断i是否为合数，如果是，则跳出内层循环。

4. 最终，经过遍历范围[2, n]内的所有数，bool数组st[N]中的元素就会根据数的素数性质被标记为true（合数）或false（素数），用来在后续计算中确定素数的个数和范围。

拓展： 

#include <iostream>

using namespace std;
const int N = 1e7+10;
bool st[N];
int primes[N],cnt;

// void get_primes(int n)
// {
//     for(int i=2;i<=n;i++)
//     {
//         if(!st[i])primes[cnt++]=i;
//         for(int j=0;primes[j]*i<=n;j++)
//         {
//             st[primes[j]*i]=true;
//             if(i%primes[j]==0)
//             break;
//         }
//     }
// }

bool isPrime(int n) {
    if (n <2) {
        return false;
    }
    for (int i = 2; i  <= n/i; i++) {   
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int main()
{
    int n;
   while( cin >> n){
      int cnt=0;
    for(int i=1;i<n;i=(i/10+1)*10+1)
    {
        if(isPrime(i))
        {
          cnt++;
        cout << i << " ";
    }
    }
    
    if(!cnt)
        cout << -1;
    cout << endl;
   }
    return 0;
}