123.Best Time to Buy and Sell Stock III---dp

题目链接：https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/

题目大意：与122题类似，只是这里要求买卖次数只能有两次，计算两次总共的最大利润值。

法一（超时）：计算某一天之前的最大利润值与某一天之后的最大利润值，然后用for循环遍历得到最大值，时间复杂度是o(n^2)，代码如下：

 int res = 0;
         for(int i = 0; i < prices.length; i++) {
             int maxPre = 0;
             int min = Integer.MAX_VALUE;
             //0 to i-1
             for(int j = 0; j < i; j++) {
                 if(prices[j] < min) {
                     min = prices[j];
                 }
                 else if(prices[j] - min > maxPre){
                     maxPre = prices[j] - min;
                 }
             }
             //i to n-1
             int maxPost = 0;
             min = Integer.MAX_VALUE;
             for(int j = i; j < prices.length; j++) {
                 if(prices[j] < min) {
                     min = prices[j];
                 }
                 else if(prices[j] - min > maxPost){
                     maxPost = prices[j] - min;
                 }
             }

             if(maxPre + maxPost > res) {
                 res = maxPre + maxPost;
             }
         }
         return res;

法二（借鉴）：动态规划，利用法一的思路，只是这里不用for循环嵌套遍历得到最大值，而是用两个数组分别记录某一天之前的最大利润值和某一天之后的最大利润值，然后再另开一个for循环，计算比较得到最大值。这里有两个动规公式：

1.数组记录最大利润：

　　1）某一天之前：preProfit[i] = max(preProfit[i - 1], prices[i] - min);

　　2）某一天之后：postProfit[i] = max(postProfit[i + 1], max - prices[i]);

2.for循环计算得到最大值：res = max(res, preProfit[i] + postProfit[i]);

代码如下（耗时1ms）：

         int length = prices.length;
         int[] preProfit = new int[length];
         int[] postProfit = new int[length];
         //从前往后找，0 to i，用数组记录每一天i之前所能获得的最大利润，计算过程与121题类似
         int minPrice = Integer.MAX_VALUE;
         int max = 0;
         for(int i = 0; i < length; i++) {
             if(prices[i] < minPrice) {
                 minPrice = prices[i];
             }
             else if(prices[i] - minPrice > max) {
                 max = prices[i] - minPrice;
             }
             preProfit[i] = max;
         }
         //从后往前，i to n-1，用数组记录每一天i之后所能获得的最大利润
         //注意：从后往前找的时候，应该记录当前位置之后的最大价值，然后将当前位置的价值与最大价值进行比较
         int maxPrice = Integer.MIN_VALUE;
         max = 0;
         for(int i = length - 1; i >= 0; i--) {
             if(prices[i] > maxPrice) {
                 maxPrice = prices[i];
             }
             else if(maxPrice - prices[i] > max) {
                 max = maxPrice - prices[i];
             }
             postProfit[i] = max;
         }

         int res = 0;
         for(int i = 0; i < length; i++) {
             if(preProfit[i] + postProfit[i] > res) {
                 res = preProfit[i] + postProfit[i];
             }
         }
         return res;

法三（借鉴）：参考：http://blog.csdn.net/u012501459/article/details/46514309解法二。