【力扣LeetCode】java算法刷题大全第1题之爬楼梯

这篇博客介绍了如何用Java解决LeetCode的第一题——爬楼梯问题,该问题与斐波那契数列有紧密联系。通过代码实现,博主展示了如何计算走n层楼梯的不同走法,同时输出了斐波那契数列的前n项。

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

一、爬楼梯走法OR斐波那契数列

(1)给定一个n层的阶梯,一个人爬楼梯,每次走1步,或者2步,总共多少走法

(2)输出斐波那契数列前n位数

package com.example.dzx.datastrctet;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 500007
 * @ClassName:
 * @Description: 1.爬楼梯,每次走1步,或者2步,总共多少走法
 * @Description: 2.斐波那契数列
 * @date 2022年04月22日 11:10:59
 */

public class Solution {
    private Map<Integer, Integer> integerIntegerMap = new HashMap<Integer, Integer>();

    /**
     * 递归
     * @param n
     * @return
     */
    public int climbStairs1(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        return climbStairs1(n - 1) + climbStairs1(n - 2);

    }

    /**
     * 带有map缓存的递归(防止重复计算)
     * @param n
     * @return
     */
    public int climbStairs2(int n) {
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        if (integerIntegerMap.get(n) != null) {
            return integerIntegerMap.get(n);
        } else {
            int res = climbStairs2(n - 1) + climbStairs2(n - 2);
            integerIntegerMap.put(n, res);
            return res;
        }
    }

    /**
     * for循环输出法
     * @param n
     * @return
     */
    public int climbStairs3(int n) {
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        int prepre = 1;
        int pre = 2;
        int res = 0;
        for (int i = 3; i <= n; i++) {
            //当前数=前前数+前数
            res = prepre + pre;
            //前数赋值给前前数
            prepre = pre;
            //当前数复制给前数
            pre = res;
        }
        return res;
    }

    // 1 2 3 5 8 13 21
    public static void main(String[] args) {
        int res1 = new Solution().climbStairs1(7);
        System.out.println(res1);

        int res2 = new Solution().climbStairs2(7);
        System.out.println(res2);

        int res3 = new Solution().climbStairs3(7);
        System.out.println(res3);
    }
}

运行代码,输出如下:

<think>好的,我现在需要帮助用户解决LeetCode爬楼梯Java实现。首先,用户明确要求用Java,所以我要确保提供的代码示例是Java的。根据用户提供的引用,有几个不同的解决方案,包括递归、动态规划和迭代法。 首先,我要回忆一下爬楼梯的基本情况。目是每次可以爬1或2个台阶,问到达n阶有多少种方法。这其实是一个斐波那契数列问,因为到达第n阶的方法数等于到达n-1阶和n-2阶方法数的和。 用户提供的引用中有几个代码示例。引用2和3提到了递归方法,但指出递归效率低,因为会有大量重复计算,比如climbStairs(n)会重复计算climbStairs(n-1)和climbStairs(n-2)。引用4和5则给出了动态规划和迭代的方法,这两种方法的时间复杂度都是O(n),空间复杂度较低。 接下来,我需要分析各个方法的优缺点。递归虽然简单,但时间复杂度是指数级的,不适合大n。动态规划通过数组存储中间结果,空间复杂度O(n),但可以优化到O(1)使用滚动变量,如引用4中的迭代法。引用5中的动态规划使用数组,而引用4的迭代法只用三个变量,节省空间。 用户可能希望得到一个高效且易懂的解法,所以应该推荐动态规划或迭代法。同时,需要解释清楚思路,比如状态转移方程f(n) = f(n-1) + f(n-2),以及如何初始化。 还要注意边界条件,比如n=1或n=2的情况,避免数组越界。例如,在引用5中,数组初始化是f[0]=1和f[1]=1,这样循环从i=2开始计算到n。而引用4中处理n=1时直接返回1,循环从i=2开始。 另外,可能需要提到进一步优化的方法,比如矩阵快速幂或公式法,将时间复杂度降到O(log n)或O(1),但这些可能超出用户当前需求,可以作为扩展知识。 最后,确保代码示例正确无误,并且符合Java语法。比如引用4中的迭代法使用了三个变量first、second、third,并在循环中更新它们的值,最终返回third。引用5的动态规划版本则使用数组存储每个阶梯的方法数。 总结步骤: 1. 介绍问本质是斐波那契数列。 2. 分析递归方法的缺点。 3. 提供动态规划解法,解释空间优化。 4. 给出迭代法的代码,并解释变量滚动更新。 5. 讨论时间复杂度和空间复杂度。 6. 可能提到其他优化方法,但以主要解法为主。 需要确保回答结构清晰,分步骤说明,代码正确,并且引用正确的参考文献,比如引用4和5的动态规划和迭代法。同时,回答用户的问时,要覆盖不同的实现方法,让用户可以根据需要选择。</think>### LeetCode 70. 爬楼梯 Java 解法详解 #### 问分析 目要求计算爬到第$n$阶楼梯的不同方法数,每次可以爬1或2个台阶。**这本质是斐波那契数列问**,因为: - 到达第$n$阶的方法数 = 到达第$(n-1)$阶的方法数(最后一步爬1阶) + 到达第$(n-2)$阶的方法数(最后一步爬2阶) #### 方法一:递归(不推荐,仅用于理解) 递归方法直接根据定义实现,但存在重复计算,时间复杂度为$O(2^n)$,空间复杂度$O(n)$(栈深度): ```java class Solution { public int climbStairs(int n) { if (n == 1) return 1; if (n == 2) return 2; return climbStairs(n - 1) + climbStairs(n - 2); } } ``` **缺点**:输入较大时(如$n=45$)会超时[^2]。 --- #### 方法二:动态规划(推荐) 通过数组存储中间结果,时间复杂度$O(n)$,空间复杂度$O(n)$: ```java class Solution { public int climbStairs(int n) { if (n <= 1) return 1; int[] dp = new int[n + 1]; dp[0] = 1; dp[1] = 1; for (int i = 2; i <= n; i++) { dp[i] = dp[i - 1] + dp[i - 2]; } return dp[n]; } } ``` **优化**:用滚动变量代替数组,空间复杂度降为$O(1)$[^4]: ```java class Solution { public int climbStairs(int n) { if (n == 1) return 1; int first = 1, second = 1, third = 0; for (int i = 2; i <= n; i++) { third = first + second; first = second; second = third; } return third; } } ``` --- #### 复杂度对比 | 方法 | 时间复杂度 | 空间复杂度 | |------------|------------|------------| | 递归 | $O(2^n)$ | $O(n)$ | | 动态规划 | $O(n)$ | $O(n)$ | | 滚动变量 | $O(n)$ | $O(1)$ | --- #### 进阶方法(扩展知识) 1. **矩阵快速幂**:时间复杂度$O(\log n)$,利用矩阵乘法性质加速计算。 2. **斐波那契公式**:直接通过通项公式计算,时间复杂度$O(1)$,但涉及浮点数精度问。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小米吃辣椒2022

你的鼓励将是我创作的最大动力!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值