买卖股票问题

最新推荐文章于 2024-05-12 13:48:18 发布
最新推荐文章于 2024-05-12 13:48:18 发布
阅读量943 收藏 23
点赞数 15
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzy233/article/details/134698193
版权

目录

121.买卖股票的最佳时机

题目描述

解题思路

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

题目描述

解题思路

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

题目描述

解题思路

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

题目描述

解题思路

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

题目描述

解题思路

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

题目描述

解题思路

总结

121.买卖股票的最佳时机

题目描述

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

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

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

  • 示例 1：
  • 输入：[7,1,5,3,6,4]
  • 输出：5
    解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
  • 示例 2：
  • 输入：prices = [7,6,4,3,1]
  • 输出：0
    解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

解题思路

  1. 确定dp数组以及下标含义

dp[ i ][ 0 ]表示第i天 持有 股票所得的现金

dp[ i ][ 1 ]表示第i天 不持有 股票所得的现金

注意！！！这里的持有可以是两种状态，一种是之前买的股票，一直没有卖出去，另一种情况是当天买入股票。

  1. 确定递推公式

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

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第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]);

  1. 初始化

由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出

其基础都是要从dp[0][0]和dp[0][1]推导出来。

dp[0][0]表示第0天持有股票，只能是当天买入，所以dp[ 0 ][ 0 ] = -prices[ 0 ]

dp[0][1]表示第0天不持有股票，可以是当天买入当天卖出，或者不进行操作，所以dp[1][0]=0

  1. 确定遍历顺序

从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。

  1. 推导dp数组

输入：[7,1,5,3,6,4]为例，dp数组状态如下：

dp[i][0]

dp[i][1]

0

-7

0

1

-1

0

2

-1

4

3

-1

4

4

-1

5

5

-1

5

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[len - 1][1]，不是dp[len - 1][0]，因为本题中不持有股票状态所得金钱一定比持有股票状态得到的多！

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。

提示：

  • 1 <= prices.length <= 3 * 10 ^ 4
  • 0 <= prices[i] <= 10 ^ 4

解题思路

本题可以多次买卖股票，但是在进行下一次交易之前必须卖出手里的股票

  1. 确定dp数组以及下标含义

dp[ i ][ 0 ]表示第i天 持有 股票所得的现金

dp[ i ][ 1 ]表示第i天 不持有 股票所得的现金

注意！！！这里的持有可以是两种状态，一种是之前买的股票，一直没有卖出去，另一种情况是当天买入股票。

  1. 确定递推公式

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

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]（正是因为本题的股票可以买卖多次！ 所以买入股票的时候，可能会有之前买卖的利润）

再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来

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

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]);

  1. 初始化

dp[0][0]表示第0天持有股票，只能是当天买入，所以dp[ 0 ][ 0 ] = -prices[ 0 ]

dp[0][1]表示第0天不持有股票，可以是当天买入当天卖出，或者不进行操作，所以dp[1][0]=0

  1. 确定遍历顺序

从前向后遍历

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        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] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[len - 1][1];
    }
};

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 <= prices.length <= 10^5
  • 0 <= prices[i] <= 10^5

解题思路

关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

  1. 确定dp数组以及下标含义

一天一共就有五个状态，

0.没有操作 （其实我们也可以不设置这个状态）

1.第一次持有股票

2.第一次不持有股票

3.第二次持有股票

4.第二次不持有股票

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

  1. 确定递推公式

达到dp[i][1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？

一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

同理dp[i][2]也有两个操作：

  • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

同理可推出剩下状态部分：

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]);

  1. 初始化

dp[0][0] = 0，第0天没有操作

dp[0][1] = -prices[0]，第0天买入股票

dp[0][2] = 0 ，当天买入立即卖出或者没有操作

dp[0][3] = -prices[0]，已经进行了一次交易，第二次买入

dp[0][4] = 0，第二次交易也在当天卖出。

  1. 确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值

  1. 推导dp数组

以输入[1,2,3,4,5]为例

下标

股票

不操作

0

买入

1

卖出

2

买入

3

卖出

4

0

1

0

-1

0

-1

0

1

2

0

-1

1

-1

1

2

3

0

-1

2

-1

2

3

4

0

-1

3

-1

3

4

5

0

-1

4

-1

4

最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。

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

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 。

提示：

  • 0 <= k <= 100
  • 0 <= prices.length <= 1000
  • 0 <= prices[i] <= 1000

解题思路

  1. 确定dp数组以及下标含义

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

j的状态表示为：

  • 0 表示不操作
  • 1 第一次买入
  • 2 第一次卖出
  • 3 第二次买入
  • 4 第二次卖出
  • .....

  1. 确定递推公式

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

达到dp[i][1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

同理dp[i][2]也有两个操作：

  • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

同理可以类比剩下的状态，代码如下：

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

  1. 初始化

初始化类似于上题，第0天持有股票状态就是-prices[0]，不持有股票就是0

  1. 确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。

注意此题中的初始化，和递推公式与上一题的区别与联系

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

vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.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[prices.size() - 1][4];

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

题目描述

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

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

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

示例:

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

解题思路

  1. 确定dp数组以及下标含义

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

  • 状态0：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
  • 不持有股票状态，这里就有两种卖出股票状态
    • 状态1：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
    • 状态2：今天卖出股票
  • 状态3：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

  1. 确定递推公式

达到买入股票状态（状态0）即：dp[i][0]，有两个具体操作：

  • 当天买入股票，一种是前一天是冷冻期，dp[i][0] = dp[i-1][3] -prices[i]；另一种情况是前一天不是冷冻期,手上也没有其他股票，dp[i][0] = dp[i-1][1] -prices[i]
  • 之前买入的股票，dp[i][0] = dp[i-1][0]

那么dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);

达到保持卖出股票状态（状态1）即：dp[i][1]，有两个具体操作：

  • 昨天是冷冻期，dp[i][1] = dp[i-1][3]
  • 昨天依然是状态1，dp[i][1] = dp[i-1][1]

dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

达到今天就卖出股票状态（状态2），即：dp[i][2]

只有一种情况，dp[i][2] = dp[i-1][0] + prices[i]

达到冷冻期状态（状态3），即：dp[i][3]，

只有一个操作：昨天卖出了股票，dp[i][3] = dp[i - 1][2];

  1. 初始化

dp[0][0] = -prices[0]，一定是当天买入股票。

dp[0][1]，第0天不持有股票，当天买入卖出，或者没有操作，初始化为0

dp[0][2]初始化为0，dp[0][3]也初始为0。

  1. 确定遍历顺序

从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。

  1. 推导dp数组

以 [1,2,3,0,2] 为例

状态0

1

2

3

第0天

-1

0

0

0

1

-1

0

1

0

2

-1

0

2

1

3

1

1

-1

2

4

1

2

3

-1

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

注意这里的返回值是，状态123的最大值，回顾下dp数组的定义就知道为啥返回的是最大值了，状态123都是手上不持有股票。

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.

注意:

  • 0 < prices.length <= 50000.
  • 0 < prices[i] < 50000.
  • 0 <= fee < 50000.

解题思路

这题和多次买卖股票多了一个手续费，只需要在每次卖出股票是减去一个手续费即可。

  1. 确定dp数组以及下标含义

dp[i][0] 表示第i天持有股票所省最多现金。

dp[i][1] 表示第i天不持有股票所得最多现金

  1. 确定递推公式

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

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]

所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
  • 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee

所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);

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

总结

买卖股票问题重点是划分不同状态，特别是有冷冻期的那题，不知道怎么初始化时，回顾下dp数组的定义

  • 股票只能买卖一次
    • dp[i][0] = max(dp[i - 1][0], -prices[i]);
    • dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

  • 股票可以买卖多次
    • 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]);

  • 股票最多可以买卖两次
    • 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]);

  • 最多可以买卖k次

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

  • 买卖多次，卖出有一天冷冻期

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

  • 状态0：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
  • 不持有股票状态，这里就有两种卖出股票状态
    • 状态1：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
    • 状态2：今天卖出股票
  • 状态3：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - 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];

  • 买卖多次，每次有手续费
    • 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);

想养小仓鼠
关注
  • 15
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划——买卖股票的最佳时机系列题
iris25145的博客
01-14 957
买卖股票有一系列题目交易状态为: [买入卖出冷冻期买入卖出。第六题，可以买无数次，但一次交易存在手续费，在交易完成一次之后需要付出一定的手续费。其中第一题可以说是后面题目的基础，给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0。
股票买卖问题：状态定义的误解与思考
JESSIENOTCAR的博客
03-17 781
iii：第iii天；kkk：交易的最大次数（这里有很多歧义，理解部分重点解释）；sss：持有状态，0代表不持有，1代表持有。举个例子，dp[3][1][0]代表在第三天，我至今最多进行了1次交易，现在没有持有的最大利润是多少。
动态规划----股票买卖问题（详解）
最新发布
2302_79862386的博客
05-12 2521
动态规划买卖股票的最佳时机是一个经典的算法问题。该问题的目标是在给定的股票价格数组中，找到最大的利润，即最佳的买入和卖出时间，使得买入时间早于卖出时间。
Leetcode——买卖股票问题汇总
Michael_Jay的博客
12-14 1307
本篇文章汇总了股票买卖的五种问题，采取动态规划算法循序渐进解题。
DP-股票买卖问题
kk阿彬
09-05 1117
第 4 题中k无限制，是一个最泛化的形式，其他的问题都是这个形式的简化，所以下面的分析以第4题为蓝本进行分析 分析（核心重点） 1、三种状态：天数、允许交易的最大次数、当前的股票持有状态（不妨用 1 表示持有，0 表示没有持有）。 三种状态定义dp数组： dp[i][k][0 or 1] 0 <= i <= n-1, 1 <= k <= K n 为天数，大 K 为最多交易数 此问题共 n × K × 2 种状态，全部穷举就能搞定。 举例： `dp[3][2][1]` 的含义就是：今
leetcode买卖股票问题-LeetCode:力码
07-07
leetcode买卖股票问题力码 由 Java 实现的 LeetCode。 按数据结构 大批 细绳 链表 两个数字相加 从列表末尾删除第 N 个节点 合并两个排序列表 合并 k 个排序列表（时间限制问题。需要 [O = kLog(n)]） 成对交换节点 ...
leetcode买卖股票问题-Project-PE:项目-PE
07-07
leetcode买卖股票问题项目-PE 重要的编码问题 系统设计 Linux 系统和内部结构 联网 手机屏幕： 涉及不同字符和窗口的字符串/数组问题 给定一个 mn 网格。 你被要求在这个网格上随机生成 k 个地雷。 每个单元格应该有...
买卖股票的最佳时机三
01-20
《买卖股票的最佳时机三》 在股票投资领域，如何把握最佳买卖时机是每个投资者关注的焦点。本问题探讨的是在给定的股票价格数组中，如何通过最多两次交易获得最大利润。具体而言，给定一个数组`prices`，其中`...
基于java计算买卖股票的最佳时机
08-25
在编程领域，尤其是在量化交易或金融数据分析中，计算买卖股票的最佳时机是一个常见的问题。这个问题的目标是确定在给定的一系列股票价格中，何时买入和卖出股票以获得最大的利润。在这个问题中，我们假设只能进行一...
LEETCODE力扣股票问题总结
12-20
在力扣（LEETCODE）平台上，股票问题是一类常见的动态规划题目，主要涉及如何在给定的股票价格序列中做出最优的买卖决策以获得最大利润。这些问题通常需要运用状态转移方程来求解。这里我们将深入探讨这类问题的核心...
股票买卖问题（动态规划）
qq_62802647的博客
12-08 1040
目录一、股票买卖 二、股票买卖 II三、股票买卖 III给定一个长度为 N 的数组，数组中的第 i 个数字表示一个给定股票在第 i 天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。第一行包含整数 N，表示数组长度。第二行包含 N 个不大于 1e9 的正整数，表示完整的数组。输出一个整数，表示最大利润。这道题目就简单了，他只要一次最大，所以我们可以记录一下从1~n之间的最小和n~1之间的最大，找出相距最大的
股票买卖问题
weixin_46497503的博客
02-25 256
以下的题是一个最泛化的形式，其他的问题都是这个形式的简化： 首先看看总共有几种「状态」，再找出每个「状态」对应的「选择」。我们要穷举所有「状态」，穷举的目的是根据对应的「选择」更新状态。如下图： 具体到当前问题，每天都有三种「选择」：买入、卖出、无操作，我们用 buy, sell, rest 表示这三种选择。 但问题是，并不是每天都可以任意选择这三种选择的，因为 sell 必须在 buy 之后，buy 必须在 sell 之后（第一次除外）。那么 rest 操作还应该分两种状态，一种是 buy 之后的 r
【算法题】股票买卖问题解法详解
Steven_L_的博客
06-19 2244
本解法是股票问题的通用解法，在leetcode上对应以下题： 买卖股票的最佳时机 买卖股票的最佳时机 II 买卖股票的最佳时机 III 买卖股票的最佳时机 IV 买卖股票的最佳时机含手续费 最佳买卖股票时机含冷冻期 下面来说通用解法：         这类问题有一个状态转移图： 其中：0表示未持有股票，1表示持有股票。则对应于每一天，有持有和未持有两种情况。 如果某一天持有股票，则可能是前一天就已持有股票或前一天未持有股票
股票买卖问题，
Superbeans的博客
09-02 499
Best Time to Buy and Sell Stock III Description: Say you have an array for which the ith element is the price of a given stock on day i. Design an algorithm to find the maximum profit. You may comple...
团灭 LeetCode 股票买卖问题
Francis的博客
09-26 711
转载自labuladong作者labuladong预计阅读时间：12分钟上篇文章用递归的方法实现了一套简单易懂的可行解，但是时间复杂度略高，不能通过全部测试用例。...
动态规划股票买卖问题
08-25
买卖股票的最佳时机、122. 买卖股票的最佳时机II、123. 买卖股票的最佳时机III、188. 买卖股票的最佳时机IV、309. 最佳买卖股票时机含冷冻期和714. 买卖股票的最佳时机含手续费等。通过学习这些例题，可以更好地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值