leetcode
leetcode 51 ~ 100
爬楼梯

爬楼梯

难度:

标签:

题目描述

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

每次你可以爬 12 个台阶。你有多少种不同的方法可以爬到楼顶呢?

 

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

代码结果

运行时间: 44 ms, 内存: 14.8 MB


/*
 * Problem Statement: Similar to the previous solution, we are to find the total number of unique ways to reach the top of the staircase.
 * 
 * Approach: Using Java Streams, we can initialize the dp array and compute the result in a functional manner.
 * The state transition remains the same as dp[i] = dp[i-1] + dp[i-2].
 */
 
import java.util.stream.IntStream;
 
public class ClimbingStairsStream {
    public int climbStairs(int n) {
        if (n <= 1) return 1;
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        IntStream.range(2, n + 1).forEach(i -> dp[i] = dp[i - 1] + dp[i - 2]);
        return dp[n];
    }
}
 

解释

方法:

这个题解使用动态规划的思路。定义状态 dp[i] 表示爬到第 i 阶楼梯的不同方法数量。可以得到状态转移方程:dp[i] = dp[i-1] + dp[i-2],因为爬到第 i 阶可以从第 i-1 阶爬 1 步,或者从第 i-2 阶爬 2 步。题解中使用两个变量 a 和 b 来代替数组,以节省空间,不断更新 a 和 b 的值,最终得到爬到第 n 阶的方法数量。

时间复杂度:

O(n)

空间复杂度:

O(1)

代码细节讲解

🦆
为什么在动态规划中选择了状态转移方程 dp[i] = dp[i-1] + dp[i-2]?
选择状态转移方程 dp[i] = dp[i-1] + dp[i-2] 是因为要爬到第 i 阶楼梯,有两种方法:从第 i-1 阶楼梯爬一步到达或从第 i-2 阶楼梯爬两步到达。因此,到达第 i 阶的方法数是到达第 i-1 阶的方法数和到达第 i-2 阶的方法数之和。这种关系反映了问题的子结构和重叠子问题,是动态规划解决这类问题的典型表达。
🦆
在题解的代码中,变量 a 和 b 的初始值为什么设定为 1 和 2?
变量 a 和 b 的初始值分别设定为 1 和 2 是因为这是问题的基本情况。当 n=1 时,只有一种方法爬到第一阶(直接1步),因此 dp[1]=1(即变量 a)。当 n=2 时,有两种方法到达第二阶:直接从地面爬两步或先爬一步到第一阶后再爬一步,因此 dp[2]=2(即变量 b)。这两个初始值是后续计算的基础,允许通过迭代递推计算更高阶的答案。
🦆
循环中的更新语句 'a, b = b, a + b' 是如何确保不会在赋值过程中出现错误或数据丢失?
Python中的语句 'a, b = b, a + b' 使用了元组解包的特性,这意味着在赋值操作之前,右侧表达式会先被计算并创建为一个元组 (b, a + b),然后这个元组被解包并分别赋值给 a 和 b。这个操作是原子的,保证了在赋值过程中变量的值不会相互干扰或丢失,从而正确地更新了两个变量的值。
🦆
如果需要修改程序以打印出到达每一级台阶的所有具体路径而不仅仅是数量,应该如何调整这个算法?
若要修改程序以打印出所有具体路径,需要使用一个不同的方法来存储路径而不仅仅是数量。可以创建一个列表 dp,其中 dp[i] 存储到达第 i 阶的所有路径的列表。初始时,dp[1] = [['1']],dp[2] = [['1', '1'], ['2']]。对于每一阶 i > 2,更新 dp[i] 为 dp[i-1] 中每条路径后加 '1' 和 dp[i-2] 中每条路径后加 '2'。最后打印 dp[n] 就可以显示到达第 n 阶的所有路径。这需要更多的空间来存储路径信息,并增加了处理每个阶梯的复杂度。

相关问题

使用最小花费爬楼梯

给你一个整数数组 cost ,其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用,即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

 

示例 1:

输入:cost = [10,15,20]
输出:15
解释:你将从下标为 1 的台阶开始。
- 支付 15 ,向上爬两个台阶,到达楼梯顶部。
总花费为 15 。

示例 2:

输入:cost = [1,100,1,1,1,100,1,1,100,1]
输出:6
解释:你将从下标为 0 的台阶开始。
- 支付 1 ,向上爬两个台阶,到达下标为 2 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 4 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 6 的台阶。
- 支付 1 ,向上爬一个台阶,到达下标为 7 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 9 的台阶。
- 支付 1 ,向上爬一个台阶,到达楼梯顶部。
总花费为 6 。

 

提示:

  • 2 <= cost.length <= 1000
  • 0 <= cost[i] <= 999

斐波那契数

斐波那契数 (通常用 F(n) 表示)形成的序列称为 斐波那契数列 。该数列由 01 开始,后面的每一项数字都是前面两项数字的和。也就是:

F(0) = 0,F(1) = 1
F(n) = F(n - 1) + F(n - 2),其中 n > 1

给定 n ,请计算 F(n)

 

示例 1:

输入:n = 2
输出:1
解释:F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2:

输入:n = 3
输出:2
解释:F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3:

输入:n = 4
输出:3
解释:F(4) = F(3) + F(2) = 2 + 1 = 3

 

提示:

  • 0 <= n <= 30

第 N 个泰波那契数

泰波那契序列 Tn 定义如下: 

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n,请返回第 n 个泰波那契数 Tn 的值。

 

示例 1:

输入:n = 4
输出:4
解释:
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4

示例 2:

输入:n = 25
输出:1389537

 

提示:

  • 0 <= n <= 37
  • 答案保证是一个 32 位整数,即 answer <= 2^31 - 1