动态规划——爬梯子

题目描述：

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

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

注意：给定 n 是一个正整数。

示例 1：

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

示例 2：

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

动规五部曲

1，确定dp数组以及下标的含义

dp[i]：爬到第i层楼梯，有dp[i]种方法

2.确定递归公式

推出dp[i]

1.dp[i-1]—>dp[i]  再跳一节台阶

2.dp[i-2]—>dp[i]  再跳两节台阶

两种可能->dp[i]

dp[i]=dp[i-1]+dp[i-2]

3.dp数组如何初始化

i=0时 dp[0]为0

i=1时 dp[1]为1，i=2时 dp[2]为2

4.确定遍历顺序

根据递归公式从前向后遍历

5，举例推导dp数组

代码出现问题时，打印dp，查看问题

代码

# 空间复杂度为O(n)版本
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 1:
            return n
        
        dp = [0] * (n + 1)
        dp[1] = 1
        dp[2] = 2
        
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        
        return dp[n]
# 空间复杂度为O(3)版本
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 1:
            return n
        
        dp = [0] * 3
        dp[1] = 1
        dp[2] = 2
        
        for i in range(3, n + 1):
            total = dp[1] + dp[2]
            dp[1] = dp[2]
            dp[2] = total
        
        return dp[2]
# 空间复杂度为O(1)版本
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 1:
            return n
        
        prev1 = 1
        prev2 = 2
        
        for i in range(3, n + 1):
            total = prev1 + prev2
            prev1 = prev2
            prev2 = total
        
        return prev2

问题扩展

题目描述

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

每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？ 

注意：给定 n 是一个正整数。

输入描述

输入共一行，包含两个正整数，分别表示n, m

输出描述

输出一个整数，表示爬到楼顶的方法数。

输入示例

3 2

输出示例

3

def climb_stairs(n, m):  
    dp = [0] * (n + 1)  
    dp[0] = 1  # 到达第0阶的方法数为1  

    for i in range(1, n + 1):  
        for j in range(1, min(m, i) + 1):  # j的循环应该从1到m，且不能超过i  
            dp[i] += dp[i - j]  

    return dp[n]  

# 输入示例  
n, m = map(int, input().split())  
print(climb_stairs(n, m))