算法训练营day41 动态规划⑧ 121. 122.123.买卖股票的最佳时机1.2.3

        动态规划的第八篇博客！说实话，我感觉这三道题的动态规划思路都挺难的，第一题要好好理解，后面才能顺利进行

121. 买卖股票的最佳时机1

        注意这道题只能买一天，卖一天，单次结果只和某两天有关

暴力解法，遍历所有的买卖天数对

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            for (int j = i + 1; j < prices.size(); j++){ 
                //内外循环，确定段落区间
                result = max(result, prices[j] - prices[i]);
            }
        }
        return result;
    }
};

贪心算法

• 遍历价格数组中的每一天价格prices[i]
• 对于每一天，首先更新low为当前最低价格（取low和prices[i]中的较小值）（*）
• 然后计算当前价格减去最低价格的利润，并与result比较，取较大值更新result
• 遍历完成后，result就是能获得的最大利润

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int low = INT_MAX;
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            low = min(low, prices[i]);  // 取最左最小价格
            result = max(result, prices[i] - low); // 直接取最大区间利润
        }
        return result;
    }
};

动态规划

• 确定dp数组（dp table）以及下标的含义

        dp[i][0] 表示第i天持有股票所得最多现金 （允许负数）

        dp[i][1] 表示第i天不持有股票所得最多现金

• 确定递推公式

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

1. 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
2. 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]

        那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

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

1. 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
2. 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]

        同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

• 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;

• 确定遍历顺序

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

• 举例推导dp数组

        其实这个解法相当于，时刻记录最便宜的买入，同时由前到后不断记录最贵的卖出，感觉和贪心算法有相似的地方

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        if length == 0:
            return 0
        dp = [[0] * 2 for _ in range(length)]
        # 初始化        
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        # 递推公式
        for i in range(1, length):
            dp[i][0] = max(dp[i-1][0], -prices[i])
            dp[i][1] = max(dp[i-1][1], prices[i] + dp[i-1][0])
            # 重点在这两个公式里！
            # 公式不要弄错
        return dp[-1][1]

动态规划空间优化（类一维数组）

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        dp = [[0] * 2 for _ in range(2)] #注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        for i in range(1, length):
            dp[i % 2][0] = max(dp[(i-1) % 2][0], -prices[i])
            dp[i % 2][1] = max(dp[(i-1) % 2][1], prices[i] + dp[(i-1) % 2][0])
        return dp[(length-1) % 2][1]

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

贪心算法

        计算差分，所有负数相加即可，详见

算法训练营day28 贪心算法②122.买卖股票的最佳时机II、55. 跳跃游戏、 45.跳跃游戏II 、1005.K次取反后最大化的数组和-CSDN博客

动态规划

        这个题目的不同在于可以多次买卖股票，而这次的动态规划的主要不同在于：每次“地基”的计算方法，对于“地基”的理解，和背包问题的一维数组有相似的地方，主要就是[0][*]的计算，因为[1][*]在计算过程中，需要上一天的[0][*]

        具体来讲就是，[0][*]部分需要增加累加的部分

        其实要明白，这两个数组之间没有太多连贯的关系，主要在于不断地更新数据

        这个地方推荐大家使用“举例推导dp数组”，来更详细了解代码具体执行过程

这里重申一下dp数组的含义：

• dp[i][0] 表示第i天持有股票所得现金。
• dp[i][1] 表示第i天不持有股票所得最多现金

如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来（唯一修改位置）

• 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][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:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        dp = [[0] * 2 for _ in range(length)]
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        for i in range(1, length):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i]) 
            # 持有股票
            # 注意这里是和121. 买卖股票的最佳时机唯一不同的地方，这个地方很关键
            # 增加的部分是已经赚到钱的证明
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i])
            # 不持有股票
        return dp[-1][1]

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

        关键在于至多买卖两次，次数不同于一次

• 确定dp数组以及下标的含义

        一天一共就有五个状态：

1. 没有操作 （其实我们也可以不设置这个状态）
2. 第一次持有股票
3. 第一次不持有股票
4. 第二次持有股票
5. 第二次不持有股票

        dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。

• 确定递推公式

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

• 操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
• 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][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])

        同理可推出剩下状态部分：

1. dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
2. dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

• dp数组如何初始化

        第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;

        第0天做第一次买入的操作，dp[0][1] = -prices[0];

        这里可以理解当天买入，当天卖出，所以dp[0][2] = 0;

        同理，第二次买入操作，初始化为：dp[0][3] = -prices[0];

        第二次卖出初始化dp[0][4] = 0;

• 确定遍历顺序

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

• 举例推导dp数组

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [[0] * 5 for _ in range(len(prices))]
        dp[0][1] = -prices[0]
        dp[0][3] = -prices[0]
        for i in range(1, len(prices)):
            dp[i][0] = dp[i-1][0]
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
            dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
            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])
        return dp[-1][4]