Leetcode 123/188. 买卖股票的最佳时机 III 买两次以及买k次

除了贪心之外，一般的解法肯定是动态规划。 

先使用三维动态规划，很容易利用滚动数组优化成两维

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if(n==0) return 0;
        int[][][] dp = new int[n][3][2];
        // dp[i][j][k] 表示第i天，卖出j次，k=1表示持有股票，k=0表示不持有股票的最大利润
        dp[0][0][1] = -prices[0];
        dp[0][1][1] = Integer.MIN_VALUE;
        for(int i=1;i<n;i++){
            dp[i][0][1] = Math.max(dp[i-1][0][1],dp[i-1][0][0]-prices[i]);
            dp[i][1][0] = Math.max(dp[i-1][1][0],dp[i-1][0][1]+prices[i]);
            dp[i][1][1] = Math.max(dp[i-1][1][1],dp[i-1][1][0]-prices[i]);
            dp[i][2][0] = Math.max(dp[i-1][2][0],dp[i-1][1][1]+prices[i]);
        }
        return Math.max(dp[n-1][2][0],dp[n-1][1][0]);
    }
}

 

直接用三维动态规划，内存会超

class Solution {
    public int maxProfit(int k, int[] prices) {
        int n = prices.length;
        if(n==0||k==0) return 0;
        int[][][] dp = new int[n][k+1][2];
        // dp[i][j][k] 表示第i天，卖出j次，k=1表示持有股票，k=0表示不持有股票的最大利润
        dp[0][0][1] = -prices[0];
        for(int j=1;j<=k;j++){
            dp[0][j][1] = Integer.MIN_VALUE;
        }
        for(int i=1;i<n;i++){
            for(int j=0;j<=k;j++){
                if(j==0) dp[i][j][1] = Math.max(dp[i-1][j][1],dp[i-1][j][0]-prices[i]);
                else if(j==k) dp[i][j][0] = Math.max(dp[i-1][j][0],dp[i-1][j-1][1]+prices[i]);
                else{
                    dp[i][j][0] = Math.max(dp[i-1][j][0],dp[i-1][j-1][1]+prices[i]);
                    dp[i][j][1] = Math.max(dp[i-1][j][1],dp[i-1][j][0]-prices[i]);
                }
            }
        }
        int res = 0;
        for(int j=0;j<=k;j++){
            res = Math.max(res,dp[n-1][j][0]);
        }
        return res;
    }
}

优化成两维

发现还是超内存

class Solution {
    public int maxProfit(int k, int[] prices) {
        int n = prices.length;
        if(n==0||k==0) return 0;
        if(k>n/2) k=n/2;
        int[][] dp = new int[k+1][2];
        // dp[i][j][k] 表示第i天，卖出j次，k=1表示持有股票，k=0表示不持有股票的最大利润
        dp[0][1] = -prices[0];
        for(int j=1;j<=k;j++){
            dp[j][1] = Integer.MIN_VALUE;
        }
        for(int i=1;i<n;i++){
            for(int j=0;j<=k;j++){
                if(j==0) dp[j][1] = Math.max(dp[j][1],dp[j][0]-prices[i]);
                else if(j==k) dp[j][0] = Math.max(dp[j][0],dp[j-1][1]+prices[i]);
                else{
                    dp[j][0] = Math.max(dp[j][0],dp[j-1][1]+prices[i]);
                    dp[j][1] = Math.max(dp[j][1],dp[j][0]-prices[i]);
                }
            }
        }
        int res = 0;
        for(int j=0;j<=k;j++){
            res = Math.max(res,dp[j][0]);
        }
        return res;
    }
}

这是因为当交易次数大于n/2时，其实就相当于可以无限次交易。所以这种时候如果在用动态规划，肯定会超时。优化的办法是加入截断条件

if(k>n/2) k=n/2;