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

尝试解决：假设您有一个数组，其第i个元素是第一天给定股票的价格

设计一个算法来寻找最大利润。您最多可以完成两项交易

解决方案： 我所做的是分而治之的方法

dp[i][j]是第i天和第j天之间的最大利润。计算如下：

dp[i][j]=max（dp[i][j]，max（价格[i]-价格[j]，dp[k][j]，dp[i][k+1]），其中k小于i且大于j

现在，我们只需要在下面找出两次交易的最大利润：

m=max（m，max（dp[i][j]，dp[k][j]+dp[i][k+1]））

请给我一个提示来解决这个问题，因为这里提供的现有解决方案正在超时

class Solution(object):
    def profit(self, prices, dp):
        m = 0
        for w in range(1, len(prices)):
            for i in range(1, len(prices)):
                for j in range(i-w, i):
                    if i-w < 0:
                        continue
                    for k in range(j, i):
                        dp[i][j] = max(dp[i][j], max(prices[i] - prices[j], dp[k][j], dp[i][k+1]))
                        m = max(m, max(dp[i][j], dp[k][j] + dp[i][k+1]))
        return m

    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        dp = [[0 for i in range(len(prices)+1)] for i in range(len(prices)+1)]
        return self.profit(prices, dp)

类解决方案（对象）：
def利润（自身、价格、dp）：
m=0
对于范围（1，len（价格））内的w：
对于范围（1，len（价格））内的i：
对于范围内的j（i-w，i）：
如果i-w<0：
持续
对于范围（j，i）内的k：
dp[i][j]=max（dp[i][j]，max（价格[i]-价格[j]，dp[k][j]，dp[i][k+1]））
m=max（m，max（dp[i][j]，dp[k][j]+dp[i][k+1]））
返回m
def maxProfit（自身、价格）：
"""
：类型价格：列表[int]
：rtype:int
"""
dp=[[0表示范围内的i（len（价格）+1）]表示范围内的i（len（价格）+1]
收益自利（价格，dp）

一个提示是对价格进行预处理，并找出以指数i结束的价格出售所能获得的最大利润。 然后，您可以从预处理向量的末尾开始找出问题的解决方案。这将使用1-D DP解决问题，并且不会超时

  int maxProfit(vector<int>& prices) {

    int mprof = 0;
    if (prices.size()>1){
        int maxprof = 0;
        vector<int> mp; // max profit before each element
        mp.push_back(0);
        int st = *prices.begin();
        for(int i = 1 ; i<=prices.size();i++){  //compute mp vector
            if (mprof < prices[i]-st){mprof = prices[i]-st;}
            if (prices[i]<st){st = prices[i];}
            mp.push_back(mprof);
        }
        mprof = 0;
        int ed = *(prices.end()-1);
        for (int i = prices.size()-2; i>=0; i--){
            if (mprof < ed - prices[i] + mp[i]) { mprof = ed - prices[i] + mp[i];}
            if (prices[i]>ed) {ed = prices[i];}
        }
    }
    return mprof;

}

int最大利润（向量和价格）{
int-mprof=0；
如果（prices.size（）>1）{
int-maxprof=0；
vector mp；//每个元素前的最大利润
mp.推回（0）；
int st=*prices.begin（）；
对于（inti=1；ied）{ed=prices[i]；}
}
}
返回mprof；
}

类解决方案：
def maxProfit（自身，价格：列表[int]）->int:
如果len（价格）=购买价格：
最大利润+=价格-买入价格
购买价格=价格
其他：
购买价格=价格
返回最大利润

你的意思是先买后卖的最大利润吗？因为否则它只是最小值和最大值。@Carlos:是的，先买后卖。Prefix-sum+Kadane的算法？它不会完全是前缀和，因为利润不会总是前缀和。@priyansgool:我用另一种方法解决了它，即从左到右跟踪最大利润直到I。将左利润和右利润加在0（n）中。你现在能提出你的解决方案吗？@nomanpuigt:我在做同样的事情，但没有维护正确的数组。您只能在左数组中执行此操作。@priyansgoel:可以为此发布一些伪代码吗？运行时，内存优化了pythonic解决方案！

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) <= 1:
            return 0

        max_profit = 0
        buy_price = prices[0]
        for price in prices:
            if price >= buy_price:
                max_profit += price - buy_price
                buy_price = price
            else:
                buy_price = price


        return max_profit