刷题第四天（股票问题专项）

121. 买卖股票的最佳时机

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

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

```cpp
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==0) return 0;
          int res=-prices[0];
          int sum=0;
          for(int i=1;i<prices.size();i++){
              res=max(res,-prices[i]);
              sum=max(sum,res+prices[i]);
          } 
          return sum;
    }
};

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

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

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

 

示例 1:

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

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

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

```cpp
//动态规划
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //动态规划：当天的状态：
        //（1）当天已购买，未买出
        //（2） 当天已卖出，未购买
        
        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][1]-prices[i],dp[i-1][0]);
         dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
          
         }
         return dp[prices.size()-1][1];
    }
};

//法二：对动态规划进行空间优化：发现每个一状态只和上一个状态有关
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //动态规划：当天的状态：
        //（1）当天已购买，未买出
        //（2） 当天已卖出，未购买
        
       int pre=-prices[0];
       int cur=0;
       for(int i=1;i<prices.size();i++){
           pre=max(pre,cur-prices[i]);
           cur=max(cur,pre+prices[i]);
       }
       return cur;
    }
};



题目中是否允许「在同一天买入并且卖出」这一操作，最终的答案都不会受到影响，这是因为这一操作带来的收益为零。若是不理解可以看下面代码
pre=max(pre',cur'-prices[i])
cur=max(cur',pre'+prices[i])
pre',cur'指的是上一个状态，所以严谨的话应该增加两个变量记录上一个状态

```cpp
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //动态规划：当天的状态：
        //（1）当天已购买，未买出
        //（2） 当天已卖出，未购买
       int pre=0;
       int cur=0;
       int pre1=-prices[0];
       int cur1=0;
       for(int i=1;i<prices.size();i++){
           pre=max(pre1,cur1-prices[i]);
           cur=max(cur1,pre1+prices[i]);
           cur1=cur;
           pre1=pre;
       }
       return cur;
    }
};

方法三：贪心算法

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

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

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

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

示例 1:

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

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

输入：prices = [7,6,4,3,1]
输出：0
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。
示例 4：

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

//1.动态规划
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //每一天的状态：
        //(1)当前已购买，未买出
        //（2）当前已购买，且卖出
        //（3）第二次购买，未买出
        //（4） 第二次卖出
     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];
    }
};
//方法二：尝试对空间进行优化，发现每一个状态只与上一个状态值有关，可以用单变量来代替数组空间

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int buy1 = -prices[0], sell1 = 0;
        int buy2 = -prices[0], sell2 = 0;
        for (int i = 1; i < n; ++i) {
            buy1 = max(buy1, -prices[i]);
            sell1 = max(sell1, buy1 + prices[i]);
            buy2 = max(buy2, sell1 - prices[i]);
            sell2 = max(sell2, buy2 + prices[i]);
        }
        return sell2;
    }
};

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

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

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

返回获得利润的最大值。

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

示例 1:

输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
输出: 8
解释: 能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

//动态
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
     //当天股票状态（1）当前已购买未买出
     //（2） 当前未购买，已卖出
     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][1]-prices[i],dp[i-1][0]);
         dp[i][1]=max(dp[i-1][0]+prices[i]-fee,dp[i-1][1]);
     }
     return dp[prices.size()-1][1];
    }
};

//空间优化
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
     //当天股票状态（1）当前已购买未买出
     //（2） 当前未购买，已卖出
    int cur=0;
    int pre=-prices[0];
    for(int i=1;i<prices.size();i++){
        pre=max(pre,cur-prices[i]);
        cur=max(cur,pre+prices[i]-fee);
    }
    return cur;
    }
};

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

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

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

返回获得利润的最大值。

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

示例 1:

输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
输出: 8
解释: 能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

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

//空间优化
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==0) return 0;
   int cur=0;
   int pre=-prices[0];
   int temp=0;
       for(int i=1;i<prices.size();i++){
        int a=max(pre,temp-prices[i]);    //已买入未卖出
        int b=max(cur,pre+prices[i]);    //已卖出，未买入
        int c=max(temp,cur);            //冷冻期
        pre=a;
        cur=b;
        temp=c;                             
    }
    return cur;
    }
};

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

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

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

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

示例 1：

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

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n=prices.size();
        if(n==0) return 0;
        k=min(k,n/2);
        vector<vector<int>> buy(n,vector<int>(k+1,0));
        vector<vector<int>> sell(n,vector<int>(k+1,0));
        buy[0][0]=-prices[0];
        for(int i=1;i<=k;i++){
          buy[0][i]=INT_MIN/2;
          sell[0][i]=INT_MIN/2;  
        }
        for(int i=1;i<n;i++){
           buy[i][0]=max(buy[i-1][0],sell[i-1][0]-prices[i]);
           for(int j=1;j<=k;j++){
              buy[i][j]=max(buy[i-1][j],sell[i-1][j]-prices[i]);
              sell[i][j]=max(sell[i-1][j],buy[i-1][j-1]+prices[i]);
           }
        }
      
        return *max_element(sell[n - 1].begin(), sell[n - 1].end()); 
    }
};