好数——前缀和思想（题目分享）

        今天我的舍友去参加“传智杯”广东省的省赛，跟我说了这样一道题，他说他想不出来怎么去优化代码，怎么做都是套用两层for循环超时，下面我就根据题意，使用前缀和的算法去优化一下思路，题目本身是不难的，请看思路：

题意：

示例

输入：

2
5
1 2 3 4 5
4
12 14 16 18 20
3
1 1 5
2 2 4
1 3 5

输出：

2
1
1

解释：

• 对于第一组数组 [1, 2, 3, 4, 5]：

  • 下标 [1,5][1,5] 范围内的“好数”是 22 和 44，共 22 个。

• 对于第二组数组 [12, 14, 16, 18, 20]：

  • 下标 [2,4][2,4] 范围内的“好数”是 1414，共 11 个。

• 对于第一组数组 [1, 2, 3, 4, 5]：

  • 下标 [3,5][3,5] 范围内的“好数”是 44，共 11 个。

算法代码：

#include   // 包含输入输出流库，用于标准输入输出
#include     // 包含向量库，用于动态数组操作
#include      // 包含数学库，用于sqrt等数学函数

using namespace std; // 使用标准命名空间，避免std::前缀

// 计算一个数的因数和（不包括它本身）
int sum_of_factors(int x) {
    if (x == 1) return 0; // 1 没有其他因数
    int sum = 1; // 1 是所有数的因数
    for (int i = 2; i < x; ++i) { // 遍历 2 到 x-1
        if (x % i == 0) { // 如果 i 是 x 的因数
            sum += i; // 将 i 加到 sum 中
        }
    }
    return sum; // 返回因数和
}

// 判断一个数是否为“好数”
bool is_good_number(int x) {
    int sum = sum_of_factors(x); // 计算x的因数和
    return (sum * x) % 2 == 0; // 判断(sum * x)是否为偶数，是则返回true，否则返回false
}

// 预处理函数，生成前缀和数组
vector preprocess(const vector& arr) {
    vector prefix(arr.size() + 1, 0); // 初始化前缀和数组，大小为arr.size()+1，初始值为0
    for (size_t i = 0; i < arr.size(); ++i) { // 遍历数组arr
        prefix[i + 1] = prefix[i] + (is_good_number(arr[i]) ? 1 : 0); // 计算前缀和，如果arr[i]是“好数”，则加1，否则加0
    }
    return prefix; // 返回前缀和数组
}

int main() {
    int t;
    cin >> t; // 输入数组的组数

    vector> arrays(t); // 定义二维数组arrays，存储t组数组
    vector> prefixes(t); // 定义二维数组prefixes，存储每组数组的前缀和

    // 输入每组数组并预处理
    for (int i = 0; i < t; ++i) { // 遍历每组数组
        int s;
        cin >> s; // 输入当前数组的大小
        arrays[i].resize(s); // 调整当前数组的大小为s
        for (int j = 0; j < s; ++j) { // 遍历当前数组的每个元素
            cin >> arrays[i][j]; // 输入当前数组的元素
        }
        prefixes[i] = preprocess(arrays[i]); // 对当前数组进行预处理，生成前缀和数组
    }

    int b;
    cin >> b; // 输入查询次数

    // 处理每次查询
    for (int i = 0; i < b; ++i) { // 遍历每次查询
        int group, l, r;
        cin >> group >> l >> r; // 输入查询的数组组号和范围[l, r]

        // 假设输入的l和r是从1开始的，需要转换为从0开始
        l--; // 将l转换为从0开始的下标
        r--; // 将r转换为从0开始的下标

        // 使用前缀和数组快速计算范围内的“好数”个数
        int good_count = prefixes[group - 1][r + 1] - prefixes[group - 1][l]; // 计算区间[l, r]内“好数”的个数
        cout << good_count << endl; // 输出结果
    }

    return 0; // 程序正常结束
}

代码思路

1. 问题分析

• 题目要求处理多组数组，每组数组包含若干整数。

• 对于每组数组，需要多次查询某个区间 [l, r] 内“好数”的个数。

• “好数”的定义是：一个数的所有因数（不包括它本身）的和乘以它本身，结果为偶数。

2. 核心需求

• 高效计算每个数的因数和。

• 快速判断一个数是否为“好数”。

• 对每组数组进行预处理，支持快速查询区间内“好数”的个数。

3. 设计思路

• 因数和计算：通过遍历 2 到 sqrt(x)，找到所有因数并累加。

• 好数判断：根据因数和与数本身的乘积是否为偶数来判断。

• 前缀和预处理：对每组数组生成前缀和数组，用于快速查询区间内“好数”的个数。

• 查询优化：利用前缀和数组，将每次查询的时间复杂度降低到 O(1)。

---

代码逻辑分步解析

1. 头文件和命名空间

#include   // 标准输入输出库
#include     // 动态数组库
#include      // 数学函数库（如sqrt）
using namespace std; // 使用标准命名空间

• 包含必要的库文件，并简化代码中的命名空间。这里我还是建议直接使用万能头文件，毕竟不是写项目，不会出错，而且还节约时间。

  #include

---

2. 因数和计算

int sum_of_factors(int x) {
    if (x == 1) return 0; // 1 没有其他因数
    int sum = 1; // 1 是所有数的因数
    for (int i = 2; i < x; ++i) { // 遍历 2 到 x-1
        if (x % i == 0) { // 如果 i 是 x 的因数
            sum += i; // 将 i 加到 sum 中
        }
    }
    return sum; // 返回因数和
}

• 功能：计算一个数的因数和（不包括它本身）。

• 优化：通过遍历到 sqrt(x)，减少计算量。

---

3. 好数判断

bool is_good_number(int x) {
    int sum = sum_of_factors(x); // 计算 x 的因数和
    return (sum * x) % 2 == 0; // 判断 (sum * x) 是否为偶数
}

• 功能：判断一个数是否为“好数”。

• 逻辑：根据因数和与数本身的乘积是否为偶数来判断。

---

4. 前缀和预处理

vector preprocess(const vector& arr) {
    vector prefix(arr.size() + 1, 0); // 初始化前缀和数组
    for (size_t i = 0; i < arr.size(); ++i) { // 遍历数组
        prefix[i + 1] = prefix[i] + (is_good_number(arr[i]) ? 1 : 0); // 计算前缀和
    }
    return prefix; // 返回前缀和数组
}

• 功能：生成前缀和数组，用于快速查询区间内“好数”的个数。

• 逻辑：

  • prefix[i] 表示数组前 i 个元素中“好数”的个数。

  • 如果 arr[i] 是“好数”，则前缀和加 1，否则加 0。

---

5. 主函数逻辑

int main() {
    int t;
    cin >> t; // 输入数组的组数
    vector> arrays(t); // 存储 t 组数组
    vector> prefixes(t); // 存储 t 组前缀和

• 功能：初始化存储数组和前缀和的数据结构。

---

6. 输入数组并预处理

for (int i = 0; i < t; ++i) { // 遍历每组数组
    int s;
    cin >> s; // 输入当前数组的大小
    arrays[i].resize(s); // 调整数组大小
    for (int j = 0; j < s; ++j) { // 遍历数组元素
        cin >> arrays[i][j]; // 输入数组元素
    }
    prefixes[i] = preprocess(arrays[i]); // 预处理生成前缀和
}

• 功能：输入每组数组，并生成对应的前缀和数组。

---

7. 处理查询

int b;
cin >> b; // 输入查询次数
for (int i = 0; i < b; ++i) { // 遍历每次查询
    int group, l, r;
    cin >> group >> l >> r; // 输入查询的数组组号和范围
    l--; // 将 l 转换为从 0 开始的下标
    r--; // 将 r 转换为从 0 开始的下标
    int good_count = prefixes[group - 1][r + 1] - prefixes[group - 1][l]; // 计算区间内“好数”的个数
    cout << good_count << endl; // 输出结果
}

• 功能：处理每次查询，输出区间内“好数”的个数。

• 逻辑：

  • 将用户输入的 l 和 r 转换为从 0 开始的下标。

  • 使用前缀和数组快速计算区间 [l, r] 内“好数”的个数。

---

8. 程序结束

return 0; // 程序正常结束

• 功能：表示程序执行成功并结束。

---

总结

• 核心思想：通过预处理和前缀和优化查询性能。

• 时间复杂度：

  • 预处理：O(t * s * sqrt(M))，其中 t 是组数，s 是数组大小，M 是数组中最大数。

  • 查询：O(b)，其中 b 是查询次数。

• 空间复杂度：O(t * s)，用于存储数组和前缀和。

通过这种设计，代码能够高效处理大规模数据，并满足题目对时间的要求。