给定一个数组，它的第 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变大

但需要注意，这道题定义dp[length][k][2]，会超出内存限制，所有应该是k过大，k最大不过是数组的一半，他的交易数量不可能超过这个值，所以当交易次数超过数组长度一半时，调用之前的方法maxProfit1，k视为无限大，可以忽略，定义dp[length][2]

之前交易两次的链接：https://mp.csdn.net/postedit/102924843

提交的代码：

class Solution {
    public static int maxProfit1(int[] prices) {
    int sum=0;
        for(int i=1;i<prices.length;i++)
        {
            if(prices[i]-prices[i-1]>0)
            {
                sum+=prices[i]-prices[i-1];
            }
        }
        return sum;
    }
    public int maxProfit(int k, int[] prices) {
        if(k>prices.length/2)
        {
            return maxProfit1(prices);
        }
        if(prices.length==0||k==0)
    {
        return 0;
    }
    int dp[][][] = new int[prices.length][k+1][2];
    dp[0][0][0] = 0;
    dp[0][0][1] = Integer.MIN_VALUE >> 1;
    for(int i=1;i<=k;i++)
    {
        dp[0][i][0]=0;
        dp[0][i][1]=-prices[0];
    }
    dp[0][1][1] = -prices[0];
    for(int i=1;i<prices.length;i++)
    {
        for(int j = 1;j<=k;j++)
        {
            dp[i][j][0]=Math.max(dp[i-1][j][0],dp[i-1][j][1]+prices[i]);
            dp[i][j][1]=Math.max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i]);    
        }
    }
    int max = dp[prices.length-1][0][0];
    for(int i=1;i<=k;i++)
    {
        if(dp[prices.length-1][k][0]>max)
        {
            max = dp[prices.length-1][k][0];
        }
    }
    return max;

    }
}