动态规划——买卖股票的最佳时机3

题目链接

leetcode在线oj题——买卖股票的最佳时机3

题目描述

给定一个数组，它的第 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

解题思路

由于这道题不仅涉及到两个不同状态——买入和卖出，并且还涉及到交易次数的问题，因此需要定义两个二维数组来表示不同的状态

f[i][j]：第I天为买入状态，进行了j次交易时的最大收益
f[i][j]：第I天为卖出状态，进行了j次交易时的最大收益

根据题目表述，可以画出状态转移图

根据状态转移图，可以写出状态转移方程

f[i][j] = Math.max(f[i - 1][j], g[i - 1][j] - prices[i]);
g[i][j] = Math.max(g[i][j], f[i - 1][j - 1] + prices[i]);

这道题需要注意初始化问题，否则会造成数组越界，在第1天也就是数组0下标位置时，如果买入，那么f[0][0] = -prices[0]，第一天无法卖出，因此g[0][0] = 0

而j下标是1，2时，由于如果第一天多次买卖会造成机会的浪费，因此是无意义的，而状态转移方程中要求较大值，因此为了不干扰最后的结果，j下标为1，2时应该是一个足够小的数字

但是，如果使用Integer.MinValue时，由于状态转移方程中涉及到减法，减去一个负无穷的数字会造成溢出，因此我们使用-0x3f3f3f这个数字，这个数字是Integer.MinValue的一半，不会造成溢出

最后，只需要返回i为n - 1，j为0，1，2中的较大者即可

完整代码

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] f = new int[n][3];
        int[][] g = new int[n][3];
        int INF = -0x3f3f3f;
        for (int i = 0; i < 3; i++){
            f[0][i] = INF;
            g[0][i] = INF;
        }
        f[0][0] = -prices[0];
        g[0][0] = 0;
        
        for (int i = 1; i < n; i++){
            for (int j = 0; j < 3; j++){
                f[i][j] = Math.max(f[i - 1][j], g[i - 1][j] - prices[i]);
                g[i][j] = g[i - 1][j];
                if(j - 1 >= 0){
                    g[i][j] = Math.max(g[i][j], f[i - 1][j - 1] + prices[i]);
                }
            }
        }
        
        int ret = 0;
        for (int i = 0; i < 3; i++){
            ret = Math.max(g[n - 1][i], ret);
        }
        return ret;
    }
}