爬楼梯

爬楼梯

1.问题描述

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

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

示例 1：

1
2
3
4
5
输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

1
2
3
4
5
6
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

  • 1 <= n <= 45

2.暴力解法: 递归

2.1代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <vector>

using namespace std;
class Solution {
public:
    int climbStairs(int n) {
        if(n==1){
            return 1;
        }
        if (n==2){
            return 2;
        }
        vector<int>dp(n+1,0);
        dp[1]=1,dp[2]=2;
        return climbStairs(n-1)+ climbStairs(n-2);
    }
};
int main() {
    Solution s;
    cout<<s.climbStairs(35)<<endl;
    return 0;
}

2.2缺点

递归方法会导致****大量的重复计算，这会使程序在处理较大的 n 时变得非常慢，并且空间复杂度极高。

3.动态规划

3.1代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <vector>

using namespace std;
class Solution {
public:
    int climbStairs(int n) {
        if(n==1){
            return 1;
        }
        if (n==2){
            return 2;
        }
        vector<int>dp(n+1,0);
        dp[1]=1,dp[2]=2;
        for (int i = 3; i <=n ; ++i) {
            dp[i]=dp[i-1]+dp[i-2]; // 动态规划的核心步骤 状态转移方程
        }
        return dp[n];
    }
};
int main() {
    Solution s;
    cout<<s.climbStairs(5)<<endl;
    return 0;
}

3.2解释

  1. 动态规划数组：dp[i] 表示爬到第 i 级台阶的方法数。
  2. 初始化：dp[1] = 1 和 dp[2] = 2，因为爬到第1级台阶有1种方法（直接爬），爬到第2级台阶有2种方法（一次爬1级或两次都爬1级）。
  3. 状态转移方程：对于 i > 2，dp[i] = dp[i - 1] + dp[i - 2]，表示到达第 i 级台阶的方法数等于到达第 i-1 级台阶的方法数加上到达第 i-2 级台阶的方法数。
  4. 结果：最后返回 dp[n]，即爬到第 n 级台阶的方法数。

这样，你的代码就通过动态规划避免了重复计算，提高了效率。