dp分类--状态枚举

一、股票系列

股票系列常见提问方式：

给定n天的股票价格，用户可以买入和卖出股票且交易次数（买入+卖出算一次交易）最多k次，计算可以获得的最大收益？

注意不同于取元素，每天的操作是不同的因此对应买入和卖出操作将元素状态分为有没有持股，所以元素状态必须作为dp状态；

1、最佳买卖股票时机含冷冻期 309

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。​设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例 1:
输入: prices = [1,2,3,0,2]
输出: 3

元素状态必须作为dp状态，因此是二维dp数组dp[i][0]表示第i天不持股， dp[i][1]表示第i天持股。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2));
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; ++i) {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            //第二天持股最大收益：前两天买入的最大值，因为两天内无法交易两次
            if (i == 1) dp[i][1] = max(-prices[0], -prices[1]);
            else dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i]);
        }
        return dp[n-1][0];
    }
};

2、买卖股票的最佳时机含手续费 714

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。返回获得利润的最大值。
示例 1：
输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8

将元素状态作为dp状态后，每次扣费可以在卖出股票时进行。这里dp[i][0]只依赖dp[i-1][0]和dp[i-1][1]，所以省略第一维度：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<int> dp(2);
        dp[1] = -prices[0];
        for (int i=1;i < n; ++i) {
            dp[0] = max(dp[0], dp[1] + prices[i] - fee); 
            dp[1] = max(dp[1], dp[0] - prices[i]);
        }
        return max(dp[0], dp[1]);
    }
};

3、买卖股票的最佳时机 III 123

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
示例 1:
输入：prices = [3,3,5,0,0,3,1,4]
输出：6

交易次数受限制，这个限制条件也必须作为dp状态；因此一共是三维dp数组：dp[i][j][0]表示第i天第i次不持股， dp[i][j][1]表示第i天第i次持股。
注意可以优化掉第一维，因为只依赖上一维度

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        //第几天/交易次数/有没有股
        //次数维度使用3，是为了表示的含义更明确
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(3, vector<int>(2)));
        //初始化：考虑第一次持有的收益，第一次不持股的收益是0不用再赋值了
        dp[0][1][1] = -prices[0];
        dp[0][2][1] = -prices[0];

        for (int i = 1; i < n; ++i) {
            dp[i][1][0] = max(dp[i-1][1][0], dp[i-1][1][1] + prices[i]);
            dp[i][1][1] = max(dp[i-1][1][1], -prices[i]);//第一次交易的利润就是买入价格-prices[i]

            dp[i][2][0] = max(dp[i-1][2][0], dp[i-1][2][1] + prices[i]);
            dp[i][2][1] = max(dp[i-1][2][1], dp[i-1][1][0] - prices[i]);
        }
        return dp[n-1][2][0];
    }
};

4、 买卖股票的最佳时机 IV 188

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
示例 1：
输入：k = 2, prices = [2,4,1]
输出：2

参考上面示例

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (k == 0 || prices.empty()) {
            return 0;
        }
        int n = prices.size();
        //第几天/第几次/有没有股
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(k+1, vector<int>(2)));
        for (int i=1;i <= k; ++i) {
            dp[0][i][1] = -prices[0];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; ++j) {
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0]-prices[i]);//这里第一次持有收益是-prices[i],但是dp[0][0]刚好是0计算结果可以统一。
            }
        }
        return dp[n-1][k][0];
    }
};