动态规划-买卖股票的最佳时机 IV｜Java 刷题打卡

本文正在参加「Java主题月 – Java 刷题打卡」，详情查看<活动链接>

【Java 刷题打卡 】刷题比玩游戏好多了，成就感越来越强，每天坚持刷几道题，每天锻炼30分钟，等8块腹肌,等大厂offer.

那就干吧！ 这个专栏都是刷的题目都是关于动态规划的,我会由浅入深、循序渐进，刷题就是这样需要连续不断的记忆–艾宾浩斯记忆法2121112。动态规划的内容不多，但是都是每个程序员必备的

$\color{green}{这是一道比较简单的题目? ? ? ~}$

什么题可以选择动态规划来做？

1.计数

• 有多少种方式走到右下角
• 有多少种方法选出k个数是的和是sum

2.求最大值最小值

• 从左上角走到右下角路径的最大数字和
• 最长上升子序列长度

3.求存在性

• 取石子游戏,先手是否必胜
• 能不能选出k个数使得和是sum

4.综合运用

• 动态规划 + hash
• 动态规划 + 递归
• …

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

给定一个整数数组 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 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

提示：

0 <= k <= 100

0 <= prices.length <= 1000

0 <= prices[i] <= 1000

—

❤️❤️❤️❤️

2.1. 动态规划组成部分1：确定状态

简单的说，解动态规划的时候需要开一个数组，数组的每个元素f[i]或者f[i][j]代表什么，类似数学题中x, y, z代表什么

最后一步

我们用 buy[i][j] 表示对于数组 prices[0..i] 中的价格而言，进行恰好 j 笔交易，并且当前手上持有一支股票，这种情况下的最大利润；

用sell[i][j] 表示恰好进行 j 笔交易，并且当前手上不持有股票，这种情况下的最大利润。

那么就有两种情况： 是否是第i买入的

1. 如果是第i天买入的，那么它的前i -1天, 都是不持有股票的，对应sel[i-1][j] – prise[i] (减去第i天的价格）

2. 如果不是第i天买入的，那么它的前i-1天，是持有股票的，对应buy[i-1][j]

那么我们就可以推导出，在i天内，我们进行j比交易，是否还持有股票？

• 如果持有，回到定义, 对于买入，就是以上分析的两种情况，那么

  buy[i][j] = max{buy[i-1][j]， sel[i-1][j] – prise[i]}

• 如果不持有，对于卖出，在第i天卖出，i-1天，都持有股票，持有股票buy[i−1][j−1] + prise[i] (当天价格),不持有股票sell[i−1][j]

  sell[i][j] = max{buy[i-1][j]， sel[i-1][j] – prise[i]}

1.2. 动态规划组成部分2：转移方程

见上分析，注意：买入不算交易次数，而卖出算交易次数+1。

因此，对于在第i天卖出，持有股票buy[i−1][j−1] + prise[i] (当天价格)会是j-1 + 卖出的prise[i] = j

1.3. 动态规划组成部分3：初始条件和边界情况

因为同一天不能进行买入卖出，n天最多n/2比交易，初始化

• i < k(k为交易数）

  buy[0][i] = Integer.MIN_VALUE / 2

  sell[0][i] = Integer.MIN_VALUE / 2

• buy[0][0] = -prices[0]; 买入扣钱

• sell[0][0] = 0;

1.4. 动态规划组成部分4：计算顺序

依次计算。

$\color{green}{? ? ? ~}$

参考代码

$\color{red}{NICE? ? ? ~}$

java版

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        k = Math.min(k, n / 2);
        int[][] buy = new int[n][k + 1];
        int[][] sell = new int[n][k + 1];

        buy[0][0] = -prices[0];
        sell[0][0] = 0;
        for (int i = 1; i <= k; ++i) {
            buy[0][i] = sell[0][i] = Integer.MIN_VALUE / 2;
        }

        for (int i = 1; i < n; ++i) {
            buy[i][0] = Math.max(buy[i - 1][0], sell[i - 1][0] - prices[i]);
            for (int j = 1; j <= k; ++j) {
                buy[i][j] = Math.max(buy[i - 1][j], sell[i - 1][j] - prices[i]);
                sell[i][j] = Math.max(sell[i - 1][j], buy[i - 1][j - 1] + prices[i]);   
            }
        }

        return Arrays.stream(sell[n - 1]).max().getAsInt();
    }
}

复制代码

滚动数组又又又又来了！！！

buy[i][j] 和 sell[i][j] 都从buy[i−1][..] 以及 sell[i−1][..] 转移而来

b[j]←max{b[j],s[j]−price[i]}

s[j]←max{s[j],b[j−1]+price[i]}

java版

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        k = Math.min(k, n / 2);
        int[] buy = new int[k + 1];
        int[] sell = new int[k + 1];

        buy[0] = -prices[0];
        sell[0] = 0;
        for (int i = 1; i <= k; ++i) {
            buy[i] = sell[i] = Integer.MIN_VALUE / 2;
        }

        for (int i = 1; i < n; ++i) {
            buy[0] = Math.max(buy[0], sell[0] - prices[i]);
            for (int j = 1; j <= k; ++j) {
                buy[j] = Math.max(buy[j], sell[j] - prices[i]);
                sell[j] = Math.max(sell[j], buy[j - 1] + prices[i]);   
            }
        }

        return Arrays.stream(sell).max().getAsInt();
    }
}

复制代码

真心感谢帅逼靓女们能看到这里，如果这个文章写得还不错，觉得有点东西的话

求点赞? 求关注❤️ 求分享? 对8块腹肌的我来说真的 非常有用！！！

如果本篇博客有任何错误，请批评指教，不胜感激 ！❤️❤️❤️❤️