LeetCode-买卖股票的最佳时机 II

1.假设有一个数组，它的第i个元素是一支给定的股票在第i天的价格。如果你最多只允许完成一次交易(例如,一次买卖股票),设计一个算法来找出最大利润。

样例：给出一个数组样例 [3,2,3,1,2], 返回 1

思路：遍历数组，在能获利的地方尝试卖出，并比较卖出利润是否最大。在成本更低的地方则买入。

[cpp]  view plain  copy

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.           
13.         int max = 0;  
14.         int cur = prices[0];  
15.         for(int i = 0; i < prices.size(); ++i){  
16.             if(prices[i] < cur){ //卖掉会亏  
17.                 cur = prices[i];  
18.             }else{ //卖掉能挣  
19.                 int tmp = prices[i] - cur;  
20.                 if(tmp > max){  
21.                     max = tmp;  
22.                 }  
23.             }  
24.         }  
25.         return max;  
26.     }  
27. };  

2.假设有一个数组，它的第i个元素是一个给定的股票在第i天的价格。设计一个算法来找到最大的利润。你可以完成尽可能多的交易(多次买卖股票)。然而,你不能同时参与多个交易(你必须在再次购买前出售股票)。

样例：给出一个数组样例[2,1,2,0,1], 返回 2

思路：由于买卖次数无限，所以只要能获利就进行买卖，这样能保证所有利润都吃到自然利润最大。

[cpp]  view plain  copy

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

3.假设你有一个数组，它的第i个元素是一支给定的股票在第i天的价格。 设计一个算法来找到最大的利润。你最多可以完成两笔交易。

样例：给出一个样例数组 [4,4,6,1,1,4,2,5], 返回 6

思路：使用递推的方法，先计算第一次买卖的最大利润区间，第二次买卖是要想获得最大利润，要么是在第一次买卖的区间之前再进行一次最大利润买卖，要么是在第一次买卖的区间之后再进行一次最大利润买卖，要么是从第一次买卖的区间中切除一个最大亏损区间，将其切分成两次买卖。比较三种方案哪种带来的利润最多就可以得到两笔交易后的最大利润。计算最大利润区间使用题1的算法，计算最大亏损区间只要改变一下题1算法的符号。

[cpp]  view plain  copy

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

4.假设你有一个数组，它的第i个元素是一支给定的股票在第i天的价格。设计一个算法来找到最大的利润。你最多可以完成 k  笔交易。

样例：给定价格 =[4,4,6,1,1,4,2,5], 且 k = 2, 返回 6.

思路：是题3方法的推广，需要注意的是在交易已经无法再提高利润时要退出循环以提高算法速度。网上有讨论认为在k大于数组长度的情况下直接使用题2的方法计算利润更有效率，也有与我不同的动态规划思路可以提高效率。参考：http://www.cnblogs.com/grandyang/p/4295761.html

[cpp]  view plain  copy

1. struct Sub{//买卖区间  
2.     int begin;  
3.     int end;  
4.     bool fill;  
5.       
6.     Sub(int begin = 0, int end = 0, bool fill = true){  
7.         this->begin = begin;  
8.         this->end = end;  
9.         this->fill = fill;  
10.     }  
11. };  
12.   
13. class Solution {  
14. public:  
15.     /** 
16.      * @param prices: Given an integer array 
17.      * @return: Maximum profit 
18.      */  
19.     int maxProfit(int k, vector<int> &prices) {  
20.         int max = 0;  
21.         vector<Sub> subArr;  
22.         subArr.push_back(Sub(0, prices.size() - 1, false));  
23.         while(k--){  
24.             //寻找一次最有利的切分  
25.             int maxCount = 0;  
26.             int maxIndex = -1;  
27.             Sub maxSub;  
28.             Sub tmpSub;  
29.             for(int i = 0; i < subArr.size(); ++i){  
30.                 int tmp;  
31.                 if(subArr[i].fill){//在实心区间上挖下一个最小值  
32.                     tmp = -findMinSub(prices, subArr[i].begin, subArr[i].end, tmpSub);  
33.                 }else{//在空心区间上找最大利润区间  
34.                     tmp = findMaxSub(prices, subArr[i].begin, subArr[i].end, tmpSub);  
35.                 }  
36.                 if(tmp > maxCount){//记录下当前最佳划分方式和其带来的利润  
37.                     maxCount = tmp;  
38.                     maxIndex = i;  
39.                     maxSub = tmpSub;  
40.                 }  
41.             }  
42.               
43.             //计算切分之后的区间状态  
44.             if(maxIndex >= 0){  
45.                 Sub sub = subArr[maxIndex];  
46.                 if(sub.fill){  
47.                     subArr.push_back(Sub(sub.begin, maxSub.begin, true));  
48.                     subArr.push_back(Sub(maxSub.end , sub.end, true));  
49.                     maxSub.begin += 1;  
50.                     maxSub.end -= 1;  
51.                     subArr[maxIndex] = maxSub;  
52.                 }else{  
53.                     subArr.push_back(Sub(sub.begin, maxSub.begin - 1, false));  
54.                     subArr.push_back(Sub(maxSub.end + 1, sub.end, false));  
55.                     subArr[maxIndex] = maxSub;  
56.                 }  
57.                 //计算此次切分之后的最大利润  
58.                 max += maxCount;  
59.             }else{ //若无法再切分则退出循环  
60.                 break;  
61.             }  
62.         }  
63.         return max;  
64.     }  
65.       
66.     int findMaxSub(vector<int> &arr, int begin, int end, Sub& sub) {  
67.         if(begin >= end)  
68.             return 0;  
69.           
70.         sub.fill = true;  
71.         int r = 0;  
72.         int curIndex = begin;  
73.         for(int i = begin; i <= end; ++i){  
74.             if(arr[i] < arr[curIndex]){  
75.                 curIndex = i;  
76.             }else{  
77.                 int tmp = arr[i] - arr[curIndex];  
78.                 if(tmp > r){  
79.                     r = tmp;  
80.                     sub.end = i;  
81.                     sub.begin = curIndex;  
82.                 }  
83.             }      
84.         }  
85.         return r;  
86.     }  
87.       
88.      int findMinSub(vector<int> &arr, int begin, int end, Sub& sub) {  
89.         if(begin >= end)  
90.             return 0;  
91.           
92.         sub.fill = false;  
93.         int r = 0;  
94.         int curIndex = begin;  
95.         for(int i = begin; i <= end; ++i){  
96.             if(arr[i] > arr[curIndex]){  
97.                 curIndex = i;  
98.             }else{  
99.                 int tmp = arr[i] - arr[curIndex];  
100.                 if(tmp < r){  
101.                     r = tmp;  
102.                     sub.end = i;  
103.                     sub.begin = curIndex;  
104.                 }  
105.             }      
106.         }  
107.         return r;  
108.     }  
109. };