leetCode-70: 爬楼梯

文丑颜不良啊

已于 2022-05-17 18:42:08 修改

阅读量137

点赞数

分类专栏： # LeetCode之简单题库文章标签： leetcode 斐波那契数列 LeetCode之爬楼梯动态规划

于 2021-09-27 15:05:35 首次发布

本文链接：https://blog.csdn.net/jiaomubai/article/details/120508920

版权

LeetCode之简单题库专栏收录该内容

29 篇文章 2 订阅

订阅专栏

该博客讨论了如何使用动态规划、递归和备忘录算法解决爬楼梯问题，其中涉及斐波那契数列的概念。文章通过三种不同的方法展示了如何在限制步数为1或2的情况下计算到达楼梯顶部的不同路径数量，并分析了各种方法的时间和空间复杂度。动态规划的迭代方法在效率上优于递归方法。

摘要由CSDN通过智能技术生成

题目描述：

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

示例：

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

解题方法：简单一看，此题便是典型的斐波那契数列，即当 n >= 3 时，f(n) = f(n - 1) + f(n - 2)。从最开始的递归算法开始，逐步优化，产生了备忘录算法和动态规划算法，代码如下：

public class ClimbStairs {

    // 迭代(动态规划)
    public static int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }
        int temp1 = 1;
        int temp2 = 2;
        for (int i = 3; i <= n; i++) {
            int result = temp1 + temp2;
            temp1 = temp2;
            temp2 = result;
        }
        return temp2;
    }

    // 递归
    public static int climbStairs2(int n) {
        if (n == 1 || n == 2) {
            return n;
        } else {
            return climbStairs2(n - 1) + climbStairs2(n - 2);
        }
    }

    // 备忘录
    public static int climbStairs3(int n, HashMap<Integer, Integer> map) {
        if (n <= 2) {
            return n;
        }
        if (map.containsKey(n)) {
            return map.get(n);
        } else {
            Integer value = climbStairs3(n -1, map) + climbStairs3(n -2, map);
            map.put(n, value);
            return value;
        }
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        int result = climbStairs3(10, new HashMap<>());
        System.out.println("result = " + result);
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
    }

}

climbStatrs2() 方法为递归方法，时间复杂度为 $O(2^{n})$ ，这种方法在对时间有要求的情况下很容易超时，climbStatrs3() 方法为递归方法的优化版本，时间复杂度为 $O(2^{n})$ ，空间复杂度为 $O(2^{n})$ ，climbStatrs() 方法为动态规划的迭代方法，即最终的时间复杂度为 $O(n)$ ，空间复杂度为 $O(1)$ 的方法。