算法45：动态规划专练(力扣70: 爬楼梯力扣746：使用最小花费爬楼梯)

适合java程序员的算法

于 2024-03-05 16:24:52 发布

阅读量1k

点赞数 26

分类专栏：算法文章标签：算法动态规划 leetcode

本文链接：https://blog.csdn.net/chen_yao_kerr/article/details/136478788

版权

算法专栏收录该内容

55 篇文章 1 订阅

订阅专栏

力扣70题：爬楼梯

假设你正在爬楼梯。需要 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. 如果有1个楼梯，那只能走1步登顶。 1中方法

2. 如果有2个楼梯。

a. 我们可以一次走一步登顶。

b. 也可以一次走2步，登顶。

累计就是2种方法。

3. 如果有3个楼梯：

a. 从楼底一步一步走上来

b. 从楼底先走1步，再一次走2步上来

c. 从楼底先一次走2步，再走1步上来

累计就是3种方法。

状态转移分析：

分析1：步骤a是一步一步走上来的，也就是说要想走到3阶楼梯，前一次是从2阶楼梯上来的.

分析2：步骤c是先从楼底一次走2步，然后一次走一步。也还是从2阶楼梯走上来的

也就是说步骤a和步骤c，都依赖2阶楼梯的走法。而我们上面分析过了，从楼底走到2阶楼梯有 2 种方法.

分析3：步骤b先从楼底走一步，最后一次走2步登顶。也就是说想要走到3阶楼梯，也可以从1 阶楼梯直接一次走2步直接登顶。依赖1阶楼梯

按照这种思路: 从楼底走到1阶楼梯有1种方法，从楼底走到2阶楼梯有2中方法。而3阶楼梯依赖 1阶楼梯和2阶楼梯。本体是要求一共多少种走法，那就是1阶楼梯和2阶楼梯的累加和。

得到公式： F(n) = F(n-1) + F(n-2). n > 2.

递归代码：

   public int climbStairs(int n)
    {
        if (n <= 1) {
            return n == 1 ? 1 : 0;
        }

        if (n == 2) {
            return 2;
        }

        return climbStairs(n-1) + climbStairs(n-2);
    }

之前我已经写过很多篇介绍如何把递归改为动态规划的博客了。这一题比较简单，我再介绍一次。我们根据题目可以知道 n > 2. 那我假设 n== 4，那么推导过程：

第一步：

开始位置	1阶段楼梯	2阶段楼梯	3阶段楼梯	4阶段楼梯
楼底	根据 n<=1, 得到1	根据 n = 2 得到2

去掉推导过程，那结果就是：

开始位置	1阶段楼梯	2阶段楼梯	3阶段楼梯	4阶段楼梯
楼底	1	2

第二步：

根据 climbStairs(n-1) + climbStairs(n-2) 可以把后面的结果都给推出来：

开始位置	1阶段楼梯	2阶段楼梯	3阶段楼梯	4阶段楼梯
楼底	1	2	3	5

由此可以知道，动态规划使用1维数组即可：

 //时间复杂度 O(n)
    public int climbStairs2(int n){
        
        //只有1阶楼梯
        if (n <= 1) {
            return n == 1 ? 1 : 0;
        }

        //2阶楼梯
        if (n == 2) {
            return 2;
        }
        
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }

        return dp[n];
    }

力扣746：使用最小花费爬楼梯

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

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

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

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

分析：

a. 这一题求的是最小花费，跟出发位置有关以及数组长度有关。以 [10,15,20]为例，数组长度为3，登顶的意思就是不是说到达数组最后一个下标，而是要把最后一个下标也给走完。

我们把爬楼梯理解成爬楼层，可能会更好懂一些。

假设一共有6层楼，登顶肯定是把6楼的楼梯也给走完才行。而数组的最后一个元素，只是代表 6楼到楼顶的所花费的代价。

b. 如果数组为空，那就直接返回0;

c. 如果数组为1，直接返回数组的唯一值

d. 如果数组长度为2. 也就是说有2层楼。你要想到达楼顶，选取数组2个元素中较小的。

假设数组为 [10,15]. 到达楼顶：

如果你从楼底出发，一次走两层直接登顶。花费的代价就是10

如果你从1楼出发，一次走一层直接登顶。花费的代价就是15.

最终花费的代价就是10。

e：3个楼梯，假设数组 [10,15,20]。到顶的意思，就是把楼梯走完，也就是数组的长度为3.

而数组10， 15， 20 代表的是从楼底到1层从1层到2层，从2层到3层的花费。

如果登顶, 那只能是从2层或者3层出发的。需要计算出到达2层花费的最小累加和，与到达3层的最小累加和。两者相比取小值。

package code04.动态规划专项训练01;

/**
 * 力扣746题
 * https://leetcode.cn/problems/min-cost-climbing-stairs/description/?envType=study-plan-v2&envId=dynamic-programming
 */
public class MinCostClimbingStairs_04 {

    public int minCostClimbingStairs(int[] cost) {
        //没有台阶
        if (cost == null || cost.length == 0) {
            return 0;
        }

        //只有1个台阶，只能从下标为0处开始爬
        if (cost.length == 1) {
            return cost[0];
        }

        //只有2个台阶，取小
        if (cost.length == 2) {
            return Math.min(cost[0], cost[1]);
        }

        int[] dp = new int[cost.length + 1];
        dp[0] = 0;
        dp[1] = 0;
        int size = cost.length;
        for (int i = 2; i <= size; i++) {
            //需要计算 i-1 号楼梯经过1步走上来的代价  和 i - 2 号楼梯
            //直接跨越2个楼梯走上来的代价
            //这一题的其妙之处就是第i号楼梯的代价是要在 i + 1 和 i + 2楼梯的时候
            //才会计算。如果没有这两个楼梯，就不需要考虑i号楼梯的代价了。比如:
            //[10,15,20]. 只需要花费15就可以爬完楼梯
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i-2] + cost[i-2]);
        }

        return dp[size];
    }

    public static void main(String[] args) {
        MinCostClimbingStairs_04 ss = new MinCostClimbingStairs_04();
        int[] arr = {10, 15, 20};
        int[] arr2= {1,100,1,1,1,100,1,1,100,1};
        System.out.println(ss.minCostClimbingStairs(arr2));
    }
}