代码随想录-算法训练营day49【动态规划11：买卖股票的最佳时机III、买卖股票的最佳时机IV】-CSDN博客

代码随想录-035期-算法训练营【博客笔记汇总表】-CSDN博客

第九章 动态规划part11

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

 详细布置 

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

这道题一下子就难度上来了，关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
视频讲解：https://www.bilibili.com/video/BV1WG411K7AR
https://programmercarl.com/0123.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAIII.html  

 188.买卖股票的最佳时机IV  
本题是123.买卖股票的最佳时机III 的进阶版  
视频讲解：https://www.bilibili.com/video/BV16M411U7XJ
https://programmercarl.com/0188.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAIV.html

0123_买卖股票的最佳时机III

0188_买卖股票的最佳时机IV

0123_买卖股票的最佳时机III

package com.question.solve.leetcode.programmerCarl2._10_dynamicProgramming;

public class _0123_买卖股票的最佳时机III {
}

class Solution0123 {//版本一
    public int maxProfit(int[] prices) {
        int len = prices.length;
        //边界判断, 题目中 length >= 1, 所以可省去
        if (prices.length == 0) return 0;

        /*
         * 定义 5 种状态:
         * 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出
         */
        int[][] dp = new int[len][5];
        dp[0][1] = -prices[0];
        //初始化第二次买入的状态是确保 最后结果是最多两次买卖的最大利润
        dp[0][3] = -prices[0];

        for (int i = 1; i < len; i++) {
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[len - 1][4];
    }
}

class Solution0123_2 {//版本二: 空间优化
    public int maxProfit(int[] prices) {
        int[] dp = new int[4];
        //存储两次交易的状态就行了
        //dp[0]代表第一次交易的买入
        dp[0] = -prices[0];
        //dp[1]代表第一次交易的卖出
        dp[1] = 0;
        //dp[2]代表第二次交易的买入
        dp[2] = -prices[0];
        //dp[3]代表第二次交易的卖出
        dp[3] = 0;
        for (int i = 1; i <= prices.length; i++) {
            //要么保持不变，要么没有就买，有了就卖
            dp[0] = Math.max(dp[0], -prices[i - 1]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
            //这已经是第二次交易了，所以得加上前一次交易卖出去的收获
            dp[2] = Math.max(dp[2], dp[1] - prices[i - 1]);
            dp[3] = Math.max(dp[3], dp[2] + prices[i - 1]);
        }
        return dp[3];
    }
}

0188_买卖股票的最佳时机IV

package com.question.solve.leetcode.programmerCarl2._10_dynamicProgramming;

public class _0188_买卖股票的最佳时机IV {
}

//版本一: 三维 dp数组
class Solution0188 {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) return 0;

        //[天数][交易次数][是否持有股票]
        int len = prices.length;
        int[][][] dp = new int[len][k + 1][2];

        //dp数组初始化
        //初始化所有的交易次数是为确保 最后结果是最多 k 次买卖的最大利润
        for (int i = 0; i <= k; i++) {
            dp[0][i][1] = -prices[0];
        }

        for (int i = 1; i < len; i++) {
            for (int j = 1; j <= k; j++) {
                //dp方程, 0表示不持有/卖出, 1表示持有/买入
                dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);
                dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);
            }
        }
        return dp[len - 1][k][0];
    }
}

//版本二: 二维dp数组
class Solution0188_2 {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) return 0;

        //[天数][股票状态]
        //股票状态: 奇数表示第 k 次交易持有/买入，偶数表示第 k 次交易不持有/卖出，0 表示没有操作
        int len = prices.length;
        int[][] dp = new int[len][k * 2 + 1];

        //dp数组的初始化, 与版本一同理
        for (int i = 1; i < k * 2; i += 2) {
            dp[0][i] = -prices[0];
        }

        for (int i = 1; i < len; i++) {
            for (int j = 0; j < k * 2 - 1; j += 2) {
                dp[i][j + 1] = Math.max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = Math.max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[len - 1][k * 2];
    }
}

//版本三：一维 dp数组 (下面有和卡哥逻辑一致的一维数组Java解法)
class Solution0188_3 {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) {
            return 0;
        }
        if (k == 0) {
            return 0;
        }
        //其实就是123题的扩展，123题只用记录2次交易的状态
        //这里记录k次交易的状态就行了
        //每次交易都有买入，卖出两个状态，所以要乘 2
        int[] dp = new int[2 * k];
        //按123题解题格式那样，做一个初始化
        for (int i = 0; i < dp.length / 2; i++) {
            dp[i * 2] = -prices[0];
        }
        for (int i = 1; i <= prices.length; i++) {
            dp[0] = Math.max(dp[0], -prices[i - 1]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
            //还是与123题一样，与123题对照来看，就很容易啦
            for (int j = 2; j < dp.length; j += 2) {
                dp[j] = Math.max(dp[j], dp[j - 1] - prices[i - 1]);
                dp[j + 1] = Math.max(dp[j + 1], dp[j] + prices[i - 1]);
            }
        }
        //返回最后一次交易卖出状态的结果就行了
        return dp[dp.length - 1];
    }
}