动态规划（七）：买卖股票发大财

一、买卖股票（单次买卖，持有一支）

121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

1、dp数组含义

我们使用二维数组记录第i天的两种状态
dp[i][0]:第i天不持有股票手中的现金
dp[i][1]:第i天持有股票手中的现金

2、递推公式

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

• 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
• 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i](注意：这里是因为只限制了买一次股票，因此如果第i天买入，手中现金就是-prices[i]，和前一天没有关系)

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

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

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

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

3、初始化

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

4、遍历顺序

从前往后遍历

5、最后返回值

最后返回一定是dp[prices.size() - 1][1]，因为最后一天的时候肯定是不持有股票才能赚钱

解题代码

// 版本一
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2));
        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], prices[i] + dp[i - 1][0]);
        }
        return dp[len - 1][1];
    }
};

由于dp数组第二个维度只有两维，因此可以使用pair进行优化

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<pair<int, int>> dp(prices.size());

        dp[0].first = -prices[0];
        dp[0].second = 0;

        for(int i = 1; i < prices.size(); i++){
            dp[i].first = max(dp[i - 1].first, -prices[i]);
            dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);
        }

        if(dp[prices.size() - 1].second < 0) return 0;
        return dp[prices.size() - 1].second;
    }
};

由于dp数组只有两个维度，因此可以使用滚动数组优化为一维dp数组

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            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[(len - 1) % 2][1];
    }
};

二、买卖股票（多次买卖，持有一支）

122.给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

和单次买卖相比，只有递推公式发生了变化：

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

• 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1].first
• 第i天买入股票，所得现金就是买入今天的股票后所得现金即：dp[i - 1].second - prices[i](注意：这里是因为只限制了买一次股票，因此如果第i天买入，手中现金就是-prices[i]，和前一天没有关系)

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

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
        vector<pair<int, int>> dp(prices.size());

        dp[0].first = - prices[0];
        dp[0].second = 0;

        for(int i = 1; i < prices.size(); i++){
            dp[i].first = max(dp[i-1].first, dp[i - 1].second - prices[i]);
            dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);
        }
        
        if(dp[prices.size() - 1].second < 0) return 0;
        return dp[prices.size() - 1].second; 
    }
};

本题还可以使用贪心算法解决，收集每天的正收益即可

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])
            res += prices[i] - prices[i - 1];
        }
        return res;
    }
};

滚动数组版本

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; 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], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

三、买卖股票（2次买卖，持有一支）

123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

1、dp数组

当最多买卖两次的时候，一天的状态可以有四个：

• dp[i][0]：第一次买入状态
• dp[i][1]：第一次卖出状态
• dp[i][2]：第二次买入状态
• dp[i][3]：第二次卖出状态
  注意：这个状态是一个持续的过程，如第一次买入后，第二次买入前，均处于第一次买入状态

2、递推公式

每个状态都分为当天发生该状态和该状态在之前发生过两种，取两者最大值即可。注意第一次买入如果是当前买入，dp[i][0] = -prices[i]，因为第一次买入前手中现金就是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]);
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]);

3、初始化

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

注意：在初始化过程中dp[0][2]也要初始化为-prices[0]，虽然第一天不可能买第二次。题目要求最多买卖两次，但我们根据实际情况可能只买卖了一次，或者不买卖，这样初始化：

• 在我们只买卖一次的时候将dp[i][0]和dp[i][1]的状态同步到了dp[i][2]和dp[i][3]；
• 当我们买卖多次的时候，dp[i][0]和dp[i][1]在买卖一次后保持不变，dp[i][2]和dp[i][3]仅需在买卖第一次赚的钱基础上进行变化

这样，不管我们买卖了几次，dp[i][3]均是在要求内赚的最多的钱

4、遍历顺序

从前到后

5、代码实现

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;

        vector<vector<int>> dp(prices.size(), vector<int>(4, 0));

        dp[0][0] = -prices[0];
        dp[0][2] = -prices[0];
        
        

        for(int i = 1; i < prices.size(); 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]);
            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[prices.size() - 1][3];
    }
};

三、买卖股票（k次买卖，持有一支）

188. 买卖股票的最佳时机 IV
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

这个就是把2次买卖拓展为k次买卖，在dp数组推导的时候写成循环即可

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
    	/---特殊情况处理---/
        if(k == 0 || prices.size() == 0) return 0;

		/---dp数组定义，第一维度为天数，第二维度为每天的状态数-----/
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k, 0));

		/---初始化dp数组，每个交易状态均初始化为-prices[0]-----/
        for(int i = 0; i <= 2 * k - 1; i = i + 2){
            dp[0][i] = -prices[0];
        }

		/---递推公式，第一次买入特殊处理，其余买入卖出使用循环处理----/
        for(int i = 1; i < prices.size(); i++){
            dp[i][0] = max(dp[i - 1][0], -prices[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]); //卖出
                if(j % 2 == 0) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]); //买入
            }
        }

        /---不管买卖了多少次，最后一天最后一个状态就是赚的钱---/
        return dp[prices.size() - 1][2 * k - 1];
    }
};

四、买卖股票（多次买卖，持有一支，有冷却期）

1、dp数组

由于包含了冷却期，将卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此一天有四种状态，因此：

• dp[i][0]:买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
• dp[i][1]:两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
• dp[i][2]:今天卖出了股票
• dp[i][3]:今天为冷冻期状态，但冷冻期状态不可持续，只有一天

2、递推公式

			 /---如果是之前买了，今天保持;如果今天买了，则昨天可能是状态1或3---/
             dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][3]) - prices[i]); 
             dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]); //状态1的昨天可能是状态1或3
             dp[i][2] = dp[i - 1][0] + prices[i];  //状态2的昨天只能为状态0
             dp[i][3] = dp[i - 1][2];  //状态3的昨天只能为状态1

3、初始化

第一天买入状态初始化为-prices[0]
dp[0][0] = -prices[0];

4、遍历顺序

从前到后

5、返回值

由于卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此最后赚的最多的钱为最后一天三个状态的最大值

6、解题代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
         vector<vector<int>> dp(prices.size(), vector<int>(4, 0));

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

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


    }
};

五、买卖股票（多次买卖，持有一支，有手续费）

714. 买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

这个类型只是在买卖股票（多次买卖，持有一支）的基础上在当天卖出的时候多减去手续费。如果题目修改成买入也需要手续费的话，同理。

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size() == 0) return 0;

        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));

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

        for(int i = 1; i < prices.size(); 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[prices.size() - 1][1];
            
    }
};