leetcode 123 Best Time to Buy and Sell Stock III
是之前两道题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; } };
