LeetCode 股票系列全部题型大总结 动态规划

121. 买卖股票的最佳时机
两种实现方式，贪心和动态规划。贪心就是从左往右遍历，找到最小的值，然后找到当前差值最大的点。动态规划就是用二维dp数组，dp[i][0]表示第i天持有股票，dp[i][1]表示第i天不持有股票。初始化为dp[0][0]=-prices[0],dp[i][1] = 0。递推公式为：dp[i][0] = max(dp[i-1][0], -prices[i]);
dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i]);如果第i天持有股票，要么是前一天就持有，要么是前一天不持有今日刚买进；如果第i天不持有股票，要么是前一天也不持有，要么是前一天持有，但是今天卖出。取两者的较大值作为第i天持有的最大现金。i从1开始遍历。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
    	//贪心方法，左边找到最小，右边找到最大
        // int res =0 ;
        // int low = INT_MAX;
        // for (int i = 0; i < prices.size(); i++) {
        //     low = min(low, prices[i]);
        //     res = max(res, prices[i]-low);
        // }
        // return res;
        // 动态规划方法
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2,0));
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            // 持有股票
            dp[i][0] = max(dp[i-1][0], -prices[i]);
            // 不持有股票
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i]);
        }
        return dp[len-1][1];
    }
};

122. 买卖股票的最佳时机 II
贪心：每一天都要取大于零的额度，反正买卖无数次，每天能赚一点是一点，有得赚才买进卖出，否则不买。
动态规划：唯一和上一题有区别的地方在于如果第i天持有股票，递推关系为：dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i]);即可能前一天已经有存余了，不再是-prices[i]。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // 贪心
        // int res = 0;
        // for (int i = 1; i<prices.size(); i++) {
        //     if (prices[i]-prices[i-1] > 0){
        //         res += prices[i] - prices[i-1];
        //     }
        // }
        // 动态规划
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2,0));
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            // dp[i][0]表示第i天持有股票的最大现金
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i]);
            // dp[i][1]表示第i天不持有股票的最大现金
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i]);
        }
        return dp[len-1][1];

        // return res;
    }
};

123. 买卖股票的最佳时机 III
最多两次交易，这样就限制了交易次数，定义五个状态，如注释所示。但是要注意因为买卖有顺序，必须要按照顺序交易，比如第一买入后才可以第一次卖出，同时第二次买入必须在第一次卖出之后（不可以同时持有多只股票）。因此递推公式只能从本身状态和前一个状态得到。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) {
            return 0;
        }
        vector<vector<int>> dp(prices.size(), vector<int>(5 ,0));
        // dp[i][0]表示不做任何操作；
        // dp[i][1]表示第一次股票持有中的现金
        // dp[i][2]表示第一次股票未持有
        // dp[i][3]表示第二次股票持有中
        // dp[i][4]表示第二次股票未持有
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); 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]);
            dp[i][4] = max(dp[i-1][4], dp[i-1][3]+prices[i]);
        }
        // for (auto vec : dp){
        //     for(auto i : vec) {
        //         cout<<i<<" ";
        //     }
        //     cout<<endl;
        // }
        return dp[prices.size()-1][4];
    }
};

188. 买卖股票的最佳时机 IV
最多k次交易，则类比最多两次交易来写，dp数组中奇数列表示持有股票，偶数列表示表示不持有股票。每个状态只能由装态本身以及前一个状态递推得到。

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

309. 买卖股票的最佳时机含冷冻期
我感觉是最难的一题。因为今日卖出股票，明天就成为冷冻日，因此需要将今日卖出股票单独划分为一个状态。四个状态的定义以及递推公式如代码所示，持有股票可能是前一天持有，状态延续；也可能前一天保持卖出状态，今天买入；也可能前一天冷冻日，今天买入。保持卖出股票可能前一天也是卖出状态，延续；也可能是前一天冷冻日，转移。今日卖出股票，就是前一日是持有股票状态。今日冷冻期就是前一天是卖出股票的状态，转移。最后的结果要在保持卖出，今日卖出和冷冻期三个状态中取最大值得到最大受益。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size(); 
        if (n == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(4, 0));
        dp[0][0] = -prices[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][1], dp[i-1][3]);
            // 今日卖出股票
            dp[i][2] = dp[i-1][0]+prices[i];
            // 冷冻期
            dp[i][3] = dp[i-1][2];
        }
        return max(dp[n-1][1],max(dp[n-1][2], dp[n-1][3]));
    }
};

714. 买卖股票的最佳时机含手续费
含手续费就是每次卖出交一笔钱，即给每次卖出的时候受益减去一个fee。

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        if (n == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        dp[0][0] = -prices[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];
    }
};

最近准备考研复试，可能就会好几天才写一篇，做点总结，写写心得。我是真心想把算法学好的。加油，北邮见！