整数因子分解的算法优化：递归分治与动态规划的实战对比

1. 从一道经典题目说起：整数因子分解到底在算什么？

大家好，我是老陈，一个在算法和性能优化领域摸爬滚打了十多年的老码农。今天想和大家深入聊聊一个听起来有点数学，但在编程面试和实际开发中时不时就会碰上的问题：整数因子分解的计数问题。

别被名字吓到，咱们先看个简单的例子。题目是这样的：给你一个大于1的正整数n，比如12，它可以写成一系列大于1的整数的乘积形式。像12=12，12=62，12=43，12=34，12=322，12=26，12=232，12=223。注意，这里34和43被认为是不同的分解式，因为顺序变了。我们的目标不是找出质因数，而是计算出所有可能的、考虑顺序的乘积表达式有多少种。

我第一次遇到这个问题时，直觉就是暴力枚举，把n的所有因子排列组合试一遍。但稍微一想就知道，当n大到像2亿（2000000000）这个级别时，暴力法根本行不通，光是遍历所有可能的因子组合，时间就爆炸了。这就像让你数清一个巨大仓库里所有货物的摆放方式，你不能一件件去摆，必须找到聪明的计数方法。

这个问题本质上是一个计数问题，它考察的是我们对整数结构的理解，以及如何用算法高效地组织计算，避免重复和遗漏。在算法武器库里，递归分治和动态规划是解决这类具有重叠子问题性质的任务的两把利剑。今天，我就结合自己踩过的坑和优化经验，带大家亲手实现这两种方法，并掰开揉碎地对比它们的性能、内存消耗和适用场景。你会发现，选择不同的算法，效率可能天差地别。

2. 庖丁解牛：递归分治法的直观思路与实现

当我们拿到问题，最自然的想法可能就是递归。递归分治的核心思想是“大事化小，小事化了”：把一个复杂问题分解成若干个规模较小的相同子问题，直到子问题可以直接求解。

2.1 递归关系的建立

对于整数n，我们定义 f(n) 为n的不同分解式个数。那么，n的一个分解式，它的第一个因子可以是n的任何一个真因子（包括1和n本身吗？注意，因子通常指能整除n的正整数，但在这个问题里，分解式要求因子大于1，不过f(1)我们定义为1，作为递归基）。如果第一个因子是 i (i能整除n，且 i>=2)，那么剩下的部分就是对 n/i 进行分解。因此，f(n) 就等于对所有可能的第一个因子i，其分解方案数 f(n/i) 的总和。

用数学公式表达就是： f(n) = Σ f(n/i)，其中 i 取遍 n 的所有大于等于2的因子。 并且我们规定 f(1) = 1。这很好理解，数字1只有一种分解方式，就是它自身（或者理解为空乘积）。

举个例子，n=20。20的因子有1, 2, 4, 5, 10, 20。根据公式： f(20) = f(20/2) + f(20/4) + f(20/5) + f(20/10) + f(20/20) 即 f(20) = f(10) + f(5) + f(4) + f(2) + f(1)。 然后我们继续递归计算 f(10), f(5)... 直到算到 f(1)=1。

2.2 第一版递归代码与它的性能陷阱

根据上面的思路，我们可以很快写出第一版递归代码。这个版本非常直白，就是遍历所有可能的因子i（从2到n），如果i能整除n，就递归计算 f(n/i) 并累加。

#include <stdio.h>

int solve(int n) {
    if (n == 1) return 1; // 递归基
    int ans = 1; // 初始化为1，代表 n = n 这种分解自身的情况
    for (int i = 2; i <= n; i++) {
        if (n % i == 0) {
            ans += solve(n / i);
        }
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solve(n));
    return 0;
}

这段代码逻辑正确，但对于稍大的n，比如1000，运行起来就会明显感到卡顿。为什么？因为它存在大量的重复计算。例如，计算 f(100) 时会计算 f(50)，计算 f(50) 时又会计算 f(25)，而在计算 f(100) 的其他分支（比如通过 f(20)）时，f(25) 又会被重复计算多次。这种指数级的重复是递归性能杀手。

2.3 关键优化：剪枝与对称性利用

直接遍历到n太慢了。我们注意到，因子是成对出现的。如果 i 是n的因子，那么 n/i 也是。我们只需要遍历到 sqrt(n) 就可以了。这能极大减少循环次数。

优化后的递归关系需要调整：

1. 对于 i * i < n 的情况，当我们找到因子i时，我们同时找到了另一个因子 n/i。因此，贡献的分解式数为 f(i) + f(n/i)。
2. 对于 i * i == n 的情况，因子i和 n/i 是同一个数，所以只贡献 f(i)。

此外，我们可以用记忆化搜索（Memoization） 来避免重复计算。这是将递归转化为高效算法的关键一步，它本质上已经是动态规划的思想了。我们用一个数组或哈希表来存储已经计算过的 f(n) 的值。

#include <stdio.h>
#include <math.h>

#define MAX_N 200000
// 假设我们通过其他方式知道最大需要计算的中间值不会超过MAX_N
// 对于更大的n，可能需要用哈希表（如C++的unordered_map）

long long memo[MAX_N]; // 使用long long防止结果溢出

long long solve(int n) {
    if (n < MAX_N && memo[n] != 0) {
        return memo[n];
    }
    if (n == 1) return 1;

    long long ans = 1; // n = n 的情况
    int sqrt_n = (int)sqrt(n);
    for (int i = 2; i <= sqrt_n; i++) {
        if (n % i == 0) {
            ans += solve(i);
            if (i != n / i) { // 避免平方数重复加
                ans += solve(n / i);
            }
        }
    }
    // 注意：遍历到sqrt(n)时，因子n本身（对应i=1的情况）已经在初始化ans=1时包含了
    // 因子1对应的f(n/1)=f(n)会导致无限递归，所以不能放入循环。
    if (n < MAX_N) {
        memo[n] = ans;
    }
    return ans;
}

int main() {
    int n;
    scanf("%d", &n);
    // 初始化记忆数组
    for(int i=0; i<MAX_N; i++) memo[i] = 0;
    memo[1] = 1;
    printf("%lld\n", solve(n));
    return 0;
}

这一版代码加入了记忆化和平方根优化，性能有了质的飞跃。它保留了递归分治思想清晰易懂的优点，又通过“用空间换时间”的策略解决了重复计算的问题。实测下来，对于n在几百万以内的数据，已经可以在毫秒级返回结果。

3. 运筹帷幄：动态规划的系统性解法

如果说递归分治是“自顶向下”的分解，那么动态规划（DP）就是“自底向上”的构建。DP更适合思维严谨、喜欢系统化解决问题的朋友。它的核心是找到状态定义、状态转移方程，并确定计算顺序。

3.1 动态规划的状态设计与转移

对于这个问题，一个直接的DP状态定义是：dp[x] 表示整数x的分解式个数。但x的范围可能很大（最大20亿），我们无法开出这么大的数组。怎么办？

我们需要更巧妙的建模。注意，最终我们只关心 f(n)，而计算过程中涉及到的所有数字，都是n的因子（包括1和n）。因为每次分解都是取出n的一个因子，剩下的部分继续分解，所以过程中产生的所有数，一定是n的因子。

因此，我们可以这样做：

1. 找出n的所有因子，并按升序排列。假设共有m个因子，存放在数组 factor[0...m-1] 里，其中 factor[0]=1, factor[m-1]=n。
2. 定义DP状态：dp[i] 表示对于因子 factor[i]，它的不同分解式个数。
3. 确定边界：最小的因子是1，dp[0] = 1（数字1只有一种分解）。
4. 推导状态转移方程：对于 factor[i]（i>0），它的分解式个数等于所有能整除它的“更小因子” factor[j] 的分解式个数之和。因为 factor[i] 的一个分解式，其第一个因子必然是它的某个因子 factor[j]，剩下的部分就是分解 factor[i] / factor[j]，而这个商也必然是因子列表中的一个（因为因子集合是封闭的）。所以： dp[i] = Σ dp[j]，其中 j 满足 j < i 且 factor[i] % factor[j] == 0。
5. 计算顺序：由于 dp[i] 依赖于比 factor[i] 小的因子的dp值，所以我们按照因子从小到大的顺序计算即可。

3.2 动态规划代码实现与细节剖析

根据上述思路，我们可以写出清晰的DP代码。这里有一个关键点是如何高效地找出n的所有因子。和递归优化一样，我们只需要遍历到 sqrt(n)。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 比较函数，用于qsort
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long solve_dp(int n) {
    // 第一步：找出所有因子
    int factors[2000]; // 根据算术基本定理，2000足够容纳20亿以内任何数的因子
    int cnt = 0;
    int sqrt_n = (int)sqrt(n);

    for (int i = 1; i <= sqrt_n; i++) {
        if (n % i == 0) {
            factors[cnt++] = i;
            if (i != n / i) { // 避免重复添加平方根
                factors[cnt++] = n / i;
            }
        }
    }
    // 对因子进行排序，这是DP正确计算的前提
    qsort(factors, cnt, sizeof(int), compare);

    // 第二步：动态规划
    long long dp[2000] = {0};
    dp[0] = 1; // factor[0] 一定是1

    for (int i = 1; i < cnt; i++) {
        dp[i] = 0; // 初始化当前因子的分解数
        for (int j = 0; j < i; j++) {
            // 如果factors[j]是factors[i]的因子
            if (factors[i] % factors[j] == 0) {
                dp[i] += dp[j];
            }
        }
    }

    // 最后一个因子就是n本身
    return dp[cnt - 1];
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%lld\n", solve_dp(n));
    return 0;
}

这段代码的结构非常规整。首先收集因子，然后排序，最后进行两重循环的DP计算。它的时间复杂度主要取决于因子个数m。对于n=20亿，其因子个数远小于sqrt(n)，大约在几百的量级，所以双重循环（O(m²)）是完全可接受的。这比原始递归的指数复杂度要好得多。

4. 正面交锋：递归分治 vs 动态规划的性能实测

纸上得来终觉浅，绝知此事要躬行。理论分析再好，不如跑个分看看。我搭建了一个简单的测试环境，在同一台机器上，用C语言分别实现了带记忆化的递归分治（方案A）和动态规划（方案B），对不同的n进行测试，并统计运行时间（单位：毫秒，取多次平均）。

从测试结果可以清晰地看出几点：

1. 正确性：两种方法得到的结果完全一致，验证了算法的正确性。
2. 性能：动态规划方法在所有测试规模下都优于递归分治方法，随着n增大，优势越明显。对于最大的n=20亿，DP比递归快大约3倍。
3. 趋势：递归方法虽然加了记忆化，但在递归调用、函数栈开销、哈希表查询（或数组访问）上仍有成本。而DP是纯粹的迭代和数组操作，缓存友好，效率更高。

4.1 内存与可读性对比

内存方面：两者都需要额外的存储空间。递归的记忆化通常需要一个查找表（如数组或哈希表）来存储子问题的解，其大小取决于递归过程中访问的不同状态数。DP方法则需要存储所有因子的数组和等长的DP数组。对于n=20亿，因子个数通常在1000以内，所以两者内存消耗都在KB级别，差异不大。但如果n非常特殊，因子极多（例如高度合成数），DP的因子数组大小是确定的（我们开了2000），而递归的记忆化表可能需要更大的容量或更复杂的哈希表，此时DP的内存管理更简单可控。

可读性与思维模式：这是两者最大的区别。递归分治的代码更符合人类对问题的直观分解思维，“要求f(n)，先求f(它的因子)”，逻辑链条直接。对于初学者或快速原型开发，递归更容易编写和理解。而动态规划需要你更前置地思考整个问题的结构，设计状态和转移方程，思维更具系统性和抽象性，代码往往更紧凑、高效，但理解门槛稍高。

4.2 如何选择？给你的实战建议

经过上面的对比，你可能觉得动态规划完胜，以后无脑用DP就好了。但在实际项目中，选择哪种方法，还需要考虑更多维度。

• 选择递归分治+记忆化当：

  • 你追求代码的直观和快速实现。在面试或竞赛中，如果时间紧迫，先写出正确的递归解法是稳妥的起点。
  • 问题的子问题空间（状态）是稀疏的或难以预先枚举。有些问题，只有部分状态会被访问到，用记忆化递归可以“按需计算”，避免计算无用状态。虽然本题因子是确定的，但有些变种问题可能具备此特点。
  • 你更熟悉递归的思维模式。对于树形结构等天然递归的问题，递归代码写起来更舒服。

• 选择动态规划当：

  • 性能是首要考虑因素。正如测试所示，DP通常有更稳定的、更优的常数时间复杂度。
  • 你需要清晰的状态转移流程。DP的表格化过程使得调试和验证中间结果更容易。
  • 问题规模已知且可以预处理。像本题这样能预先求出所有因子，DP的优势就能充分发挥。
  • 你担心递归深度过深导致栈溢出。虽然本题的递归深度不深（等于因子链长度），但对于一些递归深度可能很大的问题，迭代的DP更安全。

在我的经验里，对于整数因子分解计数这个问题，如果输入范围很大（比如达到10^9量级），我通常会首选动态规划方法。它的性能表现更可预测，代码结构也利于后续扩展（比如，如果需要输出具体的分解方案，DP表格能提供更多信息）。而递归加记忆化的方法，我更多将其作为一种思维训练和快速验证算法正确性的工具。

最后，无论选择哪种方法，优化意识是关键。在递归中，想到用记忆化避免重复计算；在DP中，想到利用因子成对出现的特性减少循环次数。这些优化点往往比选择哪种范式本身更能带来性能提升。算法学习就是这样，理解原理，对比优劣，然后在合适的场景运用最合适的工具。希望这篇对比分析能帮你下次遇到类似问题时，做出更游刃有余的选择。