爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
注意:给定 n 是一个正整数。

示例 1:
输入: 2
输出: 2
解释: 有两种方法可以爬到楼顶。

  1. 1 阶 + 1 阶
  2. 2 阶

示例 2:

输入: 3
输出: 3
解释: 有三种方法可以爬到楼顶。

  1. 1 阶 + 1 阶 + 1 阶
  2. 1 阶 + 2 阶
  3. 2 阶 + 1 阶

解题思路:
动态规划思想。
自己的求解过程,感觉有点儿像数学中的“归纳法”,先把小规模的解列出来,再归纳出函数。
知道问题规模小的时候的解(函数f(n),特殊),如n=1、2,然后推理得f(n)=f(n-1)+f(n-2)

Python:
一、
超时

class Solution:
    def climbStairs(self, n: int) -> int:
        if n==1:
            return 1
        if n == 2:
            return 2
        num = self.climbStairs(n-1) + self.climbStairs(n-2)
        return num

二、

class Solution:
    def climbStairs(self, n: int) -> int:
        if n==1:
            return 1
        if n == 2:
            return 2
        n1 = 1
        n2 = 2
        for i in range(3,n+1):
            num = n1 + n2
            n1 = n2
            n2 = num
        return num

C++
方法一:
暴力递归,列举出可能的情况。
时间复杂度O(2n),空间复杂度O(n).

class Solution {
public:
    int climbStairs(int n) {
        return climb_Stairs(0, n);
    }
    int climb_Stairs(int i, int n){
        if(i>n) return 0;
        if(i==n) return 1;
        return climb_Stairs(i+1, n) + climb_Stairs(i+2, n);
    }
};

方法二
记忆递归
时间复杂度O(n),空间复杂度O(n)
暴力递归中有许多重叠子问题,将计算过的子问题的解保存起来,可以减小时间复杂度。

class Solution {
public:
    int climbStairs(int n) {
        int mem[n+1];
        memset(mem, 0, sizeof(mem));  //将数组初始化为0
        return climb_Stairs(0, n, mem);
    }
    int climb_Stairs(int i, int n, int mem[]){
        if(i>n) return 0;
        if(i==n) return 1;
        if(mem[i]>0) return mem[i];
        mem[i] = climb_Stairs(i+1, n, mem) + climb_Stairs(i+2, n, mem);
        return mem[i];
    }
};

方法三
动态规划/斐波那契数:
第i阶的解可以由子问题:
(1) 第i-1阶的解,向后爬一阶;
(2) 第i-2阶的解,向后爬两阶;
的和得到。
时间复杂度O(n),空间复杂度O(1).

class Solution {
public:
    int climbStairs(int n) {
        if(n==1) return 1;
        if(n==2) return 2;
        int a = 1, b =2;   //保存n为1、2的值
        int i = 3;         //n从3开始
        int count = 0;     //最终的返回值
        while(i <= n ){
            count = a + b;
            a = b;
            b = count;
            ++i;
        }
        return count;
    }
};
### PTA平台上爬楼梯问题的扩展与解法 PTA平台上的爬楼梯问题是经典动态规划问题的一个变体,通常会增加一些额外条件或者改变规则。以下是针对此类问题的一些常见扩展及其解决方案。 #### 扩展一:每次可以上任意数量的台阶 如果允许一次上 `k` 个台阶(其中 `k` 是一个小于等于某个固定值的最大步数),则状态转移方程变为: \[ f(n) = \sum_{i=1}^{k} f(n-i),\quad (n > k)\] 对于 \( n \leq k \),可以直接计算可能的方法总数。例如,当最大步数为3时, ```python def climb_stairs_k_steps(n, max_step): if n == 0: return 1 dp = [0] * (n + 1) dp[0] = 1 for i in range(1, n + 1): for step in range(1, min(max_step, i) + 1): dp[i] += dp[i - step] return dp[n] ``` 此算法的时间复杂度为 \( O(n \cdot k) \)[^2]。 #### 扩展二:带有障碍物的爬楼梯问题 如果有某些特定位置存在障碍物,则无法通过这些位置。此时需要调整状态转移逻辑,在遇到障碍物的位置将其方法数设为零。 ```python def climb_stairs_with_obstacles(n, obstacles): dp = [0] * (n + 1) dp[0] = 1 for i in range(1, n + 1): if i in obstacles: dp[i] = 0 elif i >= 2: dp[i] = dp[i - 1] + dp[i - 2] else: dp[i] = dp[i - 1] return dp[n] ``` 上述代码中,`obstacles` 表示包含所有障碍物索引的集合[^3]。 #### 扩展三:带权值的路径计数 假如每一步都有一个权重,并希望求得总权重最小或最大的路径数目。这可以通过引入辅助数组存储当前最优路径对应的累积权重实现。 ```python def weighted_climb_stairs(n, weights): dp_count = [0] * (n + 1) dp_weight = [float('inf')] * (n + 1) dp_count[0], dp_weight[0] = 1, 0 for i in range(1, n + 1): for j in [1, 2]: if i - j >= 0 and dp_weight[i - j] + weights[i - 1] < dp_weight[i]: dp_weight[i] = dp_weight[i - j] + weights[i - 1] dp_count[i] = dp_count[i - j] elif i - j >= 0 and dp_weight[i - j] + weights[i - 1] == dp_weight[i]: dp_count[i] += dp_count[i - j] return dp_count[-1], dp_weight[-1] ``` 这里 `weights` 数组表示每个台阶的权重[^4]。 ### 总结 无论是基础版还是各种复杂的变形版本,“爬楼梯”类题目都可以归结为一种形式化的动态规划模型。理解其核心原理并灵活运用是解决这类问题的关键所在。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值