动态规划lc题

动态规划

746. 使用最小花费爬楼梯

难度简单

数组的每个索引作为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始)。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。

示例 2:

输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释: 最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。

注意：

1. cost 的长度将会在 [2, 1000]。
2. 每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。

分析:

确定状态: f[i]表示爬上第i个阶梯的最低花费

f[i] = min(f[i-1]+cost[i-1],f[i-2]+cost[i-2])

初始状态: f[0] = f[1] = 0

class Solution {
   
    public int minCostClimbingStairs(int[] cost) {
   
        int n = cost.length;
        int f1 =0, f2 = 0;
        for (int i = 2; i <= n; i++) {
   
            int temp = f1;
            f1 = Math.min(f1+ cost[i - 1], f2 + cost[i - 2]);
            f2 = temp;
        }
        return f1;
    }
}

1696. 跳跃游戏 VI

难度中等

给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。

一开始你在下标 0 处。每一步，你最多可以往前跳 k 步，但你不能跳出数组的边界。也就是说，你可以从下标 i 跳到 [i + 1， min(n - 1, i + k)] 包含 两个端点的任意位置。

你的目标是到达数组最后一个位置（下标为 n - 1 ），你的 得分 为经过的所有数字之和。

请你返回你能得到的 最大得分 。

示例 1：

输入：nums = [1,-1,-2,4,-7,3], k = 2
输出：7
解释：你可以选择子序列 [1,-1,4,3] （上面加粗的数字），和为 7 。

示例 2：

输入：nums = [10,-5,-2,4,0,3], k = 3
输出：17
解释：你可以选择子序列 [10,4,3] （上面加粗数字），和为 17 。

示例 3：

输入：nums = [1,-5,-20,4,-1,3,-6,-3], k = 2
输出：0

提示：

• 1 <= nums.length, k <= 105
• -104 <= nums[i] <= 104

解题

class Solution {
   
    public int maxResult(int[] nums, int k) {
   
        // 使用单调队列+动态规划
        // 确定状态：f[i]表示到达i的最大得分
        // 转移方程：f[i] = max(f[j]) + nums[i] , i - k <= j <= i-1
        // 可以使用单调队列维护max(f[j]),队列里存的是下标
        int n = nums.length;
        int[] f = new int[n];
        f[0] = nums[0];
        Deque<Integer> deque = new LinkedList<>();
        deque.addLast(0);
        for(int i = 1; i < n; i ++){
   
            // 如果下标过期了，直接删除
            while(deque.getFirst() < i - k){
   
                deque.removeFirst();
            }
            f[i] = f[deque.getFirst()] + nums[i];
            // 单调队列，维护一个递减队列，也就是 头 > 尾
            // 注意这里维护的 f[] 数组大小关系
            while(!deque.isEmpty() && f[deque.getLast()] <= f[i]){
   
                deque.removeLast();
            }
            deque.addLast(i);
        }
        return f[n-1];
    }
}

5728. 最少侧跳次数

难度中等5

给你一个长度为 n 的 3 跑道道路 ，它总共包含 n + 1 个 点 ，编号为 0 到 n 。一只青蛙从 0 号点第二条跑道 出发 ，它想要跳到点 n 处。然而道路上可能有一些障碍。

给你一个长度为 n + 1 的数组 obstacles ，其中 obstacles[i] （取值范围从 0 到 3）表示在点 i 处的 obstacles[i] 跑道上有一个障碍。如果 obstacles[i] == 0 ，那么点 i 处没有障碍。任何一个点的三条跑道中 最多有一个 障碍。

• 比方说，如果 obstacles[2] == 1 ，那么说明在点 2 处跑道 1 有障碍。

这只青蛙从点 i 跳到点 i + 1 且跑道不变的前提是点 i + 1 的同一跑道上没有障碍。为了躲避障碍，这只青蛙也可以在 同一个 点处 侧跳 到 另外一条 跑道（这两条跑道可以不相邻），但前提是跳过去的跑道该点处没有障碍。

• 比方说，这只青蛙可以从点 3 处的跑道 3 跳到点 3 处的跑道 1 。

这只青蛙从点 0 处跑道 2 出发，并想到达点 n 处的 任一跑道 ，请你返回 最少侧跳次数 。

注意：点 0 处和点 n 处的任一跑道都不会有障碍。

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D0plGokB-1631686507412)(动态规划.assets/ic234-q3-ex1.png)]

输入：obstacles = [0,1,2,3,0]
输出：2 
解释：最优方案如上图箭头所示。总共有 2 次侧跳（红色箭头）。
注意，这只青蛙只有当侧跳时才可以跳过障碍（如上图点 2 处所示）。

示例 2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8NjmpJIV-1631686507414)(动态规划.assets/ic234-q3-ex2.png)]

输入：obstacles = [0,1,1,3,3,0]
输出：0
解释：跑道 2 没有任何障碍，所以不需要任何侧跳。

示例 3：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4KQbKj30-1631686507421)(动态规划.assets/ic234-q3-ex3.png)]

输入：obstacles = [0,2,1,0,3,0]
输出：2
解释：最优方案如上图所示。总共有 2 次侧跳。

提示：

• obstacles.length == n + 1
• 1 <= n <= 5 * 105
• 0 <= obstacles[i] <= 3
• obstacles[0] == obstacles[n] == 0

在比赛的时候没有想到当前状态应该从前一个状态转移过来，然后再比较大小，思路还是不够清晰，总结思路，记住

二维状态的话，就应该考虑当前状态和前面以及上下状态的关系。

class Solution {
   
    public int minSideJumps(int[] obstacles) {
   
        int len = obstacles.length;
        int[][] f = new int[len][3];
        f[0][0] = 1;
        f[0][1] = 0;
        f[0][2] = 1;
        for(int i = 1; i < len; i++) {
   
            for(int j = 0; j < 3; j++){
   
                f[i][j] = f[i-1][j];
            }
            if(obstacles[i] != 0){
   
                f[i][obstacles[i]-1] = Integer.MAX_VALUE/2;
            }
            for (int j = 1; j <= 3; j++) {
   
                if(obstacles[i] != j){
   
                    for (int k = 1; k <= 3; k++) {
   
                        if (k != j && k != obstacles[i]) {
   
                            f[i][j-1] = Math.min(f[i][j-1], f[i][k-1] + 1);
                        }
                    }
                }
            }
        }
        return Math.min(f[len-1][0],Math.min(f[len-1][1],f[len-1][2]));
    }
}

123. 买卖股票的最佳时机 III

难度困难598

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

输入：prices = [7,6,4,3,1] 
输出：0 
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

提示：

• 1 <= prices.length <= 105
• 0 <= prices[i] <= 105

解题思路：

在考虑边界条件时，我们需要理解下面的这个事实：

无论题目中是否允许「在同一天买入并且卖出」这一操作，最终的答案都不会受到影响，这是因为这一操作带来的收益为零。

在这里我们无视了在一天不能同时买入卖出这个规则，我们直接买入卖出了两次，仔细思考可以得出，假如今天买入又卖出，那么利润就是0，

我们使用4个变量记录4种状态，其转移方程为：

• buy1 = max(buy1’,-prices[i]) 其中buy1’表示前一天买入，以下加了 ’ 都表示前一天的操作

• sell1 = max(sell1’,buy1’+prices[i])

• buy2 = max(buy2’,sell1’+prices[i])

• sell2 = max(sell2,buy2’+prices[i])

class Solution {
   
    public int maxProfit(int[] prices) {
   
        int n = prices.length;
        // 有5种状态：
        // (1)一次还没有买;
        // (2)买了一次，没有卖出；
        // (3)买了一次并且卖出了，就是完成第一笔交易；
        // (4)在第一笔交易的基础上，买了一次
        // (5)在情况4的基础上卖出，也就是完成了2笔交易
        // 对于情况(1),我们不要记录，因为它没有进行交易，利润为0
        int[] buy1 = new int[n];
        int[] buy2 = new int[n];
        int[] sell1 = new int[n];
        int[] sell2 = new int[n];
        buy1[0] = -prices[0];
        buy2[0] = -prices[0];
        for(int i = 1; i < n; i++){
   
            buy1[i] = Math.max(buy1[i-1],-prices[i]);
            sell1[i]= Math.max(sell1[i-1],buy1[i-1]+prices[i]);
            buy2[i] = Math.max(buy2[i-1],sell1[i-1]-prices[i]);
            sell2[i] = Math.max(sell2[i-1],buy2[i-1]+prices[i]);
        }
        return sell2[n-1];
    }
}

• 进行空间优化的代码

为什么可以进行空间优化呢，假如今天买入卖出，那么收益为0，而sell1和sell2的值一直大于等于0，所以对于sell1和sell2数组来说没有影响，我们可以直接使用今天的状态去更新sell1和sell2,也就变成了

sell1[i]= Math.max(sell1[i-1],buy1[i]+prices[i]);

sell2[i] = Math.max(sell2[i-1],buy2[i]+prices[i]);

这样就分离了buy和sell数组的联系，就可以直接分别使用一个变量维护其值的变化

class Solution {
   
    public int maxProfit(int[] prices) {
   
        int n = prices.length;
        // 有5种状态：
        // (1)一次还没有买;
        // (2)买了一次，没有卖出；
        // (3)买了一次并且卖出了，就是完成第一笔交易；
        // (4)在第一笔交易的基础上，买了一次
        // (5)在情况4的基础上卖出，也就是完成了2笔交易
        // 对于情况(1),我们不要记录，因为它没有进行交易，利润为0
        int buy1 = -prices[0], buy2 = -prices[0];
        int sell1 = 0, sell2 = 0;
        for(int i = 1; i < n; i++){
   
            buy1 = Math.max(buy1,-prices[i]);
            sell1 = Math.max(sell1,buy1+prices[i]);
            buy2 = Math.max(buy2,sell1-prices[i]);
            sell2 = Math.max(sell2,buy2+prices[i]);
        }
        return sell2;
    }
}

188. 买卖股票的最佳时机 IV

难度困难350

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天