动态规划入门：爬楼梯问题的递归到DP优化

1. 爬楼梯问题解析：从递归到动态规划的思维跃迁

第一次在LeetCode上遇到爬楼梯问题时，我盯着屏幕看了足足五分钟——题目描述简单到令人怀疑："每次可以爬1或2个台阶，有多少种不同的方法可以爬到第n阶？"这看似小学数学题背后，却隐藏着算法设计的精妙思想。作为动态规划的经典入门题，它完美诠释了如何将生活场景转化为数学模型。

这道题之所以被各大科技公司频繁用作面试题，是因为它能考察面试者三个核心能力：问题抽象能力（将实际场景转化为数学模型）、算法选择能力（识别问题特征选择合适解法）以及代码实现能力（边界条件处理和空间优化）。我见过不少候选人在白板上画了半天楼梯却写不出状态转移方程，也遇到过能直接写出最优解却解释不清思路的应试者。真正理解这道题，远比AC（Accept）更重要。

2. 解法演进：从暴力递归到空间优化

2.1 递归解法：最直观的思维陷阱

当我第一次尝试解决这个问题时，最自然的想法就是递归：

python复制def climbStairs(n):
    if n == 1: return 1
    if n == 2: return 2
    return climbStairs(n-1) + climbStairs(n-2)

这种解法虽然直观，但存在严重的性能问题。以n=5为例，调用栈会这样展开：

code复制climbStairs(5)
├── climbStairs(4)
│   ├── climbStairs(3)
│   │   ├── climbStairs(2)
│   │   └── climbStairs(1)
│   └── climbStairs(2)
└── climbStairs(3)
    ├── climbStairs(2)
    └── climbStairs(1)

时间复杂度高达O(2^n)，当n=40时，在我的笔记本上运行需要约15秒。这是因为存在大量重复计算——climbStairs(3)被计算了两次，climbStairs(2)被计算了三次。

关键教训：递归解法一定要先画调用树，确认是否存在重复计算。如果发现重叠子问题，就该考虑动态规划。

2.2 记忆化递归：空间换时间的平衡术

在纯递归基础上加入缓存，就是记忆化搜索（Memoization）：

python复制memo = {}
def climbStairs(n):
    if n in memo: return memo[n]
    if n == 1: return 1
    if n == 2: return 2
    memo[n] = climbStairs(n-1) + climbStairs(n-2)
    return memo[n]

这个优化将时间复杂度降到了O(n)，因为每个子问题只计算一次。但递归调用仍然需要O(n)的栈空间，当n很大时（比如10000），会导致栈溢出。在我的测试中，n=1000时Python默认递归深度就会报错。

2.3 动态规划：自底向上的迭代思维

动态规划（DP）采用迭代方式从基础情况逐步构建解：

python复制def climbStairs(n):
    if n == 1: return 1
    dp = [0]*(n+1)
    dp[1], dp[2] = 1, 2
    for i in range(3, n+1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

这种解法时间复杂度O(n)，空间复杂度O(n)。但仔细观察会发现，我们只需要前两个状态来计算当前值，因此可以优化空间：

2.4 空间优化DP：滚动数组的妙用

python复制def climbStairs(n):
    if n == 1: return 1
    a, b = 1, 2
    for _ in range(3, n+1):
        a, b = b, a+b
    return b

优化后空间复杂度降为O(1)，这是面试官最期望看到的终极解法。在我的性能测试中，n=1,000,000时仍能在0.3秒内完成计算。

3. 数学本质：斐波那契数列的变体

3.1 问题建模与数学证明

爬楼梯问题本质上是斐波那契数列的变种。让我们严格证明为什么这个问题的解符合斐波那契数列：

定义f(n)为爬到第n阶的方法数。要到达第n阶，只有两种可能：

1. 从第n-1阶跨1步
2. 从第n-2阶跨2步

因此，f(n) = f(n-1) + f(n-2)，这正是斐波那契数列的递推关系。初始条件为：

• f(1) = 1 （只有一种方法：跨1步）
• f(2) = 2 （两种方法：1+1或直接跨2步）

3.2 通项公式与时间复杂度突破

斐波那契数列有精确的数学通项公式（Binet公式）：

code复制f(n) = (φ^n - ψ^n)/√5
其中φ=(1+√5)/2≈1.618（黄金比例），ψ=(1-√5)/2≈-0.618

理论上可以用这个公式在O(1)时间内求解，但实际编程中会遇到浮点数精度问题。当n=71时，Python浮点数计算的结果就开始出现误差。

4. 边界条件与工程实践中的陷阱

4.1 dp[0]的哲学争议

在实现DP解法时，dp[0]的处理常引发争议。数学上，f(0)=1有其合理性（表示在地面有"一种方法"不爬任何台阶），但题目明确n≥1。我的建议是：

• 面试时明确询问面试官对n=0的处理要求
• 竞赛中仔细阅读题目约束
• 实际工程中加上参数校验

4.2 大数处理与溢出问题

当n很大时，结果会迅速溢出32位整数范围。以C++为例：

• n=46时结果已超过2^31-1
• 需要改用long long或BigInteger

测试案例：

cpp复制cout << climbStairs(46); // 输出2971215073 (超过INT_MAX)

5. 变种问题与思维拓展

5.1 步长扩展：三步走问题

如果每次可以爬1、2或3个台阶，解法如何调整？
状态转移方程变为：

code复制dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
初始条件：
dp[1]=1, dp[2]=2, dp[3]=4

5.2 成本最小化：带权值的爬楼梯

LeetCode 746题要求每步有体力消耗，求最小成本：

python复制def minCostClimbingStairs(cost):
    n = len(cost)
    dp = [0]*(n+1)
    for i in range(2, n+1):
        dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
    return dp[n]

5.3 禁止台阶：路径限制问题

当某些台阶被标记为"禁止"时（LeetCode 1415），需要跳过这些台阶：

python复制def climbStairs(n, forbidden):
    dp = [0]*(n+1)
    dp[0] = 1 if 0 not in forbidden else 0
    if n >= 1:
        dp[1] = 0 if 1 in forbidden else dp[0]
    for i in range(2, n+1):
        if i in forbidden:
            dp[i] = 0
        else:
            dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

6. 面试实战技巧与常见误区

6.1 白板编码时的注意事项

1. 先明确问题约束（n的范围、步长限制等）
2. 从递归思路开始，然后优化到DP
3. 主动讨论空间优化可能性
4. 考虑边界条件（n=0,1,2）
5. 测试案例至少包含：
   • n=3（最小非平凡案例）
   • n=5（验证递推正确性）
   • 大n值（测试鲁棒性）

6.2 候选人常见错误清单

1. 递归解法不考虑优化
2. DP数组大小误设为n而非n+1
3. 初始条件错误（如dp[2]=1）
4. 空间优化时变量更新顺序错误
5. 忽略整数溢出问题
6. 混淆方法数与步数的概念

7. 性能对比实测数据

在我的MacBook Pro (M1 Pro)上测试不同解法：

实际面试中，面试官通常期望看到从递归→记忆化→DP→空间优化的完整思考链条，而不仅仅是给出最优解。

8. 从这道题学到的工程思维

1. 重叠子问题识别：遇到递归问题时，第一时间思考是否存在重复计算
2. 空间-时间权衡：记忆化用空间换时间，滚动数组优化空间
3. 数学建模思维：将实际问题转化为已知数学模型（如斐波那契数列）
4. 边界条件意识：特别注意0值、初始值和溢出情况
5. 变种扩展能力：掌握问题核心后能灵活应对各种变形

在后来解决股票买卖、打家劫舍等DP问题时，我发现它们都沿用了类似的思维模式——定义状态、找出转移方程、优化存储空间。爬楼梯这道看似简单的题目，实则是打开动态规划大门的金钥匙。