LeetCode Hot100（64/100）——70. 爬楼梯

题目链接

LeetCode 70. 爬楼梯

题目说明

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

• 1 <= n <= 45

问题分析

这是一道经典的动态规划问题。我们来分析一下问题的本质：

要到达第 n 阶楼梯，只有两种可能：

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

因此，到达第 n 阶的方法数 = 到达第 n-1 阶的方法数 + 到达第 n-2 阶的方法数

这就是著名的斐波那契数列！

解法一：动态规划（自底向上）

原理讲解

动态规划的核心思想是将大问题分解为小问题，通过解决小问题来解决大问题。

对于爬楼梯问题：

• 初始状态：f(1) = 1（只有1种方法），f(2) = 2（有2种方法）
• 状态转移方程：f(n) = f(n-1) + f(n-2)
• 从小到大依次计算，直到得到 f(n)

Java代码实现

class Solution {
    public int climbStairs(int n) {
        // 边界条件处理
        if (n <= 2) {
            return n;
        }
        
        // 创建dp数组，dp[i]表示爬到第i阶的方法数
        int[] dp = new int[n + 1];
        
        // 初始化基础状态
        dp[1] = 1;  // 爬到第1阶只有1种方法
        dp[2] = 2;  // 爬到第2阶有2种方法
        
        // 自底向上计算
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        
        return dp[n];
    }
}

复杂度分析

• 时间复杂度：O(n)，需要遍历一次从 3 到 n 的所有数字
• 空间复杂度：O(n)，需要一个长度为 n+1 的数组存储中间结果

解法二：动态规划（空间优化）

原理讲解

观察解法一，我们发现计算 f(n) 时只需要 f(n-1) 和 f(n-2)，不需要保存所有的历史状态。

因此可以用两个变量来代替整个数组，实现空间优化。

Java代码实现

class Solution {
    public int climbStairs(int n) {
        // 边界条件处理
        if (n <= 2) {
            return n;
        }
        
        // 只需要保存前两个状态
        int prev2 = 1;  // f(n-2)
        int prev1 = 2;  // f(n-1)
        int curr = 0;   // f(n)
        
        // 从第3阶开始计算
        for (int i = 3; i <= n; i++) {
            curr = prev1 + prev2;  // 状态转移
            prev2 = prev1;         // 滚动更新
            prev1 = curr;
        }
        
        return curr;
    }
}

复杂度分析

• 时间复杂度：O(n)，需要遍历一次从 3 到 n 的所有数字
• 空间复杂度：O(1)，只使用了常数个变量

解法三：递归（带记忆化）

原理讲解

递归是最直观的解法，直接按照递推公式实现。但纯递归会有大量重复计算，因此需要使用记忆化来优化。

Java代码实现

class Solution {
    // 使用数组存储已计算的结果
    private int[] memo;
    
    public int climbStairs(int n) {
        memo = new int[n + 1];
        return climb(n);
    }
    
    private int climb(int n) {
        // 基础情况
        if (n <= 2) {
            return n;
        }
        
        // 如果已经计算过，直接返回
        if (memo[n] != 0) {
            return memo[n];
        }
        
        // 递归计算并存储结果
        memo[n] = climb(n - 1) + climb(n - 2);
        return memo[n];
    }
}

复杂度分析

• 时间复杂度：O(n)，每个子问题只计算一次
• 空间复杂度：O(n)，需要记忆化数组和递归调用栈

总结

爬楼梯问题是动态规划的入门经典题目，核心在于找到状态转移方程：f(n) = f(n-1) + f(n-2)

三种解法各有特点：

• 动态规划数组版本最容易理解，适合初学者
• 动态规划空间优化版本是最优解，实际应用推荐使用
• 递归记忆化版本代码最简洁，有助于理解问题本质

掌握这道题目后，可以尝试类似的变种问题，如每次可以爬 1、2 或 3 个台阶，或者某些台阶不能踩等。