LeetCode——动态规划——股票最大收益

股票最大收益

一、问题描述

给出每天股票的价格，设计一个算法计算出最大收益。可以最多买卖两个回合。而且卖出之后才能再买。

二、样例

// 1
Input : [3, 3, 5, 0, 0, 3, 1, 4]
Output : 6
Explanation : 0-3, 1-4

// 2
Input : [1, 2, 3, 4, 5]
Output : 4
Explanation : 1-5

// 3
Input : [7, 6, 4, 3, 1]
Output : 0
Explanation : 0

三、解题思路

1、我的想法

构建一个大小为$length\ast (length+1)$数组$dp$，然后$dp[i][j](i\in [0,length),j\in [0,length])$表示以价格$prices[i]$买入，$prices[j]$卖出的收益。而$dp[i][legnth]$表示以价格$prices[i]$买入，然后以某价格卖出的最高收益。然后从每个大于零 的收益开始寻找最大收益，对于任意$dp[i][j]$，此时表示第一次交易，以$i$价格买入，$j$价格卖出，然后在此基础上寻找第二次的最大收益，即寻找出$max(dp[x][length]),x\in [j,length)$，$tempMax=dp[i][j]+max(dp[x][length])$,对于每一行，都找到一个临时最大值，最后得出最大收益。
很明显时间复杂度$O(n^3)$,空间复杂度$O(n^2)$。

class Solution {
public:
    int maxProfit(vector& prices) {
        int length = prices.size();
        vector> dp(length, vector(length + 1, 0));
        int max = 0;
        for(int i = length - 1; i >= 0; -- i){
            for(int j = i + 1; j < length; ++ j){
                dp[i][j] = prices[j] - prices[i];
                if(dp[i][j] > max)
                    max = dp[i][j];
            }
            dp[i][length] = max;
            max = 0;
        }
        int temp;
        for(int i = 0; i < length; ++ i){         
            for(int j = i + 1; j < length; ++ j){
                if(dp[i][j] < 0)
                    continue;
                temp = dp[i][j];
                int temp_max = 0;
                for(int k = j; k < length; ++ k){
                    if(temp_max < dp[k][length])
                        temp_max = dp[k][length];
                }
                temp += temp_max;
                if(max < temp)
                    max = temp;
                
            }
        }
        return max;
    }
};

2、LeetCode童鞋答案

原链接
毫无疑问是用动态规划，可如何能找到递推式却是一个永恒的问题。有时候比女盆友还难找。
$dp[i][j]$表示总共进行$i$次交易，以第$j$天结尾时的最高收益，那递推式
$$\begin{gathered} dp[i][j]=max(dp[i][j-1],prices[j]-prices[x]+dp[i-1][x])x\in [0,j-1] \\ dp[i][j]=max(dp[i][j-1],prices[j]+max(dp[i-1][x]-prices[x])) \\ dp[0][j]=0 \\ dp[i][0]=0 \end{gathered}$$
通过一定的代码优化，时间复杂度和空间复杂度为$O(k\ast n),O(k\ast n)$

class Solution {
public:
    int maxProfit(vector& prices) {
        int length = prices.size();
        if(length == 0)
            return 0;
        int k = 2, maximum = 0, tmp_max;
        vector> dp(k+1, vector(length, 0));
        for(int i = 1; i < k+1; ++ i){
            tmp_max = dp[i-1][0] - prices[0];
            for(int j = 1; j < length; ++ j){
                dp[i][j] = max(dp[i][j-1], prices[j] + tmp_max);
                    tmp_max = max(tmp_max, dp[i-1][j] - prices[j]);
                    maximum = max(dp[i][j], maximum);
            }
        }
        return maximum;
        
    }
};