动态规划入门：爬楼梯问题解析与优化

1. 爬楼梯问题与动态规划入门

作为一名算法工程师，我经常遇到新手对动态规划感到困惑的情况。而LeetCode第70题"爬楼梯"恰恰是理解动态规划最经典的入门案例。这道题看似简单，却蕴含着动态规划的核心思想——将复杂问题分解为重叠子问题。

题目描述很简单：假设你正在爬楼梯，需要n阶才能到达楼顶。每次你可以爬1或2个台阶。问有多少种不同的方法可以爬到楼顶？当n=2时，有2种方法（1+1或直接2）；当n=3时，有3种方法（1+1+1，1+2，2+1）。这个数列看起来是不是很熟悉？

2. 从暴力递归到记忆化搜索

2.1 基础递归解法

我们先从最直观的递归思路开始。要到达第n阶台阶，最后一步要么爬1阶（之前已经到达n-1阶），要么爬2阶（之前已经到达n-2阶）。因此，总方法数就是这两种情况的和。

java复制public int climbStairs(int n) {
    if(n == 0 || n == 1) return 1;
    return climbStairs(n-1) + climbStairs(n-2);
}

这个解法虽然正确，但效率极低。时间复杂度是O(2ⁿ)，因为每个调用会产生两个子调用。当n=40时，计算量已经超过万亿次，明显不可行。

注意：递归解法在实际面试中可能会被要求分析其缺点，务必指出它的指数级时间复杂度问题。

2.2 记忆化搜索优化

观察递归树会发现大量重复计算。比如计算climbStairs(5)需要计算climbStairs(4)和climbStairs(3)，而climbStairs(4)又需要计算climbStairs(3)和climbStairs(2)，这样climbStairs(3)就被计算了多次。

记忆化搜索通过保存已计算结果来避免重复计算：

java复制public int climbStairs(int n) {
    int[] memo = new int[n+1];
    return dfs(n, memo);
}

private int dfs(int n, int[] memo) {
    if(n == 0 || n == 1) return 1;
    if(memo[n] > 0) return memo[n];
    memo[n] = dfs(n-1, memo) + dfs(n-2, memo);
    return memo[n];
}

这个优化将时间复杂度降到了O(n)，因为每个子问题只计算一次。空间复杂度也是O(n)用于存储备忘录。

3. 动态规划的标准解法

3.1 自底向上的动态规划

记忆化搜索是自顶向下的解法，而动态规划通常采用自底向上的方式：

java复制public int climbStairs(int n) {
    if(n <= 1) return 1;
    int[] dp = new int[n+1];
    dp[0] = 1;
    dp[1] = 1;
    for(int i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2];
    }
    return dp[n];
}

这里我们定义了dp数组，其中dp[i]表示爬到第i阶的方法数。状态转移方程dp[i] = dp[i-1] + dp[i-2]是核心，初始化条件dp[0]=1和dp[1]=1确保了边界正确性。

3.2 空间优化版本

观察状态转移方程，我们发现dp[i]只依赖于前两个状态dp[i-1]和dp[i-2]，因此不需要存储整个数组：

java复制public int climbStairs(int n) {
    if(n <= 1) return 1;
    int prev1 = 1, prev2 = 1;
    for(int i = 2; i <= n; i++) {
        int curr = prev1 + prev2;
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

这个优化将空间复杂度从O(n)降到了O(1)，是面试中最推荐的写法。

4. 深入理解与扩展思考

4.1 数学本质：斐波那契数列

爬楼梯问题实际上是斐波那契数列的变种。斐波那契数列定义为F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)。而爬楼梯问题的解序列是1,1,2,3,5,8...，相当于斐波那契数列向右平移一位。

知道这个数学关系后，我们还可以使用矩阵快速幂或通项公式来求解，将时间复杂度降到O(log n)或O(1)。不过在面试中，动态规划解法通常就足够了。

4.2 变种问题

在实际面试中，面试官可能会提出各种变种问题来考察理解深度：

1. 步长变化：如果每次可以爬1、2或3个台阶，解法如何修改？

   • 只需将状态转移方程改为dp[i] = dp[i-1] + dp[i-2] + dp[i-3]

2. 空间限制：如果n很大（比如1e18），如何求解？

   • 需要使用矩阵快速幂或通项公式

3. 路径记录：不仅要计算数量，还要输出所有可能的路径组合

   • 需要使用回溯法，时间复杂度会变为指数级

4.3 实际应用场景

动态规划在现实中有广泛应用：

• 股票买卖问题（最佳买卖时机）
• 字符串编辑距离
• 背包问题
• 路径规划

爬楼梯问题虽然简单，但它包含了动态规划的所有核心要素：

1. 最优子结构：问题的最优解包含子问题的最优解
2. 重叠子问题：不同的决策序列会到达相同的子问题
3. 状态定义：明确定义dp[i]表示什么
4. 状态转移：如何从小问题的解得到大问题的解

5. 面试技巧与常见错误

5.1 面试回答框架

当面试官提出这个问题时，建议按以下结构回答：

1. 先说明暴力递归解法及其缺点
2. 提出记忆化搜索优化
3. 过渡到标准动态规划解法
4. 最后给出空间优化版本
5. 讨论时间/空间复杂度

5.2 常见错误点

新手在解决这个问题时常犯以下错误：

1. 边界条件处理不当：忘记处理n=0或n=1的情况
2. 初始化错误：dp[0]和dp[1]的值设置不正确
3. 数组越界：当n=1时仍尝试访问dp[2]
4. 空间优化时变量更新顺序错误

5.3 测试用例建议

在面试中写出代码后，应该主动测试以下用例：

• n=0（边界）
• n=1（边界）
• n=2（最小非平凡情况）
• n=5（中等大小）
• 较大的n（验证效率）

6. 性能对比与语言实现

6.1 各解法性能对比

6.2 多语言实现

虽然我们用Java演示，但在实际工作中可能需要其他语言实现：

Python实现：

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

C++实现：

cpp复制int climbStairs(int n) {
    int prev1 = 1, prev2 = 1;
    for(int i = 2; i <= n; i++) {
        int curr = prev1 + prev2;
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

JavaScript实现：

javascript复制function climbStairs(n) {
    let prev1 = 1, prev2 = 1;
    for(let i = 2; i <= n; i++) {
        [prev1, prev2] = [prev1 + prev2, prev1];
    }
    return prev1;
}

7. 从爬楼梯看动态规划模式

爬楼梯问题展示了动态规划的通用解决模式：

1. 定义状态：明确dp数组或变量的含义
2. 确定转移方程：找出状态之间的关系式
3. 初始化：确定初始值
4. 确定遍历顺序：保证计算当前状态时所需状态已计算
5. 举例推导：验证自己的思路

掌握这个模式后，可以解决大多数一维动态规划问题，如：

• 打家劫舍问题
• 最小花费爬楼梯
• 解码方法

在实际开发中，动态规划常用于优化递归问题、解决组合优化问题等。理解爬楼梯问题的本质，就掌握了动态规划的钥匙。