算法：爬楼梯

爬楼梯

假设你正在爬楼梯。需要 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

题解：

递归方法基于这样一个事实：到达第 i 阶楼梯的方法数是到达第 i-1 阶和第 i-2 阶楼梯的方法数之和。这是因为，要到达第 i 阶，你最后一步要么是从第 i-1 阶上来的，要么是从第 i-2 阶上来的。

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

2.JavaScript代码

    // 递归方法
    function climbStairsRecursive(int n) {
        if (n <= 2) return n;
        return climbStairsRecursive(n - 1) + climbStairsRecursive(n - 2);
    }
    
    // 动态规划方法
    function climbStairsDP(int n) {
        let dp = Array(n + 1).fill(0)
        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];
    }
    // 空间优化的动态规划方法
    var climbStairs = function (n) {
    let a = 1, b = 2, temp = 0;
    if (n <= 2) return n;
    for (let i = 3; i <= n; i++) {
        temp = a + b;
        a = b;
        b = temp;
    }
    return b;
};