动态规划解丑数问题：从暴力枚举到三指针优化

1. 题目解析与核心矛盾

"丑数 II"这道算法题表面看是要求找出第n个丑数，实则暗藏玄机。丑数定义是只包含质因数2、3、5的正整数，看似简单，但不同解法效率差异能达到指数级。这道题就像一面照妖镜，能清晰反映出解题者是停留在暴力枚举的初级阶段，还是掌握了结构化思维的精髓。

我第一次遇到这个问题时，本能反应就是逐个检查自然数序列，判断每个数是否是丑数。这种方法虽然直观，但当n=1690时（LeetCode原题测试用例），我的Python代码运行了足足12秒才给出答案——这在算法竞赛中简直是灾难性的表现。

2. 暴力解法的问题诊断

2.1 典型暴力实现

最直接的暴力解法是这样的：

python复制def is_ugly(num):
    for p in [2, 3, 5]:
        while num % p == 0:
            num = num // p
    return num == 1

def nthUglyNumber(n):
    count = 0
    num = 1
    while count < n:
        if is_ugly(num):
            count += 1
        num += 1
    return num - 1

2.2 时间复杂度分析

这个解法的时间复杂度是O(nlogn)，看似还不错？但实际上，随着n增大，丑数的分布越来越稀疏。当n=1690时，需要检查的整数范围会扩大到约10^6量级，而其中绝大多数检查都是无效的。

关键发现：暴力解法最大的问题是做了大量无用功，检查了许多明显不是丑数的数字（比如包含其他质因数的数）。

3. 结构化思维的解法突破

3.1 动态规划解法

高效解法需要转换思路：不是"判断一个数是否是丑数"，而是"如何按顺序生成丑数"。这引导我们想到动态规划：

python复制def nthUglyNumber(n):
    dp = [1] * n
    p2 = p3 = p5 = 0
    for i in range(1, n):
        next2, next3, next5 = dp[p2]*2, dp[p3]*3, dp[p5]*5
        dp[i] = min(next2, next3, next5)
        if dp[i] == next2: p2 += 1
        if dp[i] == next3: p3 += 1
        if dp[i] == next5: p5 += 1
    return dp[-1]

3.2 三指针法的精妙之处

这个解法之所以高效，是因为：

1. 每个丑数都是前面某个丑数的2/3/5倍
2. 使用三个指针分别跟踪2/3/5的乘法进度
3. 每次选择最小的候选数，保证生成顺序

时间复杂度骤降至O(n)，空间复杂度O(n)。对于n=1690，运行时间从12秒降到了0.0001秒量级。

4. 算法优化中的思维跃迁

4.1 从枚举到生成的转变

暴力解法是典型的"筛选思维"——从大量候选者中筛选符合条件的。而高效解法是"生成思维"——直接按规则构造目标序列。这种思维转变在解决许多算法问题时都至关重要。

4.2 问题抽象能力的培养

识别出"每个丑数都是较小丑数的2/3/5倍"这一关键性质，需要：

1. 观察前几个丑数的生成规律
2. 发现乘法因子的递推关系
3. 设计指针来维护不同因子的进度

5. 实战中的常见误区与调试技巧

5.1 指针更新陷阱

初学者常犯的错误是：

python复制if dp[i] == next2: p2 += 1
elif dp[i] == next3: p3 += 1
else: p5 += 1

这种写法当next2 == next3时会漏更新p3，导致后续结果错误。必须用三个独立的if判断。

5.2 初始化注意事项

1. dp数组初始化为[1]，不是[0]
2. 三个指针初始化为0，不是1
3. 循环从1开始，不是0

5.3 边界条件测试

必须测试的边界情况：

• n=1（应返回1）
• n=7（应返回8）
• 较大的n值（如1690）

6. 算法扩展与变种思考

6.1 超级丑数问题

如果将质因数从[2,3,5]扩展到任意质数列表，解法只需稍作修改：

python复制def nthSuperUglyNumber(n, primes):
    dp = [1] * n
    pointers = [0] * len(primes)
    for i in range(1, n):
        candidates = [dp[p] * primes[j] for j, p in enumerate(pointers)]
        dp[i] = min(candidates)
        for j in range(len(primes)):
            if dp[i] == dp[pointers[j]] * primes[j]:
                pointers[j] += 1
    return dp[-1]

6.2 性能优化空间

对于特别大的n（如10^6级），可以考虑：

1. 使用堆来维护候选数
2. 预计算丑数表
3. 数学方法估算丑数分布密度

7. 思维模式训练建议

要培养结构化算法思维，我建议：

1. 每道题先思考暴力解法，明确其瓶颈
2. 寻找问题中的递推或生成规律
3. 用简单的测试案例验证思路
4. 总结同类问题的解题模板
5. 定期复习经典问题的多种解法

这道"丑数 II"就像算法学习中的分水岭，掌握其精髓后，你会发现许多类似问题（如斐波那契数列、爬楼梯问题）都可以用相似的生成思路高效解决。记住，优秀的算法工程师不是靠蛮力取胜，而是靠发现并利用问题中的结构规律。