买卖股票的最佳时间含手续费的代码实现

//动态规划算法
/*
思路：维护两个变量 cash、hold，前者表示当我们不持有股票时的最大利润，后者表示当我们持有股票时的最大利润。
在第 i 天时，我们需要根据第 i−1天的状态来更新 cash
对于 cash我们可以保持不变，或者将手上的股票卖出，状态转移方程为 cash = max(cash, hold + prices[i] - fee)

对于 hold，我们可以保持不变，或者买入这一天的股票，状态转移方程为 hold = max(hold, cash - prices[i])

public int maxProfit(int[] prices, int fee) {
        if(prices.length < 2) {
            return 0;
        }

        int len = prices.length;
        int [][] dp = new int [len][2];
        dp[0][0] = 0;
        dp[0][1] = - prices[0];

        for(int i = 1; i < len; i ++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }

        return dp[len - 1][0];
    }


public static int getMaxProfit(int [] prices, int fee) {
       return getMaxProfitByViolence(prices,0,fee);
    }

    //暴力枚举所有的结果-->正确，但运行超时，时间复杂度为O(n^n)
    public static int getMaxProfitByViolence(int [] prices, int s,int fee) {
        if(s >= prices.length) {
            return 0;
        }

        int max = 0;
        for(int i = s; i < prices.length; i ++) {
            int maxProfit = 0;
            for(int j = i + 1; j < prices.length; j ++) {
                if(prices[j] - prices[i] > fee) {
                    int profit = getMaxProfitByViolence(prices,j + 1, fee) + prices[j] - prices[i] - fee;
                    if(profit > maxProfit) {
                        maxProfit = profit;
                    }
                }
            }

            if(maxProfit > max) {
                max = maxProfit;
            }
        }

    return max;
    }