509.斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯

509.斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯

509.斐波那契数

力扣题目链接(opens new window)

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给你n ，请计算 F(n) 。

示例 1：

• 输入：2
• 输出：1
• 解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

• 输入：3
• 输出：2
• 解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

• 输入：4
• 输出：3
• 解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

• 0 <= n <= 30

思路:动态规划

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。
所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的
本题作为动态规划入门题，难度简单，不使用动态规划也可以做出来，但这里为了掌握动态规划的方法论
动态规划方法论分为如下五个部分
1.确认dp数组，以及下标所表示的含义
2.确认递推公式
3.dp数组如何初始化
4.确认遍历顺序
5.举例推导dp数组
那么接下来按照动态规划方法论来解题
1.确认dp数组，以及下标所表示的含义
dp数组使用一维数组dp[i]即可，下标i表示第i个斐波那契数
2.确认递推公式
题目已经给出递推公式 dp[i] = dp[i-1] + dp[i-2]
3.dp数组如何初始化
题目已经给出 dp[0] = 0,dp[1] = 1
4.确认遍历顺序
因为递推公式为dp[i] = dp[i-1] + dp[i-2],所以要从小的数字遍历到大的数字,那么遍历的顺序一定是从前到后
5.举例推导dp数组
按照递推公式来推导dp[i] = dp[i-1] + dp[i-2]。当N为10的时候，dp数组应该是如下的数列：0 1 1 2 3 5 8 13 21 34 55
如果代码写出来发现结果不对，那么打印代码中的dp数组。和我们推导出的dp数组作比较是不是一致的
时间复杂度o(n)
空间复杂度o(n)

代码如下

int fib(int N) {
    if (N == 0)
        return 0;

    int[] dp = new int[N + 1];// dp数组使用一维数组dp[i]即可，下标i表示第i个斐波那契数
    dp[0] = 0;
    dp[1] = 1;
    for (int i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[N];
}

思路:递归法

思路：递归法
递归法的思路并不难
但在时间复杂度和空间复杂度的计算上,我忘记怎么计算了
这里想着重介绍递归的时间复杂度和空间复杂度
时间复杂度o(2^n)
空间复杂度o(n) 算上了编程语言中实现递归的系统栈所占空间
画树形图计算时间和空间复杂度
假如n = 5,那么树形图如下：

可以看出树形图高度等于n,那么意味着递归深度等于n，所以空间复杂度o(n)
时间复杂度跟树形图的节点有关系。节点数量等于2^0 + 2^1 + 2^2 + …2^n-2 - 2 + 2
计算后值为2^n-1 - 1 常数项可以约去，那么时间复杂度为o(2^n)

代码如下

int fib(int N) {
    return fib1(N);
}

int fib1(int N) {
    if (N == 0)
        return 0;
    if (N == 1)
        return 1;
    return fib1(N - 1) + fib(N - 2);
}

70. 爬楼梯

力扣题目链接(opens new window)

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

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

注意：给定 n 是一个正整数。

示例 1：

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

示例 2：

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

思路:动态规划

思路：动态规划
动态规划的每一个状态是由上一个状态推导出来的
爬第一层楼梯有一种状态
爬第二层楼梯有两种状态
爬第三层楼梯的状态可以由第一层和第二层楼梯的状态推导出来,就可使用动态规划
动规五部曲
1.确认dp数组以及下标的含义
定义一维数组来表示不同楼梯的状态，表示第i层楼梯有dp[i]种方法
2.确认递推公式
当爬到第i-1层楼梯时有dp[i-1]种方法。再爬一阶楼梯即可
当爬到第i-2层楼梯时有dp[i-2]种方法。再爬两阶楼梯即可。这里为什么不连续爬两个一阶楼梯呢？因为会和dp[i-1]的场景重复了
所以爬到第i层楼梯时有dp[i] = dp[i-1] + dp[i-2].
3.dp数组初始化
dp[0] = 0,dp[1] = 1,dp[2] = 2
4.确认遍历顺序
dp[i] = dp[i-1] + dp[i-2] 遍历顺序从前向后遍历
5.举例推导dp数组
当n = 5时
dp[3] = dp[2] + dp[1] = 3
dp[4] = dp[3] + dp[2] = 5
dp[5] = dp[4] + dp[3] = 8
时间复杂度o(n)
空间复杂度o(n)

代码如下

public int climbStairs(int n) {
    int[] dp = new int[n + 1];
    if (n < 3)
        return n;
    dp[1] = 1;
    dp[2] = 2;

    for (int i = 3; i <= n; i++){
        dp[i] = dp[i-1] + dp[i-2];
        System.out.println(dp[i]);
    }
    return dp[n];
}

思路:动态规划（空间复杂度优化）

可以简化dp数组的大小，定义常数大小即可
不需要保存0~n所有的结果，只需要获取i = n时结果即可
但上一种代码看起来更加清晰，建议写出该版本代码就足够了
如果面试官有要求降低空间复杂度，建议使用这种方式
时间复杂度o(n)
空间复杂度o(1)

代码如下

public int climbStairs(int n) {
    int[] dp = new int[3];
    if (n < 3)
        return n;
    dp[1] = 1;
    dp[2] = 2;

    int sum = 0;
    for (int i = 3; i <= n; i++){
        sum = dp[1] + dp[2];
        dp[1] = dp[2];
        dp[2] = sum;
    }
    return sum;
}

746. 使用最小花费爬楼梯

力扣题目链接

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

思路:动态规划

动态规划五部曲
1.确认dp数组以及下标i的含义
dp[i]:走到第i个台阶花费的最少体力
2.确认递推公式
dp[i] = dp[i-1] + cost[i-1];
dp[i] = dp[i-2] + cost[i-2];
题目要求使用最小花费爬楼梯
所以dp[i] = Math.min(dp[i-1] + cost[i-1],dp[i-2] + cost[i-2])
3.初始化dp数组
根据题意可以选择下标为 0 或下标为 1 的台阶开始爬楼梯。
dp[1] = 0;
dp[0] = 0;
4.确认遍历顺序
dp[i] = Math.min(dp[i-1] + cost[i-1],dp[i-2] + cost[i-2]) 遍历顺序从前向后遍历
5.举例推导dp数组
dp[2] = Math.min(dp[1] + cost[1],dp[0] + cost[0])
时间复杂度：O(n)
空间复杂度：O(n)

代码如下

public int minCostClimbingStairs(int[] cost) {
    if (cost == null || cost.length == 0)// 边缘条件判断
        return 0;
    int length = cost.length;
    if (length < 2)
        return 0;

    int[] dp = new int[length + 1];
    dp[0] = 0;
    dp[1] = 0;

    for (int i = 2; i <= length; i++) {
        dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
    }
    return dp[length];

}