1.假設有一個數組，它的第i個元素是一支給定的股票在第i天的價格。如果你最多隻允許完成一次交易(例如,一次買賣股票),設計一個演算法來找出最大利潤。

樣例：給出一個數組樣例 [3,2,3,1,2], 返回 1

思路：遍歷陣列，在能獲利的地方嘗試賣出，並比較賣出利潤是否最大。在成本更低的地方則買入。

1. class Solution {  
2. public:  
3.     /** 
4.      * @param prices: Given an integer array 
5.      * @return: Maximum profit 
6.      */
7.     int maxProfit(vector<int> &prices) {  
8.         // write your code here
9.         if(prices.size() == 0){ //時刻注意陣列越界
10.             return 0;  
11.         }  
12.         int max = 0;  
13.         int cur = prices[0];  
14.         for(int i = 0; i < prices.size(); ++i){  
15.             if(prices[i] < cur){ //賣掉會虧
16.                 cur = prices[i];  
17.             }else{ //賣掉能掙
18.                 int
     tmp = prices[i] - cur;  
19.                 if(tmp > max){  
20.                     max = tmp;  
21.                 }  
22.             }  
23.         }  
24.         return max;  
25.     }  
26. };  

2.假設有一個數組，它的第i個元素是一個給定的股票在第i天的價格。設計一個演算法來找到最大的利潤。你可以完成儘可能多的交易(多次買賣股票)。然而,你不能同時參與多個交易(你必須在再次購買前出售股票)。

樣例：給出一個數組樣例[2,1,2,0,1], 返回 2

思路：由於買賣次數無限，所以只要能獲利就進行買賣，這樣能保證所有利潤都吃到自然利潤最大。

1. class Solution {  
2. public:  
3.     /** 
4.      * @param prices: Given an integer array 
5.      * @return: Maximum profit 
6.      */
7.     int maxProfit(vector<int> &prices) {  
8.         // write your code here
9.         int i, d;  
10.         int max = 0;  
11.         for(i = 1; i < prices.size(); ++i){//只要有錢賺就買賣
12.             d = prices[i] - prices[i - 1];  
13.             if(d > 0){  
14.                 max += d;  
15.             }  
16.         }  
17.         return max;  
18.     }  
19. };  

樣例：給出一個樣例陣列 [4,4,6,1,1,4,2,5], 返回 6

思路：使用遞推的方法，先計算第一次買賣的最大利潤區間，第二次買賣是要想獲得最大利潤，要麼是在第一次買賣的區間之前再進行一次最大利潤買賣，要麼是在第一次買賣的區間之後再進行一次最大利潤買賣，要麼是從第一次買賣的區間中切除一個最大虧損區間，將其切分成兩次買賣。比較三種方案哪種帶來的利潤最多就可以得到兩筆交易後的最大利潤。計算最大利潤區間使用題1的演算法，計算最大虧損區間只要改變一下題1演算法的符號。

1. struct Sub{ //買賣區間
2.     int begin;  
3.     int end;  
4.     bool fill;  
5.     Sub(int begin = 0, int end = 0, bool fill = true){  
6.         this->begin = begin;  
7.         this->end = end;  
8.         this->fill = fill;  
9.     }  
10. };  
11. class Solution {  
12. public:  
13.     /** 
14.      * @param prices: Given an integer array 
15.      * @return: Maximum profit 
16.      */
17.     int maxProfit(vector<int> &prices) {  
18.         if(prices.size() == 0){  
19.             return 0;  
20.         }  
21.         Sub tmpSub;  
22.         //第一次買賣後的最大利潤
23.         int max = findMaxSub(prices, 0, prices.size() - 1, tmpSub);  
24.         //第二次買賣後的最大利潤
25.         vector<Sub> subArr;  
26.         subArr.push_back(tmpSub);  
27.         subArr.push_back(Sub(0, tmpSub.begin - 1, false));  
28.         subArr.push_back(Sub(tmpSub.end + 1, prices.size() - 1, false));  
29.         int maxSub = 0;  
30.         for(int i = 0; i < subArr.size(); ++i){  
31.             int tmp;  
32.             if(subArr[i].fill){  
33.                 tmp = -findMinSub(prices, subArr[i].begin, subArr[i].end, tmpSub);  
34.             }else{  
35.                 tmp = findMaxSub(prices, subArr[i].begin, subArr[i].end, tmpSub);  
36.             }  
37.             if(tmp > maxSub){  
38.                 maxSub = tmp;  
39.             }  
40.         }  
41.         return max + maxSub;  
42.     }  
43.     int findMaxSub(vector<int> &arr, int begin, int end, Sub& sub) {  
44.         if(begin >= end)  
45.             return 0;  
46.         sub.fill = true;  
47.         int r = 0;  
48.         int curIndex = begin;  
49.         for(int i = begin; i <= end; ++i){  
50.             if(arr[i] < arr[curIndex]){  
51.                 curIndex = i;  
52.             }else{  
53.                 int tmp = arr[i] - arr[curIndex];  
54.                 if(tmp > r){  
55.                     r = tmp;  
56.                     sub.end = i;  
57.                     sub.begin = curIndex;  
58.                 }  
59.             }      
60.         }  
61.         return r;  
62.     }  
63.      int findMinSub(vector<int> &arr, int begin, int end, Sub& sub) {  
64.         if(begin >= end)  
65.             return 0;  
66.         sub.fill = false;  
67.         int r = 0;  
68.         int curIndex = begin;  
69.         for(int i = begin; i <= end; ++i){  
70.             if(arr[i] > arr[curIndex]){  
71.                 curIndex = i;  
72.             }else{  
73.                 int tmp = arr[i] - arr[curIndex];  
74.                 if(tmp < r){  
75.                     r = tmp;  
76.                     sub.end = i;  
77.                     sub.begin = curIndex;  
78.                 }  
79.             }      
80.         }  
81.         return r;  
82.     }  
83. };  

思路：是題3方法的推廣，需要注意的是在交易已經無法再提高利潤時要退出迴圈以提高演算法速度。網上有討論認為在k大於陣列長度的情況下直接使用題2的方法計算利潤更有效率，也有與我不同的動態規劃思路可以提高效率。參考：http://www.cnblogs.com/grandyang/p/4295761.html

1. struct Sub{//買賣區間
2.     int begin;  
3.     int end;  
4.     bool fill;  
5.     Sub(

   相關推薦

   買賣股票最佳時機（I II III IV 冷凍期，手續費）

   共6個問題： 買賣股票最佳時機 買賣股票最佳時機 II 買賣股票最佳時機 III 買賣股票最佳時機 IV 最佳買賣股票時機含冷凍期 買賣股票最佳時機含手續費 分析： 只允許一次交易的最大收益（一次買進賣出）動態規劃： dp[i] = max(dp[i-1],

   [LeetCode]數組——買賣股票的最佳時機 II

   獲取 pro 設計 pan 更多 完成 一個 class 交易 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個算法來計算你所能獲取的最大利潤。你可以盡可能地完成更多的交易（多次買賣一支股票）。 註意：你不能同時參與多筆交易（你必須在再次購買前出售

   LeetCode 122. 買賣股票的最佳時機 II（Best Time to Buy and Sell Stock II）

   必須 toc for pub i++ pre 價格 股票 時機 題目描述 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個算法來計算你所能獲取的最大利潤。你可以盡可能地完成更多的交易（多次買賣一支股票）。 註意：你不能同時參與多筆交易（你必須在

   LeetCode演算法題122：買賣股票的最佳時機 II 解析

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意： 你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例1： 輸入: [7,1,5,3,6,4] 輸出: 7

   [LeetCode]買賣股票的最佳時機 II

   買賣股票的最佳時機 II 假設有一個數組，它的第 i 個元素是一個給定的股票在第 i 天的價格。 設計一個演算法來找到最大的利潤。你可以完成儘可能多的交易（多次買賣股票）。然而，你不能同時參與多個交易（你必須在再次購買前出售股票）。 注意：可以多次購買，購買前先賣出

   Leetcode 買賣股票的最佳時機 II(c++)

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,3,6,

   LeetCode買賣股票的最佳時機 II

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,

   刷爆LeetCode之買賣股票的最佳時機 II

   買賣股票的最佳時機 II 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1:

   leetcode 122. Best Time to Buy and Sell Stock II(買賣股票的最佳時機 II)

   題目描述 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。  示例 輸入：[7, 1,

   【leetcode】買賣股票的最佳時機 II（Python、C解答）

   題目： 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7

   LeetCode 122. 買賣股票的最佳時機 II（C、C++、python）

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,3,

   leetCode 買賣股票的最佳時機 II

   題目描述： 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入:

   Leetcode 122：買賣股票的最佳時機II（最詳細的解法！！！）

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 **注意：**你不能同時參與多筆交易（你必

   Leetcode題解之陣列（2） 買賣股票的最佳時機 II

   題目描述： 給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 解題思路： 首先

   LeetCode.Best Time to Buy and Sell Stock II 買賣股票的最佳時機 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 pro

   LeetCode-122.買賣股票的最佳時機II（相關話題：貪心演算法）

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,3,6,4] 輸出:

   Leetcode 122.買賣股票的最佳時機II

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,3,6,4] 輸

   Leetcode 買賣股票的最佳時機 II 貪心

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 示例 1: 輸入: [7,1,5,3,

   leetcode -初級 買賣股票的最佳時機 II

   給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。 設計一個演算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。 注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。 輸入: [7,1,5,3,6,4]

   LeetCode-買賣股票的最佳時機 II

   1.假設有一個數組，它的第i個元素是一支給定的股票在第i天的價格。如果你最多隻允許完成一次交易(例如,一次買賣股票),設計一個演算法來找出最大利潤。樣例：給出一個數組樣例 [3,2,3,1,2], 返回 1思路：遍歷陣列，在能獲利的地方嘗試賣出，並比較賣出利潤是否最大。在成本