买卖股票的最佳时机六题全解

121. 买卖股票的最佳时机
     给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

 //只允许买卖一次
    public static int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0){
            return 0;
        }
        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]);
            //k - 1-->0\-1
            dp[i][1] = Math.max(dp[i - 1][1],-prices[i]);//dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
        }
        return dp[n - 1][0];
    }
    //只允许买卖一次
    public static int maxProfit_2(int[] prices) {
        if (prices == null || prices.length == 0){
            return 0;
        }
        int n = prices.length;
        //基本情况
        int dp_i0 = 0;
        int dp_i1 = -prices[0];
        for(int i = 1; i < n; i ++){
             dp_i0 = Math.max(dp_i0, dp_i1 + prices[i]);
            //k - 1-->0\-1
             dp_i1 = Math.max(dp_i1, -prices[i]);//dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
        }
        return dp_i0;
    }

122. 买卖股票的最佳时机 II
     给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

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

//可以买卖无限次
    public static int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0){
            return 0;
        }
        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], dp[i - 1][0] - prices[i]);//今天持有股票，昨天持有 或者 今天(用的是昨天未持有股票的钱)买入
        }
        return dp[n - 1][0];
    }
    //可以买卖无限次
    public static int maxProfit_2(int[] prices) {
        if (prices == null || prices.length == 0){
            return 0;
        }

        //第一次交易
        int dp_i0 = 0;
        int dp_i1 = -prices[0];

        for (int i = 1; i < prices.length; i ++){
            //今天没有持有股票，昨天没持有或者今天 卖出昨天持有的股票
            dp_i0 = Math.max(dp_i0,dp_i1 + prices[i]);
            //今天持有股票，昨天持有 或者 今天(用的是昨天未持有股票的钱)买入
            dp_i1 = Math.max(dp_i1,dp_i0 - prices[i]);
        }
        return dp_i0;
    }

123. 买卖股票的最佳时机 III
     给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

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

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

示例 1:

//最多可以买卖 2次
    public static int maxProfit(int[] prices) {
        //第一次交易
        int dp_i10 = 0;
        int dp_i11 = Integer.MIN_VALUE;

        //第二次交易
        int dp_i20 = 0;
        int dp_i21 = Integer.MIN_VALUE;

        for(int price : prices) {
            //第一次交易
            //今天我没有持有股票 昨天就没有持有，然后今天选择 rest，我昨天持有股票，但是今天我 sell
            dp_i10 = Math.max(dp_i10, dp_i11 + price);//
            //今天我持有着股票，要么我昨天就持有着股票，然后今天选择 rest我昨天本没有持有，但今天我选择 buy
            dp_i11 = Math.max(dp_i11,-price);//因为是第一次交易买入，负账 即 -price

            //第二次交易
            //今天我没有持有股票 昨天就没有持有，然后今天选择 rest，我昨天持有股票，但是今天我 sell
            dp_i20 = Math.max(dp_i20, dp_i21 + price);
            //今天我持有着股票，要么我昨天就持有着股票，然后今天选择 rest我昨天本没有持有，但今天我选择 buy
            dp_i21 = Math.max(dp_i21, dp_i10 - price);//第二次交易，使用第一次赚的钱买入
        }

        return dp_i20;
    }

188. 买卖股票的最佳时机 IV
     给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

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

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

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

        if(k > prices.length / 2){
            return maxProfitOfInfinity(prices);
        }

        int [][] dp = new int[k][2];
        for(int j = 0; j < k; j ++) {
            dp[j][1] = Integer.MIN_VALUE;
        }

        for(int price : prices) {
            for(int j = 0; j < k; j++){
                if(j == 0) {//第一次买入
                    dp[j][1] = Math.max(dp[j][1], -price);
                } else {
                    //今天我持有着股票，要么我昨天就持有着股票，然后今天选择 rest我昨天本没有持有，但今天我选择 buy
                    dp[j][1] = Math.max(dp[j][1], dp[j - 1][0] - price);
                }
                //今天我没有持有股票
                //昨天就没有持有，然后今天选择 rest，我昨天持有股票，但是今天我 sell
                dp[j][0] = Math.max(dp[j][0], dp[j][1] + price);

            }
        }

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

    //对k没有限制，如果k > prices.length / 2 , k 的限制相当于无
    public int maxProfitOfInfinity(int [] prices) {
        int n = prices.length;
        if(n < 2) {
            return 0;
        }

        int dp_i0 = 0;
        int dp_i1 = Integer.MIN_VALUE;

        for(int price : prices) {
            //今天我没有持有股票
            //昨天就没有持有，然后今天选择 rest，我昨天持有股票，但是今天我 sell
            dp_i0 = Math.max(dp_i0, dp_i1 + price);
            //今天我持有着股票，要么我昨天就持有着股票，然后今天选择 rest我昨天本没有持有，但今天我选择 buy
            dp_i1 = Math.max(dp_i1, dp_i0 - price);
        }

        return dp_i0;
    }

309. 最佳买卖股票时机含冷冻期
     给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

    public static int maxProfit(int[] prices) {
        if (prices == null || prices.length < 2)
            return 0;

        int n = prices.length;
        int[][] dp = new int[n][3];

        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        dp[0][2] = 0;

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

        return dp[n - 1][1] > dp[n - 1][2] ? dp[n - 1][1] : dp[n - 1][2];
    }

    //含冷冻期，交易无限次
    public static int maxProfit_2(int[] prices) {
        if (prices == null || prices.length < 2){
            return 0;
        }
        int dp_i0 = 0;//不持有股票
        int dp_i1 = 0;//处于冷冻期
        int dp_i2 = -prices[0];//持有股票
        for (int i = 1; i < prices.length; i ++){
            //今天不持有股票，要么昨天没持有，要么今天处于冷冻期
            dp_i0 = Math.max(dp_i0,dp_i1);

            //处于冷冻期，说明昨天卖出了股票
            dp_i1 = dp_i2 + prices[i];

            //今天持有股票，要么昨天持有，要么今天买入（使用不处于冷冻期的钱）。
            dp_i2 = Math.max(dp_i2,dp_i0 - prices[i]);
        }
        return dp_i0 > dp_i1 ? dp_i0 : dp_i1;
    }

714. 买卖股票的最佳时机含手续费
     给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

 public static 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 maxProfit_2(int[] prices, int fee){
        if(prices == null || prices.length < 2){
            return 0;
        }
        int dp_i0 = 0;
        int dp_i1 = -prices[0];
        for(int i = 1; i < prices.length; i ++){
            dp_i0 = Math.max(dp_i0,dp_i1 + prices[i] - fee);
            dp_i1 = Math.max(dp_i1,dp_i0 - prices[i]);
        }
        return dp_i0;
    }