动态规划解决台阶问题：从递归到优化的完整指南

1. 台阶走法问题解析：从递归到动态规划的思维跃迁

遇到这种"n级台阶每次走1/2/3步有多少种走法"的问题，我第一反应是用递归暴力破解。毕竟递归是最符合人类直觉的解法——要上第n级台阶，无非就是从n-1级走1步，或者从n-2级走2步，亦或从n-3级走3步。这种分而治之的思想在算法设计中非常经典。

1.1 递归解法及其局限

递归解法的核心代码如下：

python复制def climb_stairs(n):
    if n == 0: return 1  # 地面算1种走法
    if n == 1: return 1
    if n == 2: return 2  # 1+1或2
    if n == 3: return 4  # 1+1+1, 1+2, 2+1, 3
    return climb_stairs(n-1) + climb_stairs(n-2) + climb_stairs(n-3)

这个解法虽然直观，但存在严重的性能问题。以计算climb_stairs(10)为例，递归树会指数级膨胀，时间复杂度达到O(3^n)。在我的测试中，计算n=30时已经需要数秒时间，n=40则完全无法在合理时间内完成。

关键发现：递归解法在n>30时基本不可用，这是因为存在大量重复计算。比如计算climb_stairs(5)时会重复计算climb_stairs(2)多达3次。

1.2 动态规划的优化思路

动态规划(DP)正是为解决这类重叠子问题而生的。我们可以用一个数组dp来存储中间结果，其中dp[i]表示走到第i级台阶的走法数。状态转移方程与递归思路一致：

code复制dp[i] = dp[i-1] + dp[i-2] + dp[i-3]

优化后的DP解法：

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

这个解法的时间复杂度降为O(n)，空间复杂度也是O(n)。在我的测试中，计算n=1000仅需几毫秒。

2. 动态规划的进阶优化

2.1 空间复杂度优化

观察状态转移方程可以发现，当前状态只依赖前三个状态。因此我们可以用滚动数组技术将空间复杂度优化到O(1)：

python复制def climb_stairs_optimized(n):
    if n == 0: return 1
    a, b, c = 1, 1, 2  # 对应dp[0],dp[1],dp[2]
    for _ in range(3, n+1):
        a, b, c = b, c, a+b+c
    return c if n >1 else a

2.2 矩阵快速幂解法

对于追求极致性能的场景，我们可以使用矩阵快速幂将时间复杂度进一步降到O(log n)。这种方法基于将递推关系表示为矩阵乘法：

code复制| f(n)   |   | 1 1 1 |   | f(n-1) |
| f(n-1) | = | 1 0 0 | * | f(n-2) |
| f(n-2) |   | 0 1 0 |   | f(n-3) |

通过矩阵的快速幂运算，我们可以在对数时间内计算出结果。虽然实现较复杂，但在n极大时(如1e18)优势明显。

3. 算法扩展与变种

3.1 步数限制变化

如果步数选择不限于1/2/3，而是一个数组steps=[s1,s2,...,sk]，解法只需稍作修改：

python复制def climb_stairs_general(n, steps):
    dp = [0]*(n+1)
    dp[0] = 1
    for i in range(1, n+1):
        for s in steps:
            if i >= s:
                dp[i] += dp[i-s]
    return dp[n]

3.2 带障碍的台阶问题

如果某些台阶有障碍不能踩(用数组obstacles表示)，解法调整如下：

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

4. 性能对比与实测数据

我在不同n值下测试了各种解法的性能(单位：秒)：

实际开发建议：对于n<30的小规模问题，递归写法更直观；中等规模(30<n<1e6)用优化DP；超大规模(n>1e6)考虑矩阵快速幂。

5. 常见错误与调试技巧

5.1 边界条件处理

新手常犯的错误是忽略边界条件。特别注意：

• n=0时应返回1(地面算一种走法)
• 初始化dp数组时前几个元素需要特别处理
• 在优化空间复杂度的版本中，n<3时的返回值需要单独判断

5.2 整数溢出问题

当n很大时，走法数可能超过普通整型的最大值。在Python中这不是问题，但在C++/Java等语言中需要使用long long或BigInteger。

5.3 记忆化搜索的实现

如果不喜欢自底向上的DP，也可以用记忆化递归(自顶向下)：

python复制from functools import lru_cache

@lru_cache(maxsize=None)
def climb_stairs_memo(n):
    if n <= 3: return [1,1,2,4][n]
    return climb_stairs_memo(n-1) + climb_stairs_memo(n-2) + climb_stairs_memo(n-3)

这种方法结合了递归的直观和DP的效率，但递归深度可能受栈大小限制。

6. 实际应用场景

这类问题不仅出现在算法题中，在实际工程中也有广泛应用：

1. 路径规划：机器人导航中寻找不同路径
2. 游戏设计：角色移动方式的组合计算
3. 密码学：某些密钥生成算法中的组合计数
4. 金融工程：计算不同投资组合的可能性

我在开发一个游戏关卡系统时就用到了这个算法，计算玩家从起点到终点的不同移动方式组合，从而评估关卡设计的多样性。