动态规划之股票系列

只允许买卖一次

题目

思路分析

dp[]含义

1、dp[i][0]：第i天持有股票时最大的收益；
2、dp[i][1]：第i天不持有股票时最大的收益；

动态转移方程

1、dp[i][0]：第i天持有股票时最大的收益；
（1）情况1：前面已经买入，第i天不做任何操作，即dp[i][0] = dp[i-1][0]；
（2）情况2：前面没有买入，第i天买入，即dp[i][0] = -prices[i]；
==> dp[i][0] = max(dp[i-1][0]), 0-prices[i])

2、dp[i][1]：第i天不持有股票时最大的收益；
（1）情况1：前面没有买入，第i天也不买入，即dp[i][1] = dp[i-1][1]；
（2）情况2：前面已经买入，第i天卖出，即dp[i][0] = dp[i-1][0] + prices[i]；
==> dp[i][1] = max(dp[i-1][1]), dp[i-1][0] + prices[i]);

初始化

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

代码实现

int maxProfit(vector<int>& prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(2, 0));

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

    return dp[n-1][1];
}

允许买卖多次

题目

思路分析

dp[]含义

1、dp[i][0]：第i天持有股票时最大的收益；
2、dp[i][1]：第i天不持有股票时最大的收益；

动态转移方程

1、dp[i][0]：第i天持有股票时最大的收益；
（1）情况1：前面已经买入没有卖出，第i天不做任何操作，即dp[i][0] = dp[i-1][0]；
（2）情况2：前面存在买入卖出，第i天买入，即dp[i][0] = dp[i-1][1]-prices[i]；
==> dp[i][0] = max(dp[i-1][0]), dp[i-1][1]-prices[i])

2、dp[i][1]：第i天不持有股票时最大的收益；
（1）情况1：前面存在买入卖出，第i天也不买入，即dp[i][1] = dp[i-1][1]；
（2）情况2：前面已经买入，第i天卖出，即dp[i][0] = dp[i-1][0] + prices[i]；
==> dp[i][1] = max(dp[i-1][1]), dp[i-1][0] + prices[i]);

初始化

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

代码实现

int maxProfit(vector<int>& prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(2, 0));

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

    return dp[n-1][1];
}

允许买卖多次，但是卖出有手续费

题目

思路分析

dp[]含义

1、dp[i][0]：第i天持有股票时最大的收益；
2、dp[i][1]：第i天不持有股票时最大的收益；

动态转移方程

1、dp[i][0]：第i天持有股票时最大的收益；
（1）情况1：前面已经买入没有卖出，第i天不做任何操作，即dp[i][0] = dp[i-1][0]；
（2）情况2：前面存在买入卖出，第i天买入，即dp[i][0] = dp[i-1][1]-prices[i]；
==> dp[i][0] = max(dp[i-1][0]), dp[i-1][1]-prices[i])

2、dp[i][1]：第i天不持有股票时最大的收益；
（1）情况1：前面存在买入卖出，第i天也不买入，即dp[i][1] = dp[i-1][1]；
（2）情况2：前面已经买入，第i天卖出，即dp[i][0] = dp[i-1][0] + prices[i] - fee；
==> dp[i][1] = max(dp[i-1][1]), dp[i-1][0] + prices[i] - fee);

初始化

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

代码实现

int maxProfit(vector<int>& prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(2, 0));

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

    return dp[n-1][1];
}

允许买卖2次

题目

思路分析

dp[]含义

1、dp[i][0]：第i天第一次持有股票时最大的收益；
2、dp[i][1]：第i天第一次不持有股票时最大的收益；
3、dp[i][2]：第i天第二次持有股票时最大的收益；
4、dp[i][3]：第i天第二次不持有股票时最大的收益；

动态转移方程

1、dp[i][0]：第i天第一次持有股票时最大的收益；
（1）情况1：前面已经买入，第i天不做任何操作，即dp[i][0] = dp[i-1][0]；
（2）情况2：前面没有买入，第i天买入，即dp[i][0] = -prices[i]；
==> dp[i][0] = max(dp[i-1][0]), -prices[i])

2、dp[i][1]：第i天第一次不持有股票时最大的收益；
（1）情况1：前面没有买入，第i天不做任何操作，即dp[i][1] = dp[i-1][1]；
（2）情况2：前面已经买入，第i天卖出，即dp[i][1] = dp[i-1][0] + prices[i]；
==> dp[i][1] = max(dp[i-1][1]), dp[i-1][0] + prices[i])

3、dp[i][2]：第i天第二次持有股票时最大的收益；
（1）情况1：前面已经第二次买入，第i天不做任何操作，即dp[i][2] = dp[i-1][2]；
（2）情况2：前面没有第二次买入，第i天买入，即dp[i][2] = dp[i-1][1]-prices[i]；
==> dp[i][0] = max(dp[i-1][2]), dp[i-1][1] - prices[i])

4、dp[i][3]：第i天第二次不持有股票时最大的收益；
（1）情况1：前面已经卖出没有买入，第i天不做任何操作，即dp[i][3] = dp[i-1][3]；
（2）情况2：前面存在买入，第i天卖出，即dp[i][3] = dp[i-1][2] + prices[i]；
==> dp[i][3] = max(dp[i-1][3]), dp[i-1][2] + prices[i])

初始化

dp[0][0] = -prices[0]
dp[0][1] = 0
dp[0][2] = -prices[0] // 可以理解为当天买入卖出再买入
dp[0][3] = 0

代码实现

int maxProfit(vector<int>& prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(4, 0));

    dp[0][0] = 0 - prices[0]; dp[0][1] = 0;
    dp[0][2] = 0 - prices[0]; dp[0][3] = 0;
    for(int i = 1; i < n; ++i){
        dp[i][0] = max(dp[i-1][0], 0 - prices[i]);
        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]);
    }

    return dp[n-1][3];
}

允许买卖K次

题目

思路分析

dp[]含义

参考上面买入卖出两次的场景

动态转移方程

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

初始化

for(int j = 1; j < 2k; j+=2)
	dp[0][j] = 0 - prices[i];

代码实现

int maxProfit(int k, vector<int>& prices) {
int n = prices.size();
int m = 2 * k;
vector<vector<int>> dp(n, vector<int>(m, 0));

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

return dp[n-1][m-1];
}

允许买卖多次，但有冷冻期

题目

思路分析

dp[]含义

1、dp[i][0]：第i天持有股票时最大的收益；
2、dp[i][1]：第i天保持卖出时最大的收益；
3、dp[i][2]：第i天卖出股票时最大的收益；
4、dp[i][3]：第i天是冷冻期时最大的收益；

动态转移方程

1、dp[i][0]：第i天持有股票时最大的收益；
（1）情况1：前面已经买入，第i天不做任何操作，即dp[i][0] = dp[i-1][0]；
（2）情况2：前面已经卖出，第i-1天不是冷冻期，第i天买入，即dp[i][0] = dp[i-1][1] - prices[i]；
（2）情况3：前面已经卖出，第i-1天是冷冻期，第i天买入，即dp[i][0] = dp[i-1][3] - prices[i]；
==> dp[i][0] = max(dp[i-1][0]), dp[i-1][1] - prices[i], dp[i-1][3] - prices[i])

2、dp[i][1]：第i天保持卖出时最大的收益；
（1）情况1：前一天是冷冻期，保持前一天的卖出状态：dp[i][1] = dp[i-1][3]
（1）情况2：前一天不是冷冻期，保持前一天的卖出状态：dp[i][1] = dp[i-1][1]
==> dp[i][1] = max(dp[i-1][3], dp[i-1][1]);

3、dp[i][2]：第i天卖出股票时最大的收益；
（1）只有一种情况
==> dp[i][2] = dp[i-1][0] + prices[i];

2、dp[i][3]：第i天是冷冻期时最大的收益；
（1）只有一种情况，那就是i-1天卖出股票
==> dp[i][3] = dp[i-1][2];

初始化

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

代码实现

int maxProfit(vector<int>& prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(4, 0));

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

    return max(max(dp[n-1][1], dp[n-1][2]), dp[n-1][3]);
}