代码随想录day50｜股神系列｜123.买卖股票的最佳时机III｜188.买卖股票的最佳时机IV｜Golang

代码随想录day50

还10天

目录

代码随想录day50

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

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

---

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

 思路

        这道题目相对 121.买卖股票的最佳时机和 122.买卖股票的最佳时机II难了不少。

        关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

接来下我用动态规划五部曲详细分析一下：

1、确定dp数组以及下标的含义

一天一共就有五个状态，

        dp[i][0]: 没有操作

        dp[i][1]: 第一次买入

        dp[i][2]: 第一次卖出

        dp[i][3]: 第二次买入

        dp[i][4]: 第二次卖出

dp[i][j] 表示第i天，j为[0-4]的五个状态，dp[i][j]表示第i天、状态j、所剩的最大现金。

2、确定递推公式

        需要注意：dp[i][1]表示的是第i天，买入股票的状态，并不少说一定要第i天买入股票，这是很多同学容易陷入的误区。

达到dp[i][1]，有两个具体操作：

• 操作1：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
• 操作2: 第i天没有操作，而是沿用前一天买入的状态，即dp[i][1] = dp[i-1][1]

那么dp[i][1]究竟是选dp[i-1][0]-prices[i]呢 还是dp[i-1][1]呢？

一定是选最大的，所以dp[i][1] = max(dp[i-1][1] , dp[i-1][0] - prices[i],)

同理dp[i][2]也有两个操作：

操作1：第i天卖出去股票了，那么dp[i][2] = dp[i-1][1] + prices[i]

操作2：第i天没有操作，沿用前一天卖出股票的状态，即dp[i][2] = dp[i-1][2]

所以dp[i][2] = max( dp[i-1][2],  dp[i-1][1] + prices[i]  )

同理可以推出剩下的状态：

dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i] )

dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i] )

3、dp数组如何初始化

第0天的状态0: 没有操作，这个最容易想到，就是0，即dp[0][0] = 0

第0天的状态1，即第一次买入的操作 dp[0][1] =  -prices[0]

第0天的状态2，即第一次卖出去的操作，这个初始值应该是多少呢？

        首先卖出去的操作一定是收获利润，整个股票买卖最差情况也就是没有盈利即全程无操作，现金为0。 从递推公式中可以看出每次是取最大值，那么既然是收获利润比0还小了那就没必要收获这个利润了，所以dp[0][2] = 0

第0天的状态3，即第二次买入的操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？

        第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了、第一次卖出了，然后再买入一次（第二次买入），那么现在手头上没有现金，现金就做相应的减少。

        所以第二次买入的操作，初始化为dp[0][3] = -prices[0]

        同理第二次卖出初始化dp[0][4] = 0

4、确定遍历顺序

        从递推公式其实已经可以看出来，一定是从前向后遍历，因为dp[i]是依靠前一个状态dp[i-1]的数值。

5、举例推导dp数组

以输入[1,2,3,4,5]为例

大家可以看到红色框为最后两次卖出的状态。

现在最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。

所以最终最大利润是dp[4][4]

以上五部都分析完了，不难写出如下代码：

func maxProfit(prices []int) int {
    dp := make([][]int, len(prices))
    for i:=0;i<len(prices);i++{
        dp[i] = make([]int,5)
    }
    /*
       dp[i][0]: 没有操作
       dp[i][1]: 第一次买入
       dp[i][2]: 第一次卖出
       dp[i][3]: 第二次买入
       dp[i][4]: 第二次卖出
    */
    dp[0][0] = 0
    dp[0][1] = -prices[0]
    dp[0][2] = 0
    dp[0][3] = -prices[0]
    dp[0][4] = 0
    for i:=1;i<len(prices);i++{
        dp[i][0] = dp[i-1][0]
        dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
        dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
        dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])
        dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])
    }
    return dp[len(prices)-1][4]
}
func max(a, b int) int{
    if a > b {
        return a 
    }
    return b 
}

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

思路

        这道题目可以说是动态规划：123.买卖股票的最佳时机III的进阶版，这里要求至多有k次交易。

        动规五部曲，分析如下：

1、确定dp数组以及下标的含义

        在动态规划：123.买卖股票的最佳时机III中，我是定义了一个二维dp数组，本题其实依然可以用一个二维dp数组。

        使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

j的状态表示为：

• 0 表示不操作
• 1 第一次买入
• 2 第一次卖出
• 3 第二次买入
• 4 第二次卖出
• .....

大家应该发现规律了吧 ，除了0以外，偶数就是卖出，奇数就是买入。

题目要求是至多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。

所以二维dp数组的C++定义为：

vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));

2、确定递推公式

        还要强调一下：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。

达到dp[i][1]状态，有两个具体操作：

• 操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
• 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

同理dp[i][2]也有两个操作：

• 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
• 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

同理可以类比剩下的状态，代码如下：

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

        本题和动态规划：123.买卖股票的最佳时机III最大的区别就是这里要类比j为奇数是买，偶数是卖的状态。

3、dp数组如何初始化

第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;

第0天做第一次买入的操作，dp[0][1] = -prices[0];

第0天做第一次卖出的操作，这个初始值应该是多少呢？

        首先卖出的操作一定是收获利润，整个股票买卖最差情况也就是没有盈利即全程无操作现金为0，

        从递推公式中可以看出每次是取最大值，那么既然是收获利润如果比0还小了就没有必要收获这个利润了。

所以dp[0][2] = 0;

第0天第二次买入操作，初始值应该是多少呢？

不用管第几次，现在手头上没有现金，只要买入，现金就做相应的减少。

第二次买入操作，初始化为：dp[0][3] = -prices[0];

所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]

for (int j = 1; j < 2 * k; j += 2) {
    dp[0][j] = -prices[0];
}

在初始化的地方同样要类比j为偶数是卖、奇数是买的状态。

4、确定遍历顺序

        从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5、举例推导dp数组

以输入[1,2,3,4,5]，k=2为例。

最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。

以上分析完毕，Go代码如下：               

// 买卖股票的最佳时机IV 动态规划
// 时间复杂度O(kn) 空间复杂度O(kn)
func maxProfit(k int, prices []int) int {
    if k == 0 || len(prices) == 0 {
        return 0
    }
    dp:=make([][]int,len(prices))
    for i:=0;i<len(prices);i++{
        dp[i]=make([]int,2*k+1)
    }
 
    // 初始化买入
    for j := 1; j < 2 * k; j += 2 {
        dp[0][j] = -prices[0]
    }
    // 其他初始化为的0都操作，默认就是0，不用再敲一遍。
 
    for i := 1; i < len(prices); i++ {
        for j := 0; j < 2 * k; j += 2 {
            // 奇数是买入
            dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i])
 
            // 偶数是卖出
            dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i])
        }
    }
    return dp[len(prices) - 1][2 * k]
}
 
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}