动态规划：买卖股票的最佳时机问题

leetcode121.买卖股票的最佳时机 I

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/

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

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

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

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

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示持有股票时所持的现金，j = 1表示不持有股票时所持的现金

假设prices数组长度为size，最终结果为：dp[size - 1] [1]

(2).根据题意导出递推关系：

dp[i] [0] = max(dp[i - 1] [0], -prices[i])

dp[i] [1] = max(dp[i - 1] [1], dp[i - 1] [0] + prices[i])

(3).确认初始条件：

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

dp[0] [1] = 0

2.题解

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

        //动态规划
        int dp[size][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
   
        for (int i = 1;i < 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]);
        }

        return dp[size - 1][1];
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

假设数组prices长度为N，则空间复杂度为O(N)

优化：

1.基本思想

不断的去寻找“股票价格的历史最低值”(注意：历史最低值的含义是当天或当天以前股票价格的最低值)，然后用当天的股票价格减去“股票价格的历史最低值”表示一次股票买卖，其中去寻找最大值。

2.题解

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

        int minPrice = prices[0];
        int maxProfit = 0;
        for (int i = 1;i < size;++i)
        {
            minPrice = min(minPrice, prices[i]);
            maxProfit = max(maxProfit, prices[i] - minPrice);
        }

        return maxProfit;
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

空间复杂度为O(1)

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/

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

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

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

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

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示啥也没干，

j = 1 表示第一次买入后持股，j = 2表示第一次卖出后不持股，

j = 3 表示第二次买入后持股，j = 4表示第二次卖出后不持股。

假设prices数组长度为size，最终结果为：dp[size - 1] [4]

(2).根据题意导出递推关系：

dp[i] [0] = dp[i - 1] [0]

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]}

(3).确认初始条件：

dp[0] [0] = 0

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

dp[0] [2] = 0

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

dp[0] [4] = 0

2.题解：

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

        int dp[size][5];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;

        for (int i = 1;i < size;++i)
        {
            dp[i][0] = dp[i - 1][0];
            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]);
        }

        return dp[size - 1][4];
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

假设数组prices长度为N，则空间复杂度为O(N)

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/

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

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

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

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

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示啥也没干，j为奇数时表示买入后持股，j为偶数表示卖出后不持股。

假设prices数组长度为size，交易次数为k，最终结果为：dp[size - 1] [2 * k]

(2).根据题意导出递推关系：

dp[i] [0] = dp[i - 1] [0]

if (j为奇数): dp[i] [j] = max{ dp[i - 1] [j], dp[i - 1] [j - 1] - prices[i] }

if (j为偶数): dp[i] [j] = max{ dp[i - 1] [j], dp[i - 1] [j - 1] + prices[i] }

(3).确认初始条件：

dp[0] [0] = 0

if (j为奇数): dp[0] [j] = -prices[i]

if (j为偶数): dp[0] [j] = 0

2.注意点

若交易次数k大于等于prices数组长度size的一半，则问题转换为leetcode122.买卖股票的最佳时机 II，即交易次数无限制。

3.题解：

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

        if (k >= size / 2)
        {
            int result = 0;
            for (int i = 1;i < size;++i)
            {
                result = result + max(0, prices[i] - prices[i - 1]);
            }
        }

        int dp[size][2 * k + 1];
        dp[0][0] = 0;
        for (int j = 1;j < 2 * k + 1;++j)
        {
            if (j % 2 == 1)
            {
                dp[0][j] = -prices[0];
            }
            else
            {
                dp[0][j] = 0;
            }
        }

        for (int i = 1;i < size;++i)
        {
            dp[i][0] = dp[i - 1][0];
            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[size - 1][2 * k];
    }
};

3.时间复杂度

假设数组prices长度为N，交易次数为K，则时间复杂度为O(NK)

4.空间复杂度

假设数组prices长度为N，交易次数为K，则空间复杂度为O(NK)

对买卖股票的最佳时机 I III IV 的总结

这三个问题是一脉相承的。从买卖1次，到买卖2次，再到买卖k次：**本质上的思想都是一样的，所用的方法都是一样。**实际上，可以将IV的思想方法作为一个模板推广到I和III 。 即：

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示啥也没干，j为奇数时表示买入后持股，j为偶数表示卖出后不持股。

假设prices数组长度为size，交易次数为k，最终结果为：dp[size - 1] [2 * k]

(2).根据题意导出递推关系：

dp[i] [0] = dp[i - 1] [0]

if (j为奇数): dp[i] [j] = max{ dp[i - 1] [j], dp[i - 1] [j - 1] - prices[i] }

if (j为偶数): dp[i] [j] = max{ dp[i - 1] [j], dp[i - 1] [j - 1] + prices[i] }

(3).确认初始条件：

dp[0] [0] = 0

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

leetcode122.买卖股票的最佳时机 II

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/

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

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

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

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

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示持有股票时持有的现金，j = 1表示不持有股票时持有的现金

假设prices数组长度为size，最终结果为：dp[size - 1] [1]

(2).根据题意导出递推关系：

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] }

(3).确认初始条件：

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

dp[0] [1] = 0

2.题解：

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

        //动态规划
        int dp[size][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1;i <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]);       
        }

        return dp[size - 1][1];
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

假设数组prices长度为N，则空间复杂度为O(N)

贪心：

1.贪心策略

本题可以使用贪心策略，贪心就贪心在只有在股票上涨时才卖出股票。

2.题解

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

        //贪心
        int result = 0;
        for (int i = 1;i < size;++i)
        {
            result = result + max(0, prices[i] - prices[i - 1]);
        }

        return result;
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

空间复杂度为O(1)

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示持有股票时持有的现金
j = 1表示不持有股票时持有的现金，且进入冷冻期，
j = 2表示不持有股票时持有的现金，且退出冷冻期。

假设prices数组长度为size，最终结果为：
max{dp[size - 1] [1], dp[size - 1] [2] }

(2).根据题意导出递推关系：

dp[i] [0] = max{ dp[i - 1] [0], dp[i - 1] [2] - prices[i] }

dp[i] [1] = dp[i - 1] [0] + prices[i]

dp[i] [2] = max{ dp[i - 1] [2], dp[i - 1] [1]}

(3).确认初始条件：

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

dp[0] [1] = 0

dp[0] [2] = 0

2.题解：

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

        int dp[size][3];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        dp[0][2] = 0;

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

        return max(dp[size - 1][1], dp[size - 1][2]);
    }
};

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

假设数组prices长度为N，则空间复杂度为O(N)

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/

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

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

返回获得利润的最大值。

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

输入: 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.

动态规划：

1.递推关系

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示持股时持有的现金，j = 1表示不持股时持有的现金

假设prices数组长度为size，最终结果为：dp[size - 1] [1]

(2).根据题意导出递推关系：

由于该题要求每笔交易完成后需要支付手续费，故

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 }

(3).确认初始条件：

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

dp[0] [1] = 0

2.题解：

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

        int dp[size][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

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

3.时间复杂度

假设数组prices长度为N，则时间复杂度为O(N)

4.空间复杂度

假设数组prices长度为N，则空间复杂度为O(N)

对买卖股票的最佳时机 II 含冷冻期 含手续费 的总结

这三个问题也是一脉相承的，**其中II作为基础，而含冷冻期和含手续费都是在II的基础上添加一个限制条件罢了。**只要我们熟悉了作为基础的II，后两者很容易就能写出递推式，写出题解，即：

(1).明确dp[i] [j]表示什么：

dp[i] [j] 表示玩家手里所获得利润。

i表示天数。

j = 0表示买入后持股，j = 1表示卖出后不持股

假设prices数组长度为size，最终结果为：dp[size - 1] [1]

(2).根据题意导出递推关系：

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] }

(3).确认初始条件：

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

dp[0] [1] = 0