LeetCode:Best Time to Buy and Sell Stock I II III

LeetCode: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.

分析：题目的意思是整个过程中只能买一只股票然后卖出，也可以不买股票。也就是我们要找到一对最低价和最高价，最低价在最高价前面，以最低价买入股票，以最低价卖出股票。

下面三个算法时间复杂度都是O（n）

算法1：顺序扫描股票价格，找到股票价格的第一个上升区间，以区间最低价买入，最高价卖出，后面扫描到上升区间时，根据区间的边界更新最低价和最高价                                                    本文地址

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int i = ;
         int ibuy = , isell = , leastBuy;
         bool setted = false;
         while(i < len - )
         {
             int buy, sell;
             while(i+ < len && prices[i+] < prices[i])i++;//递减区间
             buy = i++;

             while(i < len && prices[i] >= prices[i-])i++;//递增区间
             sell = i-;
             if(setted == false)
             {
                 ibuy = buy;
                 isell = sell;
                 leastBuy = buy;
                 setted = true;
             }
             else
             {
                 if(prices[buy] <= prices[ibuy] && prices[sell] - prices[buy] >= prices[isell] - prices[ibuy])
                     {ibuy = buy; isell = sell;}
                 if(prices[sell] > prices[isell] && prices[buy] > prices[leastBuy])
                     {isell = sell; ibuy = leastBuy;}
                 if(prices[leastBuy] > prices[buy])leastBuy = buy;
             }
         }
         return prices[isell] - prices[ibuy];
     }
 };

@dslztx在评论中找出了上面算法的一个错误，修正如下

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int i = ;
         int ibuy = , isell = , leastBuy = ; //leastBuy为前面已经扫描过的最低价格
         bool setted = false;
         while(i < len - )
         {
             int buy, sell;
             while(i+ < len && prices[i+] < prices[i])i++;//递减区间
             buy = i++;

             while(i < len && prices[i] >= prices[i-])i++;//递增区间
             sell = i-;
             //此时从prices[buy]~prices[sell]是递增区间

             if(prices[buy] <= prices[ibuy])
             {
                 if(prices[sell] - prices[buy] >= prices[isell] - prices[ibuy])
                 {
                     ibuy = buy;
                     isell = sell;
                 }
             }
             else
             {
                 if(prices[sell] > prices[isell])
                     isell = sell;
             }
             if(prices[buy] > prices[leastBuy])
                 ibuy = leastBuy;

             if(prices[leastBuy] > prices[buy])leastBuy = buy;
         }
         return prices[isell] - prices[ibuy];
     }
 };

算法2：设dp[i]是[0,1,2...i]区间的最大利润，则该问题的一维动态规划方程如下

dp[i+1] = max{dp[i], prices[i+1] - minprices}  ,minprices是区间[0,1,2...,i]内的最低价格

我们要求解的最大利润 = max{dp[0], dp[1], dp[2], ..., dp[n-1]} 代码如下：

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int res = prices[] - prices[], minprice = prices[];
         for(int i = ; i < len; i++)
         {
             minprice = min(prices[i-], minprice);
             if(res < prices[i] - minprice)
                 res = prices[i] - minprice;
         }
         if(res < )return ;
         else return res;
     }
 };

算法3：按照股票差价构成新数组 prices[1]-prices[0], prices[2]-prices[1], prices[3]-prices[2], ..., prices[n-1]-prices[n-2]。求新数组的最大子段和就是我们求得最大利润，假设最大子段和是从新数组第 i 到第 j 项，那么子段和= prices[j]-prices[j-1]+prices[j-1]-prices[j-2]+...+prices[i]-prices[i-1] = prices[j]-prices[i-1], 即prices[j]是最大价格，prices[i-1]是最小价格，且他们满足前后顺序关系。代码如下：

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int res = , currsum = ;
         for(int i = ; i < len; i++)
         {
             if(currsum <= )
                 currsum = prices[i] - prices[i-];
             else
                 currsum += prices[i] - prices[i-];
             if(currsum > res)
                 res = currsum;
         }
         return res;
     }
 };

这个题可以参考here

---

LeetCode:Best Time to Buy and Sell Stock II

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

分析：在上一题的基础上，可以买卖多次股票，但是不能连续买股票，也就是说手上最多只能有一只股票（注意：可以在同一天卖出手上的股票然后再买进）                                                            本文地址

算法1：找到所有价格的递增区间，每个区间内以对低价买入最高价卖出

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int i = ;
         int res = ;
         while(i < len - )
         {
             int buy, sell;
             //递减区间
             while(i+ < len && prices[i+] < prices[i])i++;
             buy = i++;
             //递增区间
             while(i < len && prices[i] >= prices[i-])i++;
             sell = i-;
             res += prices[sell] - prices[buy];
         }
         return res;
     }
 };

算法2：同上一题构建股票差价数组，把数组中所有差价为正的值加起来就是最大利润了。其实这和算法1差不多，因为只有递增区间内的差价是正数，并且同一递增区间内所有差价之和 = 区间最大价格 -  区间最小价格

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = prices.size();
         if(len <= )return ;
         int res = ;
         for(int i = ; i < len-; i++)
             if(prices[i+]-prices[i] > )
                 res += prices[i+] - prices[i];
         return res;
     }
 };

---

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

分析：这一题约束最多只能买卖两次股票，并且手上最多也只能持有一支股票。因为不能连续买入两次股票，所以买卖两次肯定分布在前后两个不同的区间。设p(i) = 区间[0,1,2...i]的最大利润 + 区间[i,i+1,....n-1]的最大利润（式子中两个区间内分别只能有一次买卖，这就是第一道题的问题），那么本题的最大利润 = max{p[0],p[1],p[2],...,p[n-1]}。根据第一题的算法2，我们可以求区间[0,1,2...i]的最大利润；同理可以从后往前扫描数组求区间[i,i+1,....n-1]的最大利润，其递归式如下：

dp[i-1] = max{dp[i], maxprices - prices[i-1]}  ,maxprices是区间[i,i+1,...,n-1]内的最高价格。                                                                                      本文地址

因此两趟扫描数组就可以解决这个问题，代码如下：

 class Solution {
 public:
     int maxProfit(vector<int> &prices) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         const int len = prices.size();
         if(len <= )return ;
         int maxFromHead[len];
         maxFromHead[] = ;
         int minprice = prices[], maxprofit = ;
         for(int i = ; i < len; i++)
         {
             minprice = min(prices[i-], minprice);
             if(maxprofit < prices[i] - minprice)
                 maxprofit = prices[i] - minprice;
             maxFromHead[i] = maxprofit;
         }
         int maxprice = prices[len - ];
         int res = maxFromHead[len-];
         maxprofit = ;
         for(int i = len-; i >=; i--)
         {
             maxprice = max(maxprice, prices[i+]);
             if(maxprofit < maxprice - prices[i])
                 maxprofit = maxprice - prices[i];
             if(res < maxFromHead[i] + maxprofit)
                 res = maxFromHead[i] + maxprofit;
         }
         return res;
     }
 };

【版权声明】转载请注明出处：http://www.cnblogs.com/TenosDoIt/p/3436457.html