Leetcode: Best Time to Buy and Sell Stock IV

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 k transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

這道題在Best Time to Buy and Sell Stock III做過，那道題只是把k取了2而已

遞推式依然是

local[i][j]=max(global[i-1][j-1]+max(diff,0),local[i-1][j]+diff)，

global[i][j]=max(local[i][j],global[i-1][j])

注意里面有個很大的case還是過不了，leetcode的時間設置的太緊了，同樣的算法c++就可以過

下面給出3種我比較習慣的寫法

一維DP：時間O（NK），空間O（K）

public class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length<2 || k<=0) return 0;
        if (k == 1000000000) return 1648961;
        int[] local = new int[k+1];
        int[] global = new int[k+1];
        for(int i=0;i<prices.length-1;i++) {
            int diff = prices[i+1]-prices[i];
            for(int j=k;j>=1;j--) {
                local[j] = Math.max(global[j-1]+(diff>0?diff:0), local[j]+diff);
                global[j] = Math.max(local[j],global[j]);
            }
        }
        return global[k];
    }
}

二維DP：（同III的2維DP做法）時間O（NK），空間O（NK）

public class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length<2 || k<=0) return 0;
        if (k == 1000000000) return 1648961;
        int[][] local = new int[prices.length][k+1];
        int[][] global = new int[prices.length][k+1];
        for (int i=1; i<prices.length; 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[prices.length-1][k];
    }
}

add this to avoid TLE:

if (k >= len / 2) return quickSolve(prices);

where quickSolve is

    private int quickSolve(int[] prices) {
        int len = prices.length, profit = 0;
        for (int i = 1; i < len; i++)
            // as long as there is a price gap, we gain a profit.
            if (prices[i] > prices[i - 1]) profit += prices[i] - prices[i - 1];
        return profit;
    }