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 阶的方法数

这就是著名的斐波那契数列!
爬到第n阶
从第n-1阶爬1步
从第n-2阶爬2步
f n = f n-1 + f n-2

解法一:动态规划(自底向上)

原理讲解

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

对于爬楼梯问题:

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

n=1: 1种
n=2: 2种
n=3: 3种
n=4: 5种
n=5: 8种
...

Java代码实现

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),不需要保存所有的历史状态。

因此可以用两个变量来代替整个数组,实现空间优化。
curr prev1 prev2 curr prev1 prev2 初始状态 计算n=3 滚动更新 继续计算... 1 2 prev1 + prev2 = 3 prev1 = 2 curr = 3

Java代码实现

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),只使用了常数个变量

解法三:递归(带记忆化)

原理讲解

递归是最直观的解法,直接按照递推公式实现。但纯递归会有大量重复计算,因此需要使用记忆化来优化。
f 5
f 4
f 3
f 3
f 2
f 2
f 1
f 2
f 1
红色节点表示重复计算

Java代码实现

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 个台阶,或者某些台阶不能踩等。

相关推荐
凌冰_2 小时前
数据结构 - 时间空间复杂度(一)
数据结构·算法·软件工程
Pniubi3 小时前
力扣2 . 两数相加
算法·leetcode·职场和发展
戴·菲瑜3 小时前
为什么PPO难以做出顶级棋类引擎
算法·博弈论·rl·ppo
在所不辞兄5 小时前
为什么数字孪生驱动的产线标定需要在线更新机制,而不能一次标定后长期沿用?
人工智能·神经网络·其他·算法·机器学习
文丑颜不良啊9 小时前
LeetCode3401~3420题目解析
java·leetcode
AvocadoZeroOneOI10 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
文丑颜不良啊10 小时前
LeetCode3421~3440题目解析
java·leetcode
cjz389912 小时前
双指针技巧:覆盖式双指针(原地覆盖)
算法
橘子1315 小时前
【高级数据库】关系代数基本概念
算法
电科_银尘1 天前
【大模型算法与工程 15】手写Self-Attention:Q、K、V与缩放点积
算法