埃氏筛算法优化与区间非素数统计实践

1. 题目解析与算法设计

这道题目要求我们计算给定区间[a,b]内非素数的个数。题目有两个特殊要求需要注意：

1. 将1视为素数处理（这与数学定义不同）
2. 数据规模可能很大（b≤10^7）

1.1 素数判断的常规方法

对于素数判断，初学者可能会想到对每个数进行试除法：

cpp复制bool isPrime(int n) {
    if(n == 1) return true; // 题目特殊要求
    for(int i=2; i*i<=n; i++) {
        if(n%i == 0) return false;
    }
    return true;
}

但这种方法的复杂度是O(n√n)，当n=10^7时，计算量将达到10^10级别，显然无法在1秒内完成（计算机通常每秒处理10^8次运算）。

1.2 埃拉托斯特尼筛法优化

更高效的解决方案是使用埃拉托斯特尼筛法（埃氏筛）。其核心思想是：

1. 初始化一个标记数组，假设所有数都是素数
2. 从2开始，将每个素数的倍数标记为非素数
3. 最后统计未被标记的数字即为素数

对于本题的特殊要求（1视为素数），只需在初始化时单独处理即可。

2. 算法实现细节

2.1 预处理阶段设计

观察题目要求的多组查询特性，我们应采用预处理+前缀和的方案：

cpp复制const int MAX = 10000005;
int isComposite[MAX] = {0}; // 0表示素数，1表示合数
int prefixSum[MAX] = {0};   // 前缀和数组

预处理分为两个步骤：

1. 筛法标记合数
2. 计算前缀和数组

2.2 筛法实现要点

cpp复制void sieve() {
    isComposite[0] = isComposite[1] = 0; // 题目要求1视为素数
    for(int i=2; i*i<MAX; i++) {
        if(!isComposite[i]) {
            for(int j=i*i; j<MAX; j+=i) {
                isComposite[j] = 1;
            }
        }
    }
}

这里有几个优化点：

• 外层循环只需到√MAX
• 内层循环从i²开始（因为i*(i-1)等已被更小的素数标记过）
• 使用i*i避免浮点运算

2.3 前缀和数组构建

为了快速查询任意区间[a,b]的非素数个数，我们需要预处理前缀和：

cpp复制void buildPrefix() {
    for(int i=1; i<MAX; i++) {
        prefixSum[i] = prefixSum[i-1] + isComposite[i];
    }
}

这样，查询[a,b]区间的非素数个数只需计算：
prefixSum[b] - prefixSum[a-1]

3. 完整代码实现

结合上述思路，完整代码如下：

cpp复制#include<bits/stdc++.h>
using namespace std;

const int MAX = 10000005;
int isComposite[MAX] = {0};
int prefixSum[MAX] = {0};

void init() {
    // 题目特殊要求：1视为素数
    isComposite[0] = isComposite[1] = 0;
    
    // 埃氏筛
    for(int i=2; i*i<MAX; i++) {
        if(!isComposite[i]) {
            for(int j=i*i; j<MAX; j+=i) {
                isComposite[j] = 1;
            }
        }
    }
    
    // 构建前缀和
    for(int i=1; i<MAX; i++) {
        prefixSum[i] = prefixSum[i-1] + isComposite[i];
    }
}

int main() {
    init(); // 预处理
    
    int a, b;
    while(cin >> a >> b) {
        cout << prefixSum[b] - prefixSum[a-1] << endl;
    }
    return 0;
}

4. 算法分析与优化

4.1 时间复杂度分析

• 预处理阶段：
  • 筛法：O(n log log n)
  • 前缀和：O(n)
• 查询阶段：O(1) per query

对于n=10^7，筛法大约需要1.5×10^8次操作，在现代计算机上可在1秒内完成。

4.2 空间复杂度优化

原始实现使用了两个数组（isComposite和prefixSum），可以进一步优化：

cpp复制int prefixSum[MAX] = {0};

void init() {
    // 直接在prefixSum上操作
    for(int i=2; i*i<MAX; i++) {
        if(prefixSum[i] == 0) {
            for(int j=i*i; j<MAX; j+=i) {
                prefixSum[j] = 1;
            }
        }
    }
    
    // 重新计算前缀和
    for(int i=1; i<MAX; i++) {
        prefixSum[i] += prefixSum[i-1];
    }
}

这样节省了一个数组的空间，但会略微降低代码可读性。

4.3 欧拉筛法对比

埃氏筛的一个缺点是会重复标记某些合数（如6会被2和3都标记）。更高效的线性筛（欧拉筛）可以避免这个问题：

cpp复制void eulerSieve() {
    vector<int> primes;
    for(int i=2; i<MAX; i++) {
        if(prefixSum[i] == 0) {
            primes.push_back(i);
        }
        for(int p : primes) {
            if(i*p >= MAX) break;
            prefixSum[i*p] = 1;
            if(i%p == 0) break;
        }
    }
}

虽然欧拉筛时间复杂度更低（O(n)），但实际运行速度可能不如优化后的埃氏筛，因为其常数因子较大。

5. 常见问题与调试技巧

5.1 内存限制问题

当MAX=10^7时：

• 两个int数组需要约80MB内存（题目限制256MB）
• 如果出现MLE，可以尝试：
  • 使用bitset压缩空间（8倍节省）
  • 分块处理数据

5.2 边界条件处理

特别注意以下边界情况：

1. a=1时的处理（题目要求1视为素数）
2. a=b时的正确性
3. 最大数据规模测试（a=1, b=10^7）

5.3 输入输出优化

对于C++，当输入规模很大时：

cpp复制ios::sync_with_stdio(false);
cin.tie(0);

可以显著加快IO速度。但注意此时不能与scanf/printf混用。

6. 实际测试与性能对比

我在本地进行了三种实现的性能测试（n=10^7，10组随机查询）：

测试结果表明，优化后的埃氏筛在本题场景下综合表现最佳。

7. 算法扩展与应用

这种预处理+前缀和的思路可以应用于许多区间统计问题：

1. 区间质数个数（本题的反向问题）
2. 区间内满足特定条件的数字个数（如含某个数字的数）
3. 区间最大/最小质因数统计

关键思想是将O(n)的查询转化为O(1)的前缀和差分。

8. 个人实现心得

在实际编码中，我遇到了几个值得注意的问题：

1. 数组初始化：全局数组会自动初始化为0，但局部大数组不会，这可能导致WA
2. i*i溢出：当MAX接近INT_MAX时，i*i可能溢出，应使用long long或调整循环条件
3. 输入终止：在线判题系统通常以EOF结束，while(cin>>a>>b)是最安全的写法

一个实用的调试技巧是先用小数据测试：

cpp复制assert(prefixSum[10] - prefixSum[0] == 5); // 验证样例1

最后，对于算法竞赛，我建议：

• 熟练掌握埃氏筛的写法
• 理解前缀和思想的广泛应用
• 注意题目中的特殊约定（如本题的1视为素数）