LeetCode 第70题：爬楼梯

LeetCode 第70题：爬楼梯

题目描述

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

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

难度

简单

题目链接

点击在LeetCode中查看题目

示例

示例 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

解题思路

动态规划

这是一个经典的动态规划问题，可以发现：

1. 到达第n阶的方法数等于到达第(n-1)阶和第(n-2)阶的方法数之和
2. 这是因为最后一步可以选择爬1阶或2阶
3. 形成了斐波那契数列的规律

关键点：

1. 确定状态转移方程：dp[n] = dp[n-1] + dp[n-2]
2. 确定初始状态：dp[1] = 1, dp[2] = 2
3. 注意边界情况处理
4. 可以优化空间复杂度

具体步骤：

1. 处理特殊情况（n=1,2）
2. 使用动态规划数组或变量记录状态
3. 按照状态转移方程计算
4. 返回最终结果

图解思路

算法步骤分析表

步骤	操作	状态	说明
初始	n=4	[1,2]	初始状态
第1步	dp[3]=3	[1,2,3]	1+2=3
第2步	dp[4]=5	[1,2,3,5]	2+3=5
结果	返回5	-	最终结果

状态/情况分析表

情况	输入	输出	说明
基本情况	n=1	1	只有一种方法
简单情况	n=2	2	两种方法
一般情况	n=4	5	需要动态规划

代码实现

C# 实现

public class Solution {
    public int ClimbStairs(int n) {
        if (n <= 2) return n;
        
        // 使用两个变量优化空间复杂度
        int oneStep = 1;  // 代表dp[i-1]
        int twoStep = 2;  // 代表dp[i-2]
        int result = 0;
        
        for (int i = 3; i <= n; i++) {
            // 计算当前阶数的方法数
            result = oneStep + twoStep;
            // 更新状态
            oneStep = twoStep;
            twoStep = result;
        }
        
        return result;
    }
}

Python 实现

class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2:
            return n
        
        # 使用两个变量优化空间复杂度
        one_step = 1  # 代表dp[i-1]
        two_step = 2  # 代表dp[i-2]
        result = 0
        
        for i in range(3, n + 1):
            # 计算当前阶数的方法数
            result = one_step + two_step
            # 更新状态
            one_step = two_step
            two_step = result
        
        return result

C++ 实现

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n;
        
        // 使用两个变量优化空间复杂度
        int oneStep = 1;  // 代表dp[i-1]
        int twoStep = 2;  // 代表dp[i-2]
        int result = 0;
        
        for (int i = 3; i <= n; i++) {
            // 计算当前阶数的方法数
            result = oneStep + twoStep;
            // 更新状态
            oneStep = twoStep;
            twoStep = result;
        }
        
        return result;
    }
};

执行结果

• 执行用时：20 ms
• 内存消耗：26.3 MB

代码亮点

1. 🎯 使用动态规划解决问题
2. 💡 优化空间复杂度为O(1)
3. 🔍 边界情况处理完善
4. 🎨 代码简洁易读

常见错误分析

1. 🚫 递归实现导致超时
2. 🚫 边界条件处理错误
3. 🚫 状态转移方程错误
4. 🚫 变量更新顺序错误

解法对比

解法	时间复杂度	空间复杂度	优点	缺点
动态规划(数组)	O(n)	O(n)	直观易懂	空间消耗大
动态规划(变量)	O(n)	O(1)	空间优化	状态不可见
递归	O(2ⁿ)	O(n)	代码简单	性能很差
数学公式	O(1)	O(1)	最优性能	不易理解

相关题目

• 使用最小花费爬楼梯 - 简单
• 斐波那契数 - 简单
• 第 N 个泰波那契数 - 简单