10、买卖股票的最佳时机 IV

题目描述：
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [2,4,1], k = 2
输出: 2
解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2:

输入: [3,2,6,5,0,3], k = 2
输出: 7
解释: 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
跟上道题目类似，但是这里如果k大于等于prices长度的一半时，就需要使用贪心，因为这时候如果动态规划就会内存溢出，代码：
参照III的解释
买股票的最佳时机III

class Solution {
    public int maxProfit(int k, int[] prices) {
     if (prices == null || prices.length == 0){
			return 0;
		}
       if(k >= prices.length / 2){
			int max = 0;
			for (int i = 1; i < prices.length; i++) {
				if(prices[i] > prices[i-1]){
					max += (prices[i] - prices[i - 1]);
				}
			}
			return max;
		}
        int dp [][][] = new int[prices.length][k+1][2];
        dp[0][0][0] = 0;
//        初始化dp数组
        for (int i = 0; i <= k; i++) {
			dp[0][k][0] = 0;
			dp[0][i][1] = -prices[0];
		}
        for (int i = 1; i < dp.length; i++) {
        	dp[i][0][1] = Math.max(dp[i-1][0][0] - prices[i] , dp[i-1][0][1]);
        	dp[i][0][0] = dp[i-1][0][0];
			for (int j = 1; j <= k; j++) {
				dp[i][j][0] = Math.max(dp[i-1][j-1][1] + prices[i], dp[i-1][j][0]);
				dp[i][j][1] = Math.max(dp[i-1][j][1], dp[i-1][j][0] - prices[i]);
			}
		}
        
        return dp[prices.length - 1][k][0];   
    }
}

排名靠前的代码

class Solution {
    public int maxProfit(int k, int[] prices) {
	int n = prices.length;
	if (n <= 1)
		return 0;
	
	//if k >= n/2, then you can make maximum number of transactions.
	if (k >=  n/2) {
		int maxPro = 0;
		for (int i = 1; i < n; i++) {
			if (prices[i] > prices[i-1])
				maxPro += prices[i] - prices[i-1];
		}
		return maxPro;
	}
	
    int[][] dp = new int[k+1][n];
    for (int i = 1; i <= k; i++) {
    	int localMax = dp[i-1][0] - prices[0];
    	for (int j = 1; j < n; j++) {
    		dp[i][j] = Math.max(dp[i][j-1],  prices[j] + localMax);
    		localMax = Math.max(localMax, dp[i-1][j] - prices[j]);
    	}
    }
    return dp[k][n-1];
}
}