买卖股票的最佳时机Ⅲ和Ⅳ

1. 买卖股票的最佳时机Ⅲ

1.1 问题描述

给定一个数组，它的第i个元素是一支给定的股票在第i天的价格

设计一个算法计算你能得到的最大利润，最多可以完成两笔交易。

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

【示例】

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

输入：prices = [1]
输出：0

来源：力扣（LeetCode）

1.2 动态规划步骤分析

• （1）确定状态

  • 一天总共五种状态：

    0：没有操作
    1：第一次买入
    2：第一次卖出
    3：第二次买入
    4：第二次卖出
    

  • f[i][j]中i表示第i天，j为[0-4]五个状态，f[i][j]表示第i天状态j所剩的最大现金。

• （2）转移方程
  • f[i][1]有两种状态：
    • 第i天买入股票，则f[i][1] = f[i-1][0] - prices[i];
    • 第i天没有操作，等同于前一天的状态，即f[i][1] = f[i-1][1];
  • f[i][2]有两种状态：
    • 第i天卖出股票，则f[i][2] = f[i-1][1] + prices[i];
    • 第i天没有操作，等同于前一天的状态，即f[i][2] = f[i-1][2];
  • 依次往下类推

  //f[i][1]
  f[i][1] = max(f[i-1][1],f[i-1][0] - prices[i]);
  //f[i][2]
  f[i][2] = max(f[i-1][2],f[i-1][1] + prices[i]);
  //f[i][3]
  f[i][3] = max(f[i-1][3],f[i-1][2] - prices[i]);
  //f[i][4]
  f[i][4] = max(f[i-1][4],f[i-1][3] + prices[i]);
  

• （3）初始化

第0天没有操作:f[0][0] = 0;

第0天第一次买入：f[0][1] = -prices[0];

第0天第一次卖出：f[0][2] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0

第0天第二次买入：f[0][3] = -prices[0]; //第二次买入依赖于第一次卖出，相当于第0天先买入卖出，然后再买入

第0天第二次卖出：f[0][4] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0

• （4）计算顺序
  • f[i] 依赖于f[i-1]，故计算顺序从前往后。
• （5）举例
  

1.3 C++实现

int maxProfit3(vector<int>& prices){
    if(prices.size() == 0) return 0;
    vector<vector<int>> f(prices.size(),vector<int>(2));
    //初始化
    f[0][1] = f[0][3] = -prices[0];
    f[0][0] = f[0][2] = f[0][4] = 0;

    for(int i = 1;i < prices.size();++i){
        f[i][0] = f[i-1][0];
        f[i][1] = max(f[i-1][1],f[i-1][0] - prices[i]);
        f[i][2] = max(f[i-1][2],f[i-1][1] + prices[i]);
        f[i][3] = max(f[i-1][3],f[i-1][2] - prices[i]);
        f[i][4] = max(f[i-1][4],f[i-1][3] + prices[i]);
    }
	//利润最大的时候一定最后一次卖出所得的利润。所以最终最大利润是f[4][4]
    return f[prices.size()-1][4];
}

#include <iostream>
#include <vector>
using namespace std;

int maxProfit3(vector<int>& prices);

int main(){
    vector<int> prices = {1,2,3,4,5};

    cout << maxProfit3(prices) << endl;
    return 0;
}

2. 买卖股票的最佳时机Ⅳ

2.1 问题描述

给定一个整数数组prices，它的第i个元素prices[i]是一支给定的股票在第i天的价格。

设计一个算法来计算你能获得的最大利润，最多可以完成K笔交易（不能同时参与多笔交易，即再次购买前需要出售掉之前的股票）

【示例】

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

来源：力扣（LeetCode）

1.2 动态规划问题分析

• （1）确定状态

  • 使用二维数组f[i][j]。第i天的状态为j，所剩下的最大现金是f[i][j]。j的状态表示如下

    0：没有操作
    1：第一次买入
    2：第一次卖出
    3：第二次买入
    4：第二次卖出
    ......
    ......
    

  • 除了0以外，偶数就是卖出，奇数就是买入。题目要求最多有k笔交易，那么j的定义范围为[0,2*k+1]

    //初始化二维数组f[i][j]
    vector<vector<int>> f(prices.size(),vector<int>(2*k+1,0));
    

• （2）转移方程

  • f[i][1]有两种状态：
    • 第i天买入股票，则f[i][1] = f[i-1][0] - prices[i];
    • 第i天没有操作，等同于前一天的状态，即f[i][1] = f[i-1][1];
  • f[i][2]有两种状态：
    • 第i天卖出股票，则f[i][2] = f[i-1][1] + prices[i];
    • 第i天没有操作，等同于前一天的状态，即f[i][2] = f[i-1][2];
  • 依次往下类推

  for(int j = 0;j < 2*k - 1;j+=2){
  	//奇数为买入 1,3,5,...
  	f[i][j+1] = max(f[i-1][j+1],f[i-1][j] - prices[i]);
  	//偶数为卖出 2,4,6,...
  	f[i][j+2] = max(f[i-1][j+2],f[i-1][j+1] + prices[i]);
  }
  

• （3）初始化

  第0天没有操作:f[0][0] = 0;
  第0天第一次买入：f[0][1] = -prices[0];
  第0天第一次卖出：f[0][2] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0
  第0天第二次买入：f[0][3] = -prices[0]; //第二次买入依赖于第一次卖出，相当于第0天先买入卖出，然后再买入
  第0天第二次卖出：f[0][4] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0
  ...
  ...
  

  • 可以推出f[0][j]当j为奇数的时候都初始化为 -prices[0]；偶数时初始化为0。

  for(int j = 1;j < 2*k;j+=2){
  	f[0][j] -= prices[0];
  }
  

• （4）计算顺序

  • 从转移方程其实已经可以看出，一定是从前向后遍历，因为f[i]，依靠f[i - 1]的数值。

2.3 C++实现

int maxProfit4(vector<int>& prices,int k){
    if(prices.size() == 0) return 0;
    vector<vector<int>> f(prices.size(),vector<int>(2*k+1,0));
    //初始化数组元素
    for(int j = 1;j < 2*k ;j+=2){
        f[0][j] -= prices[0];
    }

    for(int i = 1; i < prices.size();++i){
        for(int j = 0;j < 2*k-1;j+=2){
            f[i][j+1] = max(f[i-1][j+1],f[i-1][j] - prices[i]);
            f[i][j+2] = max(f[i-1][j+2],f[i-1][j+1] + prices[i]);
        }
    }
    return f[prices.size()-1][2*k];
}

#include <iostream>
#include <vector>
using namespace std;

int maxProfit4(vector<int>& prices,int k);

int main(){
    vector<int> prices = {1,2,3,4,5};
    cout << maxProfit4(prices,2) << endl;
    return 0;
}

【参考】代码随想录