LeetCode 算法：爬楼梯 c++

• 原题链接🔗：爬楼梯
• 难度：简单⭐️

题目

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

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

题解

1. 解题思路：

LeetCode 上的 “爬楼梯” 问题是一个经典的动态规划问题，通常有两种解法：递归和动态规划。

1. 递归方法
   递归方法基于这样一个事实：到达第 i 阶楼梯的方法数是到达第 i-1 阶和第 i-2 阶楼梯的方法数之和。这是因为，要到达第 i 阶，你最后一步要么是从第 i-1 阶上来的，要么是从第 i-2 阶上来的。
   递归的伪代码如下：
   function climbStairs(n):
   if n == 1:
   return 1
   if n == 2:
   return 2
   return climbStairs(n - 1) + climbStairs(n - 2)

2. 动态规划方法
   动态规划方法是对递归方法的优化，避免了重复计算相同的子问题。我们使用一个数组 dp 来存储到达每一阶楼梯的方法数，其中 dp[i] 表示到达第 i 阶的方法数。
   动态规划的伪代码如下：
   function climbStairs(n):
   if n == 1:
   return 1
   dp = new int[n + 1]
   dp[1] = 1
   dp[2] = 2
   for i from 3 to n:
   dp[i] = dp[i - 1] + dp[i - 2]
   return dp[n]

3. 空间优化的动态规划
   由于 dp[i] 只依赖于 dp[i - 1] 和 dp[i - 2]，我们不需要存储整个数组，只需要两个变量来存储这两个状态即可，从而将空间复杂度降低到 O(1)。
   空间优化的动态规划伪代码如下：
   function climbStairs(n):
   if n == 1:
   return 1
   a, b = 1, 2
   for i from 3 to n:
   temp = a + b
   a = b
   b = temp
   return b

4. 总结

• 递归方法直观但效率低，因为它有很多重复计算。
• 动态规划方法通过存储中间结果避免了重复计算，提高了效率。
• 空间优化的动态规划进一步减少了空间的使用，使得算法更加高效。

2. c++ demo：

#include <iostream>
#include <vector>

class Solution {
public:
    // 递归方法
    int climbStairsRecursive(int n) {
        if (n <= 2) return n;
        return climbStairsRecursive(n - 1) + climbStairsRecursive(n - 2);
    }

    // 动态规划方法
    int climbStairsDP(int n) {
        std::vector<int> dp(n + 1);
        if (n <= 2) return n;
        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 climbStairsOptimized(int n) {
        if (n == 1) return 1;
        int a = 1, b = 2, temp;
        for (int i = 3; i <= n; ++i) {
            temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }
};

int main() {
    Solution solution;
    int n = 5; // 测试爬5阶楼梯

    // 测试递归方法
    std::cout << "Using Recursive Method: " << solution.climbStairsRecursive(n) << std::endl;

    // 测试动态规划方法
    std::cout << "Using DP Method: " << solution.climbStairsDP(n) << std::endl;

    // 测试空间优化的动态规划方法
    std::cout << "Using Optimized DP Method: " << solution.climbStairsOptimized(n) << std::endl;

    return 0;
}

• 输出结果：

Using Recursive Method: 8
Using DP Method: 8
Using Optimized DP Method: 8

3. 代码仓库地址：climbStairs