LeetCode_70_Climbing Stairs_爬楼梯

最新推荐文章于 2024-11-11 16:05:06 发布

原创最新推荐文章于 2024-11-11 16:05:06 发布 · 189 阅读

0 ·

CC 4.0 BY-SA版权

编程题专栏收录该内容

253 篇文章

订阅专栏

博客围绕爬楼梯问题展开，给出了三种算法。记忆化递归通过存储每步结果减少递归树大小；动态规划利用第 i 阶与 (i - 1) 阶、(i - 2) 阶方法数的关系求解；还可使用斐波那契数列。此外，还提及了进阶的变态爬楼梯问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

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

算法一：记忆化递归
在暴力法中，我们将会把所有可能爬的阶数进行组合，也就是 1 和 2 。而在每一步中我们都会继续调用 climbStairs 这个函数模拟爬 1 阶和 2 阶的情形，并返回两个函数的返回值之和。
climbStairs(i,n)=(i + 1, n) + climbStairs(i + 2, n)
climbStairs(i,n)=(i+1,n)+climbStairs(i+2,n)
其中 i定义了当前阶数，而 n 定义了目标阶数。
我们可以把每一步的结果存储在 stair数组之中，每当函数再次被调用，我们就直接从 stair 数组返回结果。
在 stair 数组的帮助下，我们得到了一个修复的递归树，其大小减少到 n。

class Solution {
public:
    int climb_stair(int i,int n,int *stair){
        if(i>n)
            return 0;
        if(i==n)
            return 1;
        if(stair[i]!=-1)
            return stair[i];
        stair[i]=climb_stair(i+1,n,stair)+climb_stair(i+2,n,stair);
        return stair[i];
    }
    int climbStairs(int n) {
        int stair[n];
        fill(stair,stair+n,-1);//初始化stair数组
        return climb_stair(0,n,stair);
    }
};

在这里插入图片描述
方法二：动态规划
第 i 阶可以由以下两种方法得到：
在第 (i-1) 阶后向上爬一阶。
在第 (i-2) 阶后向上爬 2 阶。
所以到达第 ii 阶的方法总数就是到第 (i−1) 阶和第 (i−2) 阶的方法数之和。
令 dp[i] 表示能到达第 ii 阶的方法总数：
dp[i]=dp[i-1]+dp[i-2]
dp[i]=dp[i−1]+dp[i−2]

int climbStairs(int n){
        if(n==1)//先进行判断，n是否是1阶
            return 1;
        int dp[n+1];
        memset(dp,0,sizeof(dp));
        dp[1]=1;
        dp[2]=2;
        if(n==1)
            return dp[1];
        if(n==2)
            return dp[2];
        for(int i=3;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }

在这里插入图片描述
方法三：使用斐波那契数列
我们使用 dpdp 数组，其中 dp[i]=dp[i-1]+dp[i-2]。可以很容易通过分析得出 dp[i] 其实就是第 ii 个斐波那契数。
Fib(n)=Fib(n-1)+Fib(n-2)
现在我们必须找出以 1 和 2 作为第一项和第二项的斐波那契数列中的第 n 个数，也就是说 Fib(1)=1 且 Fib(2)=2

int climbStairs(int n){
        if(n==1)
            return 1;
        int one=1;
        int two=2;
        for(int i=3;i<=n;i++){
            int three=one+two;
            one=two;
            two=three;
        }
        return two;
    }

在这里插入图片描述
进阶：变态爬楼梯一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法

class Solution {
public:
    int jumpFloorII(int number) {
        if(number==1)
            return 1;
        if(number==2)
            return 2;
        vector<int> solu(number+1,0);
        solu[1]=1;
        solu[2]=2;
        return helper(solu,number);
    }
    //思路：solu[n]=solu[n-1]+solu[n-1]+...+solu[1]+1
    int helper(vector<int>& solu,int number){
        if(solu[number]!=0)
            return solu[number];
        for(int i=3;i<=number;i++){
            for(int j=1;j<i;j++)
                solu[i]+=solu[j];
            solu[i]+=1;
        }
        return solu[number];
    }
};