团灭6道leetcode股票买卖问题 Java

Leetcode 上共有 6 道 股票买卖问题，分别是 121（1次交易），122（无限次交易），123（2次交易），188（k次交易），309（无限次交易且卖出后有一天冷冻期），714（无限次交易且每次卖出包含固定手续费），这6道问题可以用同一个状态转移方程解决：

i表示当前天数，k表示目前可交易次数，0表示空仓状态，1表示持仓状态

dp[i][k][0] = Math.max(dp[i-1][k][0],dp[i-1][k][1]+price[i]) 
上一行表示第i天可进行k次交易且空仓状态，可能是前一天就空仓，也可能是前一天持仓，第i天刚卖掉；取最大值

dp[i][k][1] = Math.max(dp[i-1][k][1],dp[i-1][k-1][0]-price[i]
上一行表示第i天可进行k次交易且持仓状态，可能是前一天就持仓，也可能是前一天空仓，交易次数减1后第i天买入；取最大值

121.1次交易，注释掉的是状态压缩前的解法

    public int maxProfit(int[] prices) {
//        int n=prices.length;
//        int[][] dp = new int[n][2];
//        dp[0][0] = 0;
//        dp[0][1]=-prices[0];
//        for(int i=1;i<n;i++){
//            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i]);
//            dp[i][1] = Math.max(dp[i-1][1],-prices[i]);
//        }
//        return dp[n-1][0];
        int dp_i_0 = 0,dp_i_1 = Integer.MIN_VALUE;
        for(int v : prices){
            dp_i_0 = Math.max(dp_i_0,dp_i_1+v);
            dp_i_1 = Math.max(dp_i_1,-v);
        }
        return dp_i_0;
    }

122.无限次交易

public int maxProfit(int[] prices) {
        int dp_i_0=0,dp_i_1=Integer.MIN_VALUE;
        for(int v : prices){
            dp_i_0 = Math.max(dp_i_0,dp_i_1+v);
            dp_i_1 = Math.max(dp_i_1,dp_i_0-v);
        }
        return dp_i_0;
    }

123. 2次交易

public int maxProfit(int[] prices) {
// 通用解法
//        int n = prices.length;
//        int[][][] dp = new int[n+1][3][2];
//        for(int i=0;i<=n;i++){
//            for(int k=2;k>=1;k--){
//                if(i == 0) {
//                    dp[i][k][1] = Integer.MIN_VALUE;
//                }else {
//                    dp[i][k][0] = Math.max(dp[i-1][k][0],dp[i-1][k][1]+prices[i-1]);
//                    dp[i][k][1] = Math.max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i-1]);
//                }
//            }
//        }
//        return dp[n][2][0];
        int dp_2_1,dp_2_0,dp_1_1,dp_1_0;
        dp_1_0 = dp_2_0 = 0;
        dp_1_1 = dp_2_1 = Integer.MIN_VALUE;
        for(int v : prices){
            dp_2_0 = Math.max(dp_2_0,dp_2_1 + v); //还有2次交易机会且为空仓状态，可能是前一天空仓，也可能是前一天持仓但今天清仓了
            dp_2_1 = Math.max(dp_2_1,dp_1_0 - v);
            dp_1_0 = Math.max(dp_1_0,dp_1_1 + v);
            dp_1_1 = Math.max(dp_1_1,-v);
        }
        return dp_2_0;
    }

188.k次交易

public int maxProfit(int k, int[] prices) {
		int n = prices.length;
		int[][][] dp = new int[n+1][k+1][2];
		for(int i=0;i<=n;i++){
			for(int j=k;j>=1;j--){
				if(i == 0){
					dp[i][j][1] = Integer.MIN_VALUE;
				}else{
					dp[i][j][0] = Math.max(dp[i-1][j][0],dp[i-1][j][1]+prices[i-1]);
					dp[i][j][1] = Math.max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i-1]);
				}
			}
		}
		return dp[n][k][0];
    }

309.含冷冻期

public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n+2][2];
        dp[0][1] = dp[1][1] = Integer.MIN_VALUE;
        for(int i=2;i<=n+1;i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i-2]);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-2][0]-prices[i-2]);
        }
        return dp[n+1][0];
    }

714.含手续费

 public int maxProfit(int[] prices, int fee) {
//		int n = prices.length;
//		int[][] dp = new int[n+1][2];
//		dp[0][1] = Integer.MIN_VALUE;
//		for(int i=1;i<=n;i++){
//			dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i-1]);
//			dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-prices[i-1]-fee);
//		}
//		return dp[n][0];
		int dp_1 = Integer.MIN_VALUE;
		int dp_0 = 0;
		for(int v : prices){
			dp_0 = Math.max(dp_0,dp_1+v);
			dp_1 = Math.max(dp_1,dp_0-v-fee);
		}
		return dp_0;
    }

小结：

• 除了k次交易以外，其他5道题的时间复杂度都为O(n),对 prices 数组一次循环就够了
• 需要重点注意的Base 条件：非状态压缩解法，dp数组的一维要比 prices.length 多1，dp[0]表示第0天（正常从第一天开始遍历），这一天如果为持有状态则定义为负无穷
• Java 中数组定义后默认值为 0