信息学奥赛 NOIP 2012 质因数分解题解：从 1 行代码到 3 种优化策略

在信息学竞赛中，质因数分解是一个经典且基础的问题。NOIP 2012 普及组的这道真题看似简单，却蕴含着丰富的算法思想和优化技巧。本文将带您从最朴素的解法出发，逐步深入探讨三种高效优化策略，帮助您在竞赛中快速解决类似问题。

1. 问题分析与朴素解法

题目要求：已知正整数 n 是两个不同质数的乘积，试求出较大的那个质数。

1.1 问题理解

首先明确几个关键点：

• 输入：一个正整数 n（6 ≤ n ≤ 2×10^9）
• 输出：n 的较大质因数
• 保证：n 是两个不同质数的乘积

这意味着 n 的质因数分解形式只能是 p×q，其中 p 和 q 都是质数，且 p < q。

1.2 朴素解法实现

最直接的思路是从小到大枚举可能的因数：

#include <iostream> #include <cmath> using namespace std; int main() { int n; cin >> n; for (int i = 2; i <= sqrt(n); i++) { if (n % i == 0) { cout << n / i << endl; break; } } return 0; }

算法分析：

• 时间复杂度：O(√n)
• 空间复杂度：O(1)
• 优点：实现简单，代码量少
• 缺点：对于大数（接近 2×10^9）效率较低

提示：由于题目保证 n 是两个质数的乘积，所以找到的第一个因数必定是较小的质数，n/i 就是较大的质数。

2. 优化策略一：预处理质数表

2.1 优化思路

朴素解法需要检查所有可能的因数，但实际上我们只需要检查质数即可。如果能预先计算出一定范围内的质数表，可以显著减少需要检查的数的数量。

2.2 实现方法

#include <iostream> #include <vector> #include <cmath> using namespace std; vector<int> primes; // 存储预计算的质数 // 埃拉托斯特尼筛法生成质数表 void sieve(int limit) { vector<bool> is_prime(limit + 1, true); is_prime[0] = is_prime[1] = false; for (int i = 2; i * i <= limit; i++) { if (is_prime[i]) { for (int j = i * i; j <= limit; j += i) { is_prime[j] = false; } } } for (int i = 2; i <= limit; i++) { if (is_prime[i]) primes.push_back(i); } } int main() { int n; cin >> n; int limit = sqrt(n); sieve(limit); for (int p : primes) { if (n % p == 0) { cout << n / p << endl; return 0; } } // 如果没找到，说明较小的质数大于sqrt(n)，这与题意矛盾 cout << n << endl; // 实际上不会执行到这里 return 0; }

算法分析：

• 预处理时间复杂度：O(n log log n)
• 查询时间复杂度：O(π(√n)) ≈ O(√n / ln n)
• 空间复杂度：O(√n)

注意：虽然理论复杂度更好，但对于 n=2×10^9，√n≈44721，质数表大小约为 4633，实际运行效率提升有限。

3. 优化策略二：数学性质利用

3.1 关键观察

题目保证 n 是两个不同质数的乘积，这意味着：

1. n 只有两个质因数
2. 较小的质因数 p ≤ √n
3. 较大的质因数 q = n/p

因此，我们只需要找到第一个能整除 n 的数（从 2 开始），这个数必定是较小的质因数 p。

3.2 优化实现

#include <iostream> #include <cmath> using namespace std; int main() { int n; cin >> n; // 直接从2开始找第一个因数 for (int i = 2; ; i++) { if (n % i == 0) { cout << n / i << endl; break; } } return 0; }

优化点：

• 去掉了不必要的 sqrt(n) 计算
• 循环条件简化为 true，因为题目保证有解
• 实际运行效率可能比预想的更好，因为较小的质数更密集

性能对比：

4. 优化策略三：Pollard's Rho 算法简介

4.1 适用场景

虽然本题不需要这么高级的算法，但了解 Pollard's Rho 算法对处理更大数的质因数分解很有帮助。

4.2 算法思想

Pollard's Rho 算法是一种概率性算法，用于快速找到合数的一个非平凡因数。其核心思想是利用生日悖论，通过随机序列中的重复模 p 值来发现因数。

4.3 简化实现

#include <iostream> #include <cstdlib> #include <ctime> #include <algorithm> using namespace std; using ll = long long; ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } ll pollards_rho(ll n) { if (n % 2 == 0) return 2; if (n % 3 == 0) return 3; ll x = rand() % (n - 2) + 2; ll y = x; ll c = rand() % (n - 1) + 1; ll d = 1; while (d == 1) { x = (x * x + c) % n; y = (y * y + c) % n; y = (y * y + c) % n; d = gcd(abs(x - y), n); } return d; } int main() { srand(time(0)); ll n; cin >> n; ll factor = pollards_rho(n); cout << max(factor, n / factor) << endl; return 0; }

算法特点：

• 期望时间复杂度：O(n^(1/4))
• 适用于大数分解
• 概率性算法，可能需要进行多次尝试

注意：对于本题而言，这个算法过于复杂，但了解它有助于解决更一般的质因数分解问题。

5. 解题决策树与策略选择

根据不同的场景和约束条件，我们可以选择不同的解法：

是否需要处理一般质因数分解？ ├── 是 → 使用 Pollard's Rho 或其他高级算法 └── 否 → 题目是否保证是两个质数的乘积？ ├── 是 → 使用优化策略二（直接找第一个因数） └── 否 → 使用预处理质数表或朴素解法

对于 NOIP 2012 这道题，最优选择显然是优化策略二，因为它：

1. 代码简洁（仅需 10 行左右）
2. 运行效率高（平均情况远快于 √n）
3. 无需预处理或复杂实现

6. 实际测试与性能比较

我们在不同规模的输入下测试三种方法的性能：

测试结果表明，优化策略二在实际运行中表现最好，尤其是在 n 较大时优势明显。

7. 常见错误与注意事项

在解决这类问题时，容易犯以下错误：

1. 忽略题目条件：没有利用"两个不同质数"的条件，编写了完整的质因数分解代码
2. 边界条件处理不当：如 n=6（2×3）时的处理
3. 效率问题：对大数使用 O(n) 的算法导致超时
4. 数学错误：误认为需要检查所有数到 n/2

特别提醒：

• 题目已经保证 n 是两个不同质数的乘积，所以无需检查因数是否为质数
• 找到的第一个因数必定是质数（因为任何合数都是由更小的质数组成）
• 不需要处理 n=1 或 n 为质数的情况

8. 扩展思考

虽然本题已经足够简单，但我们可以进一步思考：

1. 如果不保证 n 是两个质数的乘积，该如何修改代码？
2. 如果需要输出所有质因数（考虑重复因数），算法该如何调整？
3. 如何优化算法以处理更大的 n（如 10^18）？

这些思考有助于我们更好地理解质因数分解问题的本质和解决方法。