【LeetCode】Best Time to Buy and Sell Stock & Best Time to Buy and Sell Stock

最新推荐文章于 2023-02-28 14:37:52 发布

原创最新推荐文章于 2023-02-28 14:37:52 发布 · 516 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 同时被 2 个专栏收录

86 篇文章

订阅专栏

动态规划

17 篇文章

订阅专栏

本文深入探讨了股票交易中的经典问题，包括一次交易的最大收益、不限次数交易的最大收益及最多两次交易的最大收益。通过算法分析，提供了求解这些问题的高效方法，并详细解释了关键步骤与实现逻辑。

参考链接

http://www.cnblogs.com/wdpp/archive/2011/12/28/2386704.html

http://hi.baidu.com/liu_a_meng/item/e2dbd8e4ac11a0c4baf37d4f

http://www.cnblogs.com/remlostime/archive/2012/11/06/2757434.html

II

http://blog.youkuaiyun.com/salutlu/article/details/20937185

题目描述

Best Time to Buy and Sell Stock

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

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

题目分析

题意思，就是第i天的股票价格为array[i]。问最大利润，就是右边的数和它左边的数做差，求最大的一个差值

从最后一个数字开始 prices.size()-1.....i.......0 第i个数时最大差值就是max（i）=MAX（max（i+1）,MAX(array[i+1],array[i+2].....)-array[i]）

也就是已经求得的最优解和i后面数字中最大数和当前值的差值的最大值。

总结

代码示例

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (prices.size() == 0)
            return 0;
            
        int maxPrice = prices[prices.size()-1];
        int ans = 0;
        for(int i = prices.size() - 1; i >= 0; i--)
        {
            maxPrice = max(maxPrice, prices[i]);
            ans = max(ans, maxPrice - prices[i]);
        }
        
        return ans;
    }
};

Best Time to Buy and Sell Stock II

Total Accepted: 12370 Total Submissions: 34808 My Submissions

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

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

int maxProfit(vector<int> &prices) 
{
	if (prices.size() <= 1) return 0;
	int profit = 0;
	for (int i = 1; i < prices.size(); i++)
	{
		if (prices[i-1] < prices[i])
		{
			profit += prices[i] - prices[i-1];
		}
	}
	return profit;	        
}

Best Time to Buy and Sell Stock III

Say you have an array for which the ith 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).

参考：

http://www.cnblogs.com/lihaozy/archive/2012/12/19/2825525.html

http://blog.youkuaiyun.com/pickless/article/details/12034365

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;      
    }
};