是之前两道题leetcode Best Time to Buy and Sell Stock和leetcode Best Time to Buy and Sell Stock II的加强版。
这里要求只能买两次股票。
做了一个多小时，试了好多次，终于AC了。
思路：找到有可能为断点的地方，也就是出现递减的地方，递减了就说明有损失所以有可能卖出。
对每个可能的分割点，计算左右两边的最大收益，求最大收益和leetcode Best Time to Buy and Sell Stock这个差不多。然后把所有可能的解记录，返回最大的解就是了。
class Solution { public: int maxProfit(vector<int> &prices) { int i = 0, tmpi = 0, len = prices.size(), minp = 0; vector<int> maxp; while(i < len - 1) { if (prices[i] >= prices[i + 1]) {i++; continue;} int curp = prices[i]; int maxID = i + 1; while(i + 1 < len && prices[i] <= prices[i + 1]) { maxID = i + 1; i++;} //对于每个递减的部分左右分割 tmpi = 0; minp = prices[tmpi]; int tmpMax1 = 0; while(tmpi < maxID + 1) { if (prices[tmpi] < minp) minp = prices[tmpi]; else if (prices[tmpi] - minp > tmpMax1) tmpMax1 = prices[tmpi] - minp; tmpi++; } //右边 tmpi = maxID + 1; if (tmpi < len) minp = prices[tmpi]; int tmpMax2 = 0; while(tmpi < len) { if (prices[tmpi] < minp) minp = prices[tmpi]; else if (prices[tmpi] - minp > tmpMax2) tmpMax2 = prices[tmpi] - minp; tmpi++; } maxp.push_back(tmpMax1 + tmpMax2); i = maxID + 1; } int max1 = 0; for (int j = 0; j < maxp.size(); ++j) if (maxp[j] > max1) max1 = maxp[j]; return max1; } };
胜之不武啊，原来我的方法是n方的方法，比普通的遍历所有的节点两边分割的方法好那么一点点，那终究是n方的。
果然，学习了下，还有O(n)的方法。
动态规划：
这位大神
进行优化：
对于点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]，即为题目所求。
package Level4; import java.util.Arrays; /** * 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://blog.csdn.net/pickless/article/details/12034365 * */ public class S123 { public static void main(String[] args) { // int[] prices = {3,3,5,0,0,3,1,4}; int[] prices = {2,1,2,0,1}; System.out.println(maxProfit(prices)); } // 基本思想是分成两个时间段，然后对于某一天，计算之前的最大值和之后的最大值 public static int maxProfit(int[] prices) { if(prices.length == 0){ return 0; } int max = 0; // dp数组保存左边和右边的利润最大值 int[] left = new int[prices.length]; // 计算[0,i]区间的最大值 int[] right = new int[prices.length]; // 计算[i,len-1]区间的最大值 process(prices, left, right); // O(n)找到最大值 for(int i=0; i<prices.length; i++){ max = Math.max(max, left[i]+right[i]); } return max; } public static void process(int[] prices, int[] left, int[] right){ left[0] = 0; int min = prices[0]; // 最低买入价 // 左边递推公式 for(int i=1; i<left.length; i++){ left[i] = Math.max(left[i-1], prices[i]-min); // i的最大利润为（i-1的利润）和（当前卖出价和之前买入价之差）的较大那个 min = Math.min(min, prices[i]); // 更新最小买入价 } right[right.length-1] = 0; int max = prices[right.length-1]; // 最高卖出价 // 右边递推公式 for(int i=right.length-2; i>=0; i--){ right[i] = Math.max(right[i+1], max-prices[i]); // i的最大利润为（i+1的利润）和（最高卖出价和当前买入价之差）的较大那个 max = Math.max(max, prices[i]); // 更新最高卖出价 } // System.out.println(Arrays.toString(left)); // System.out.println(Arrays.toString(right)); } }
下面的解法主要是能把两次的限制推广到k次交易：
这道题是Best Time to Buy and Sell Stock的扩展，现在我们最多可以进行两次交易。我们仍然使用动态规划来完成，事实上可以解决非常通用的情况，也就是最多进行k次交易的情况。
这里我们先解释最多可以进行k次交易的算法，然后最多进行两次我们只需要把k取成2即可。我们还是使用“局部最优和全局最优解法”。我们维护两种量，一个是当前到达第i天可以最多进行j次交易，最好的利润是多少（global[i][j]），另一个是当前到达第i天，最多可进行j次交易，并且最后一次交易在当天卖出的最好的利润是多少（local[i][j]）。下面我们来看递推式，全局的比较简单，
也就是去当前局部最好的，和过往全局最好的中大的那个（因为最后一次交易如果包含当前天一定在局部最好的里面，否则一定在过往全局最优的里面）。
全局（到达第i天进行j次交易的最大收益） = max{局部（在第i天交易后，恰好满足j次交易），全局（到达第i-1天时已经满足j次交易）
对于局部变量的维护，递推式是
也就是看两个量，第一个是全局到i-1天进行j-1次交易，然后加上今天的交易，如果今天是赚钱的话（也就是前面只要j-1次交易，最后一次交易取当前天），第二个量则是取local第i-1天j次交易，然后加上今天的差值（这里因为local[i-1][j]比如包含第i-1天卖出的交易，所以现在变成第i天卖出，并不会增加交易次数，而且这里无论diff是不是大于0都一定要加上，因为否则就不满足local[i][j]必须在最后一天卖出的条件了）。
局部（在第i天交易后，总共交易了j次） = max{情况2，情况1}
情况1：在第i-1天时，恰好已经交易了j次（local[i-1][j]），那么如果i-1天到i天再交易一次：即在第i-1天买入，第i天卖出（diff），则这不并不会增加交易次数！【例如我在第一天买入，第二天卖出；然后第二天又买入，第三天再卖出的行为 和 第一天买入，第三天卖出 的效果是一样的，其实只进行了一次交易！因为有连续性】
情况2：第i-1天后，共交易了j-1次（global[i-1][j-1]），因此为了满足“第i天过后共进行了j次交易，且第i天必须进行交易”的条件：我们可以选择1：在第i-1天买入，然后再第i天卖出（diff），或者选择在第i天买入，然后同样在第i天卖出（收益为0）。
上面的算法中对于天数需要一次扫描，而每次要对交易次数进行递推式求解，所以时间复杂度是O(n*k)，如果是最多进行两次交易，那么复杂度还是O(n)。空间上只需要维护当天数据皆可以，所以是O(k)，当k=2，则是O(1)。
http://blog.csdn.net/linhuanmars/article/details/23236995
public class Solution { public int maxProfit(int[] prices) { return max(prices, 2); } public int max(int[] prices, int k) { // k: k times transactions int len = prices.length; if(len == 0) { return 0; } int[][] local = new int[len][k+1]; // local[i][j]: max profit till i day, j transactions, where there is transaction happening on i day int[][] global = new int[len][k+1]; // global[i][j]: max profit across i days, j transactions for(int i=1; i<len; i++) { int diff = prices[i] - prices[i-1]; for(int j=1; j<=k; j++) { local[i][j] = Math.max(global[i-1][j-1]+Math.max(diff,0), local[i-1][j]+diff); global[i][j] = Math.max(global[i-1][j], local[i][j]); } } return global[len-1][k]; } }
20150403: 动态规划
class Solution { public: int maxProfit(vector<int> &prices) { int n = prices.size(); if (n <= 1) return 0; int left[n], right[n]; // left[i] records 0 to ith day's profits, right[i] i to (n-1)th days' left[0] = 0; int minVal = prices[0]; for (int i = 1; i < n; i++){ left[i] = max(left[i-1], prices[i]- minVal); minVal = min(minVal, prices[i]); } right[n-1] = 0; int maxVal = prices[n-1]; for (int i = n-2; i > 0; i--){ right[i] = max(right[i+1], maxVal - prices[i]); maxVal = max(maxVal, prices[i]); } int profits = 0; for (int i = 1; i < n; i++){ if (profits < left[i] + right[i]) profits = left[i] + right[i]; } return profits; } };