欧拉函数与亲朋数：算法竞赛中的数学优化

markdown复制## 1. 题目背景与核心考察点

洛谷P10262"亲朋数"是一道经典的算法竞赛模拟题，主要考察选手对整数性质分析和基础算法优化的掌握能力。题目要求：对于给定的正整数n，定义其"亲朋数"为所有小于n且与n互质的正整数之和。需要高效计算多个查询的亲朋数值。

这道题融合了三个关键知识点：
- 欧拉函数性质（互质数判定）
- 前缀和预处理技巧
- 查询优化策略

在实际竞赛中，这类题目常出现在省选/NOIP中档难度题型中，是区分选手基础算法功底的重要标尺。

## 2. 互质数判定与欧拉函数

### 2.1 互质数定义
两个数互质意味着它们的最大公约数(GCD)为1。计算GCD的经典方法是欧几里得算法：

```cpp
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

2.2 欧拉函数特性

欧拉函数φ(n)表示小于n的正整数中与n互质的数的个数。虽然本题要求的是这些数的和而非个数，但欧拉函数的性质仍具有参考价值：

• 当n为质数时，φ(n) = n-1
• 若n=p^k（p为质数），φ(n) = p^k - p^(k-1)
• 对于互质的m,n，φ(mn) = φ(m)φ(n)

注意：直接套用欧拉函数公式无法得到本题要求的"和"，但可以帮助理解互质数的分布规律

3. 暴力解法与性能分析

3.1 基础实现

最直观的做法是对每个查询n，遍历1到n-1所有数，累加满足gcd(i,n)==1的数：

cpp复制int solve_naive(int n) {
    int sum = 0;
    for (int i = 1; i < n; ++i) {
        if (gcd(i, n) == 1) {
            sum += i;
        }
    }
    return sum;
}

3.2 时间复杂度

对于Q次查询，最大数值N：

• 单次查询：O(N log N)（gcd复杂度为O(log N)）
• 总体复杂度：O(QN log N)
  当Q和N达到1e5量级时，这种解法必然超时

4. 数学优化思路

4.1 关键数学性质

发现一个重要规律：对于n>1，与n互质的数总是成对出现（i与n-i互质）。例如n=10：

• 1与9互质
• 3与7互质
• 7与3互质
• 9与1互质

每对的和为n，因此亲朋数可以表示为：
sum = n * φ(n) / 2

4.2 特例处理

需要单独处理n=1的情况（φ(1)=1，但sum应为0）

4.3 优化后算法

cpp复制int solve_math(int n) {
    if (n == 1) return 0;
    return n * euler_phi(n) / 2;
}

5. 欧拉函数高效计算

5.1 单次计算实现

基于欧拉函数公式：
φ(n) = n × ∏(1 - 1/p) （p为n的所有不同质因数）

cpp复制int euler_phi(int n) {
    int res = n;
    for (int p = 2; p * p <= n; ++p) {
        if (n % p == 0) {
            res = res / p * (p - 1);
            while (n % p == 0) n /= p;
        }
    }
    if (n > 1) res = res / n * (n - 1);
    return res;
}

5.2 线性筛法预处理

当需要多次查询时，可以使用欧拉筛预处理所有φ值：

cpp复制const int MAX_N = 1e6;
int phi[MAX_N + 1];

void init_phi() {
    vector<bool> is_prime(MAX_N + 1, true);
    iota(phi, phi + MAX_N + 1, 0);
    
    for (int i = 2; i <= MAX_N; ++i) {
        if (is_prime[i]) {
            for (int j = i; j <= MAX_N; j += i) {
                is_prime[j] = (j == i);
                phi[j] = phi[j] / i * (i - 1);
            }
        }
    }
}

6. 完整AC代码实现

cpp复制#include <iostream>
#include <vector>
#include <numeric>
using namespace std;

const int MAX_N = 1e6;
int phi[MAX_N + 1];

void init() {
    vector<bool> is_prime(MAX_N + 1, true);
    iota(phi, phi + MAX_N + 1, 0);
    
    for (int i = 2; i <= MAX_N; ++i) {
        if (is_prime[i]) {
            for (int j = i; j <= MAX_N; j += i) {
                is_prime[j] = (j == i);
                phi[j] = phi[j] / i * (i - 1);
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    init();
    
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        if (n == 1) cout << "0\n";
        else cout << 1LL * n * phi[n] / 2 << "\n";
    }
    
    return 0;
}

7. 算法复杂度分析

• 预处理阶段：

  • 时间复杂度：O(N log log N)（类似埃氏筛）
  • 空间复杂度：O(N)

• 查询阶段：

  • 单次查询：O(1)
  • Q次查询：O(Q)

整体复杂度：O(N log log N + Q)，可以轻松处理N=1e6，Q=1e5规模的数据

8. 竞赛技巧与注意事项

1. 预处理范围选择：

   • 根据题目给出的n上限确定MAX_N
   • 通常设置为1e6+5防止越界

2. 整数溢出处理：

   • 当n=1e6时，n×φ(n)可能达到1e12量级
   • 使用1LL * n * phi[n] / 2确保64位计算

3. 输入输出优化：

   • 使用ios::sync_with_stdio(false)和cin.tie(nullptr)加速IO
   • 对于C++选手，避免使用endl（改用'\n'）

4. 边界条件测试：

   • 特别注意n=1的特殊情况
   • 测试n为质数、2的幂次等特殊情况

9. 同类题型扩展

掌握这道题后，可以解决以下变种问题：

1. LC 2103 环和杆：利用位运算统计互质特征
2. CF 1295D Same GCDs：欧拉函数的高级应用
3. 洛谷 P2303 Longge的问题：GCD求和与数论分块

竞赛经验：当题目涉及"互质数"相关计算时，优先考虑欧拉函数性质，并观察是否存在配对规律可以简化计算

10. 调试与验证技巧

1. 小数据验证：

   • 手工计算n=1~10的结果验证程序正确性
   • 例如n=6的亲朋数应为1+5=6

2. 对拍测试：

   python复制# 对拍验证程序（Python示例）
   import math
   def brute_force(n):
       return sum(i for i in range(1,n) if math.gcd(i,n)==1)
   
   def math_method(n):
       if n == 1: return 0
       def phi(x):
           res = x
           for p in range(2,int(x**0.5)+1):
               if x % p == 0:
                   while x % p == 0:
                       x //= p
                   res = res // p * (p-1)
           if x > 1:
               res = res // x * (x-1)
           return res
       return n * phi(n) // 2
   

3. 压力测试：

   • 生成n=1e6的极端情况测试程序稳定性
   • 验证预处理数组是否越界

11. 性能优化对比

实际竞赛中，90%的情况下选择预处理方案最为稳妥

12. 常见错误与修正

1. 忘记n=1特判：

   • 错误表现：输出1而不是0
   • 修正方法：添加if(n==1) return 0

2. 整数溢出：

   • 错误表现：大n时输出负数
   • 修正方法：使用1LL*强制类型转换

3. 预处理范围不足：

   • 错误表现：n=1e6时段错误
   • 修正方法：检查MAX_N定义和数组大小

4. φ计算错误：

   • 典型错误：忘记处理剩余的大于√n的质因数
   • 修正方法：在质因数分解后添加if(n>1)判断

13. 算法竞赛中的应用价值

这道题体现了算法竞赛中三个重要思维模式：

1. 数学转化思维：将看似需要遍历的问题转化为数学公式计算
2. 预处理思想：用空间换时间，将在线计算转为离线预处理
3. 边界意识：注意特殊情况的独立处理

在实际比赛中，遇到数论题时建议：

1. 先写暴力解法验证思路
2. 寻找数学规律优化
3. 考虑预处理可能性
4. 最后处理边界条件和IO优化

我个人的经验是：这类题目在纸上推导数学性质的时间往往比编码时间更重要，好的数学分析可以降低100倍的代码复杂度

code复制