LeetCode——Best Time to Buy and Sell Stock III

最新推荐文章于 2025-10-30 17:17:57 发布

原创最新推荐文章于 2025-10-30 17:17:57 发布 · 4.9k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

Online Judge 专栏收录该内容

134 篇文章

订阅专栏

本文介绍了一种解决股票买卖问题的高效算法，该问题允许进行最多两次交易以获得最大利润，并确保不会同时进行多次交易。通过优化算法，利用动态规划的思想，文章详细解释了如何在O(n)时间内找到最优解。

Say you have an array for which the i^th element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

» Solve this problem

O(n^2)的算法很容易想到：

找寻一个点j，将原来的price[0..n-1]分割为price[0..j]和price[j..n-1]，分别求两段的最大profit。

进行优化：

对于点j+1，求price[0..j+1]的最大profit时，很多工作是重复的，在求price[0..j]的最大profit中已经做过了。

类似于Best Time to Buy and Sell Stock，可以在O(1)的时间从price[0..j]推出price[0..j+1]的最大profit。

但是如何从price[j..n-1]推出price[j+1..n-1]？反过来思考，我们可以用O(1)的时间由price[j+1..n-1]推出price[j..n-1]。

最终算法：

数组l[i]记录了price[0..i]的最大profit，

数组r[i]记录了price[i..n]的最大profit。

已知l[i]，求l[i+1]是简单的，同样已知r[i]，求r[i-1]也很容易。

最后，我们再用O(n)的时间找出最大的l[i]+r[i]，即为题目所求。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int profit = 0, n = prices.size();
        if (n == 0) {
            return 0;
        }
        int l[n], r[n];
        memset(l, 0, sizeof(int) * n);
        memset(r, 0, sizeof(int) * n);
        int min = prices[0];
        for (int i = 1; i < n; i++) {
            l[i] = prices[i] - min > l[i - 1] ? prices[i] - min : l[i - 1];        
            min = prices[i] < min ? prices[i] : min;
        }
        int max = prices[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            r[i] = max - prices[i] > r[i + 1] ? max - prices[i] : r[i + 1];
            max = prices[i] > max ? prices[i] : max;
        }
        for (int i = 0; i < n; i++) {
            profit = l[i] + r[i] > profit ? l[i] + r[i] : profit;
        }
        return profit;      
    }
};

public class Solution {
    public int maxProfit(int[] prices) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int n = prices.length;
        int[] left = new int[n];
        int[] right = new int[n];
        int min = prices[0];
        for (int i = 1; i < n; i++) {
            left[i] = left[i - 1] > prices[i] - min ? left[i - 1] : prices[i] - min;
            min = min < prices[i] ? min : prices[i];
        }
        int max = prices[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            right[i] = right[i + 1] > max - prices[i] ? right[i + 1] : max - prices[i];
            max = max > prices[i] ? max : prices[i];
        }
        int value = 0;
        for (int i = 0; i < n; i++) {
            value = value > left[i] + right[i] ? value : left[i] + right[i];
        }
        return value;
    }
}