best-time-to-buy-and-sell-stock系列——先买入后卖出股票的最大值

1、

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

给一个数prices[]，prices[i]代表股票在第i天的售价，求出只做一次交易(一次买入和卖出)能得到的最大收益。

只需要找出最大的差值即可，即 max(prices[j] – prices[i]) ，i < j。一次遍历即可，在遍历的时间用遍历low记录 prices[o....i] 中的最小值，就是当前为止的最低售价，时间复杂度为 O(n)。

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         if(prices.empty())
             return ;
         int res=,min=prices[];
         for(int i=;i<prices.size();i++){
             if(prices[i]<min) min=prices[i];
                 else if(prices[i]-min>res) res=prices[i]-min;
         }
         return res;
     }
 };

2、

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 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).

此题和上面一题的不同之处在于不限制交易次数。也是一次遍历即可，只要可以赚就做交易。

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         if(prices.empty()) return ;
         int res =;
         for(int i=;i<prices.size();i++){
             if(prices[i]-prices[i-]>)
                 res+=prices[i]-prices[i-];
         }
         return res;
     }
 };

3、

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

此题是限制在两次交易内，相对要难一些。容易想到的解决办法是，把prices[] 分成两部分prices[0...m] 和 prices[m...length]  ，分别计算在这两部分内做交易的做大收益。由于要做n次划分，每次划分可以采用 第一题：  I的解法， 总的时间复杂度为O(n^2).

 public class Solution {
     public int maxProfit(int[] prices) {
         int ans = 0;
         for(int m = 0; m<prices.length; m++){
             int tmp = maxProfitOnce(prices, 0, m) + maxProfitOnce(prices, m, prices.length-1);
             if(tmp > ans) ans = tmp;
         }
         return ans;
     }
 
     public int maxProfitOnce(int[] prices,int start, int end){
         if(start >= end) return 0;
         int low = prices[start];
         int ans = 0;
         for(int i=start+1; i<=end; i++){
             if(prices[i] < low) low = prices[start];
             else if(prices[i] - low > ans) ans = prices[i] - low;
         }
         return ans;
     }
 
 }

但是由于效率过低，运行超时。可以利用动态规划的思想进行改进，保持计算的中间结果，减少重复的计算。

那就是第一步扫描，先计算出子序列[0,...,i]中的最大利润，用一个数组保存下来，那么时间是O(n)。计算方法也是利用第一个问题的计算方法。 第二步是逆向扫描，计算子序列[i,...,n-1]上的最大利润，这一步同时就能结合上一步的结果计算最终的最大利润了，这一步也是O(n)。 所以最后算法的复杂度就是O(n)的。

就是说，通过预处理，把上面的maxProfitOnce()函数的复杂度降到O(1)

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         if(prices.empty()) return ;
         int n=prices.size();
         vector<int> opt(n,);
         int res=,low=prices[];
         for(int i=;i<n;i++){
             if(prices[i]<low) low=prices[i];
             else if(res <prices[i]-low) res=prices[i]-low;
             opt[i]=res;
         }
         vector<int> optReverse(n,);
         int high=prices[n-];
         res=;
         for(int i=n-;i>=;i--){
             if(prices[i]>high) high=prices[i];
             else if(high-prices[i]>res) res=high-prices[i];
             optReverse[i]=res;
         }
         res=;
 
         for(int i=;i<n;i++){
             int tmp=opt[i]+optReverse[i];
             res=tmp>res?tmp:res;
         }
         return res;
     }
 };