第九章 动态规划part08

121. 买卖股票的最佳时机

文章讲解

思路

• 贪心的解法：

class Solution {
    public int maxProfit(int[] prices) {
        // 找到一个最小的购入点
        int low = Integer.MAX_VALUE;
        // res不断更新，直到数组循环完毕
        int res = 0;
        for(int i = 0; i < prices.length; i++){
            low = Math.min(prices[i], low);
            res = Math.max(prices[i] - low, res);
        }
        return res;
    }
}

• 动态规划

1. 确定dp数组（dp table）以及下标的含义
   dp[i][0] 表示第i天持有股票所得最多现金 ，dp[i][1] 表示第i天不持有股票所得最多现金

2. 确定递推公式
   如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来

   • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
   • 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
   • 那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

   如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来

   • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
   • 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]
   • 同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

3. dp数组如何初始化
   由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出其基础都是要从dp[0][0]和dp[0][1]推导出来。
   那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
   dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;

4. 确定遍历顺序
   从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。

5. 举例推导dp数组
   以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：

   
   
   image.png

class Solution {
    public int maxProfit(int[] prices) {
        //版本1
        int len = prices.length;
        if(prices == null || len == 0) return 0;

        // dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[len][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < len; i++){
            dp[i][0] = Math.max(dp[i-1][0], -prices[i]);
            dp[i][1] = Math.max(dp[i-1][1], prices[i] + dp[i-1][0]);
        }
        return dp[len-1][1];
    }
}

从递推公式可以看出，dp[i]只是依赖于dp[i - 1]的状态。

dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

那么我们只需要记录 当前天的dp状态和前一天的dp状态就可以了，可以使用滚动数组来节省空间
i % 2 的作用是用来在 dp 数组的两行之间切换，使得我们能够复用数组空间。例如：

• 当 i 为偶数时，i % 2 为 0，表示使用 dp 数组的第 0 行来存储第 i 天的状态。
• 当 i 为奇数时，i % 2 为 1，表示使用 dp 数组的第 1 行来存储第 i 天的状态。

这样，我们就可以使用 dp[0] 和 dp[1] 两行来分别存储当前和前一天的状态，达到节省空间的目的。

class Solution {
    public int maxProfit(int[] prices) {
        //版本1
        int len = prices.length;
        if(prices == null || len == 0) return 0;

        // dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[2][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < len; i++){
            dp[i % 2][0] = Math.max(dp[(i-1) % 2][0], -prices[i]);
            dp[i % 2][1] = Math.max(dp[(i-1) % 2][1], prices[i] + dp[(i-1) % 2][0]);
        }
        return dp[(len-1) % 2][1];
    }
}

122.买卖股票的最佳时机II

文章讲解

思路
dp数组的含义：

• dp[i][0] 表示第i天持有股票所得现金。
• dp[i][1] 表示第i天不持有股票所得最多现金
  注意这里和121. 买卖股票的最佳时机 (opens new window)唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况。
• 本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
  那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金 减去 今天的股票价格 即：dp[i - 1][1] - prices[i]。
  再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
  • 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[2];
        // 0代表持有，1代表卖出
        dp[0] = -prices[0];
        dp[1] = 0;
        for(int i = 1; i <= prices.length; i++){
            //第i天持有; 或前一天持有（前一天持有的话，之前就是卖出的状态，就要用dp[1]减去前一天的价格）
            dp[0] = Math.max(dp[0], dp[1] - prices[i - 1]);
            //第i天卖出；或前一天卖出(前一天卖出的话，先前就是持有的状态，再加上前一天的收益)
            dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
        }
        return dp[1]; //二维数组应该返回length-1，但是这里改了for循环里 i <= prices.length
    }
}

123.买卖股票的最佳时机III

这道题一下子就难度上来了，关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
文章讲解

思路

• 关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

1. 确定dp数组以及下标的含义
   一天一共就有五个状态，

   • 没有操作 （其实我们也可以不设置这个状态）
   • 第一次持有股票
   • 第一次不持有股票
   • 第二次持有股票
   • 第二次不持有股票
     dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
     需要注意：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票

2. 确定递推公式

• 达到dp[i][1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
  • dp[i][1]一定是选最大的，所以dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

• 同理dp[i][2]也有两个操作：

  • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
  • 所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

• 同理可推出剩下状态部分：
  dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

3. dp数组如何初始化
   第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
   第0天做第一次买入的操作，dp[0][1] = -prices[0];
   第0天做第一次卖出的操作，这个初始值应该是多少呢？
   此时还没有买入，怎么就卖出呢？ 其实大家可以理解当天买入，当天卖出，所以dp[0][2] = 0;
   第0天第二次买入操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？
   第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后再买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
   所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
   同理第二次卖出初始化dp[0][4] = 0;

4. 确定遍历顺序
   从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5. 举例推导dp数组
   以输入[1,2,3,4,5]为例

   
   
   image.png

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;

        /*
         * 定义 5 种状态:
         * 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出
         */
        int[][] dp = new int[len][5];
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for(int i = 1; i < len; i++){
            dp[i][1] = Math.max(dp[i - 1][1], 0 - prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[len - 1][4];
         
    }
}