动态规划-股票买卖_股票动态规划不限制持有

一、思路

1.基本思路

关键在于定义状态，一般来说最起码有两个状态：当天结束的时候持有股票和不持有股票，根据限制条件再细分状态种类，明确状态之间的转移关系。

2.空间优化

一般来说状态转移只用到上个时间的状态，可以做空间优化。

3.时间优化

对于限制比较少的题目考虑是否可以用贪心实现。

二、例题详解

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

求只交易一次的最大利润。

1）动规朴素版

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f[n][2];//第一维表示天数，第二维为0表示当天结束持有股票，1表示当天结束不持有股票，数组元素表示每天不同状态下的最大利润
        f[0][0] = -prices[0];
        f[0][1] = 0;
        for (int i = 1; i < n; i++) {
            f[i][0] = max(f[i - 1][0], -prices[i]);//当天持有股票可能是昨天就持有股票，或者昨天不持有股票、今天新买入
            f[i][1] = max(f[i - 1][1], f[i - 1][0] + prices[i]);//当天不持有股票可能是昨天就不持有股票，或者昨天持有股票、今天新卖出
        }
        return f[n - 1][1];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2）动规优化版

删掉第一维

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f[2];//第一维表示天数，第二维为0表示当天结束持有股票，1表示当天结束不持有股票，数组元素表示每天不同状态下的最大利润
        f[0] = -prices[0];
        f[1] = 0;
        for (int i = 1; i < n; i++) {
            f[0] = max(f[0], -prices[i]);
            f[1] = max(f[1], f[0] + prices[i]);
        }
        return f[1];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3）贪心

由于只交易一次，找到最大的一对price差值即为答案。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int minp = prices[0];
        int res = 0;
        for (int i = 1; i < prices.size(); i++) {
            res = max(res, prices[i] - minp);
            minp = min(minp, prices[i]);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12

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

不限制交易次数的最大利润，但不能同时进行多笔交易。

1）动规朴素版

和121唯一不同的地方在于，121只能交易一次，因此如果持有股票并且在今天新买入，利润只能是-prices[i]，而这题可以交易多次，因此需要加上前面的累计利润。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f[n][2];
        f[0][0] = -prices[0]; //0表示持有股票
        f[0][1] = 0;//1表示不持有股票
        for (int i = 1; i < n; i++) {
            f[i][0] = max(f[i - 1][0], f[i - 1][1] - prices[i]);//和121唯一不同的地方
            f[i][1] = max(f[i - 1][1], f[i - 1][0] + prices[i]);
        }
        return max(f[n - 1][0], f[n - 1][1]);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2）动规优化版

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f0 = -prices[0]; //0表示持有股票
        int f1 = 0;//1表示不持有股票
        for (int i = 1; i < n; i++) {
            f0 = max(f0, f1 - prices[i]);
            f1 = max(f1, f0 + prices[i]);
        }
        return f1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

3）贪心

由于交易次数没有限制，可以当天卖出再买入，a[j] - a[i] = (a[i+1]-a[i])+(a[i+2]-a[i+1])+…+(a[j]-a[j-1]),因此只要a[i]>a[i-1]就可以将其差值累加。若连续一段a[i]>a[i-1]，则相当于头尾交易一次。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int res = 0;
        for (int i = 1; i < prices.size(); i++) {
            res += max(0, prices[i] - prices[i - 1]);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10

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

最多可以完成两笔交易的最大利润。

1）动规朴素版

添加交易次数这一维度的状态。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f[n][2][3];//第一维表示天数，第二维表示是否持有股票，第三维表示今天结束时交易刺入（从买入开始计算）
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 3; k++) {
                    f[i][j][k] = 0;
                }
            }
        }
        //0表示持有股票，1表示不持有股票
        //f[i][0][0]没有意义，f[i][1][0]始终等于0，因此这两项不用更新
        f[0][0][0] = -1e5, f[0][0][2] = -1e5, f[0][0][1] = -prices[0];
        f[0][1][0] = 0, f[0][1][1] = -1e5, f[0][1][2] = -1e5;
        for (int i = 1; i < n; i++) {
            f[i][0][1] = max(f[i - 1][0][1], f[i - 1][1][0] - prices[i]);
            f[i][0][2] = max(f[i - 1][0][2], f[i - 1][1][1] - prices[i]);

            f[i][1][1] = max(f[i - 1][1][1], f[i - 1][0][1] + prices[i]);
            f[i][1][2] = max(f[i - 1][1][2], f[i - 1][0][2] + prices[i]);
        }
        return max(f[n - 1][1][0], max(f[n - 1][1][1], f[n - 1][1][2]));
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2）动规优化版

去掉天数这一维度。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int f[2][3];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                f[i][j] = 0;
            }
        }
        //0表示持有股票，1表示不持有股票
        f[0][0] = -1e5, f[0][2] = -1e5, f[0][1] = -prices[0];
        f[1][0] = 0, f[1][1] = -1e5, f[1][2] = -1e5;
        for (int i = 1; i < n; i++) {
            f[0][1] = max(f[0][1], f[1][0] - prices[i]);
            f[0][2] = max(f[0][2], f[1][1] - prices[i]);

            f[1][1] = max(f[1][1], f[0][1] + prices[i]);
            f[1][2] = max(f[1][2], f[0][2] + prices[i]);
        }
        return max(f[1][0], max(f[1][1], f[1][2]));
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

最多可以完成K笔交易的最大利润。

1）动规优化版

在123的基础上改变需要循环的交易次数即可，只展示优化版。

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        if (n < 2 || !k) return 0;
        int f[2][k + 1];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j <= k; j++) {
                f[i][j] = -1e5;
            }
        }
        f[0][1] = -prices[0];
        f[1][0] = 0;
        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                f[0][j] = max(f[0][j], f[1][j - 1] - prices[i]);
                f[1][j] = max(f[1][j], f[0][j] + prices[i]);
            }
        }
        int res = 0;
        for (int i = 0; i <= k; i++) {
            res = max(res, f[1][i]);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.LeetCode 309.最佳买卖股票时机含冷冻期

卖完一次股票后有一天的冷冻期，总交易次数没有限制。

1）动规朴素版

将不持有股票细分成在冷冻期和不在冷冻期两种状态。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp[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] = max(dp[i - 1][1]  - prices[i], dp[i - 1][0]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]);
            dp[i][2] = dp[i - 1][0] + prices[i];
        }
        return max(dp[n - 1][1], dp[n - 1][2]);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2）动规优化版

去掉天数这一维度。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp[3];
        dp[0] = -prices[0];//持有股票
        dp[1] = 0;//不持有股票，不在冷冻期
        dp[2] = 0;//不持有股票，在冷冻期
        for (int i = 1; i < n; i++) {
            dp[0] = max(dp[1]  - prices[i], dp[0]);
            dp[1] = max(dp[1], dp[2]);
            dp[2] = dp[0] + prices[i];
        }
        return max(dp[1], dp[2]);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.LeetCode 714.买卖股票的最佳时机含手续费

可以无限次地完成交易，但是你每笔交易都需要付手续费。

1）动规优化版

在122的基础上，卖出的时候减去手续费即可。

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        int f0 = -prices[0]; //0表示持有股票
        int f1 = 0;//1表示不持有股票
        for (int i = 1; i < n; i++) {
            f0 = max(f0, f1 - prices[i]);
            f1 = max(f1, f0 + prices[i] - fee);
        }
        return f1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13