Leetcode 股票问题集合

已于 2023-09-10 10:22:44 修改
阅读量1.4k 收藏 1
点赞数 1
分类专栏： Leetcode专栏 文章标签： leetcode 算法 动态规划
于 2023-05-07 12:00:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51322383/article/details/130539844
版权

文章目录

模板

在这里插入图片描述
状态方程：

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max( 今天选择 rest,        今天选择 sell       )

解释：今天我没有持有股票，有两种可能，我从这两种可能中求最大利润：

1、我昨天就没有持有，且截至昨天最大交易次数限制为 k；然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。

2、我昨天持有股票，且截至昨天最大交易次数限制为 k；但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max( 今天选择 rest,         今天选择 buy         )

解释：今天我持有着股票，最大交易次数限制为 k，那么对于昨天来说，有两种可能，我从这两种可能中求最大利润：

1、我昨天就持有着股票，且截至昨天最大交易次数限制为 k；然后今天选择 rest，所以我今天还持有着股票，最大交易次数限制依然为 k。

2、我昨天本没有持有，且截至昨天最大交易次数限制为 k - 1；但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。

这里着重提醒一下，时刻牢记「状态」的定义，状态 k 的定义并不是「已进行的交易次数」，而是「最大交易次数的上限限制」。如果确定今天进行一次交易，且要保证截至今天最大交易次数上限为 k，那么昨天的最大交易次数上限必须是 k - 1。

链接：一个方法团灭 LEETCODE 股票买卖问题

Leetcode 121. 买卖股票的最佳时机

题目

在这里插入图片描述
Leetcode 121. 买卖股票的最佳时机

代码（首刷看解析）

做出初始状态、状态转移方程dp[i] = max(dp[i-1], prices[i] - minprice);
记得更新minprice

我一开始没做出来的原因是没有想到更新minprice。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<int> dp(prices.size(), 0);
        int n = prices.size();
        if(n <= 1)
            return 0;
        int minprice = prices[0];
        for(int i = 1; i < n; i++) {
            minprice = min(minprice, prices[i]);
            dp[i] = max(dp[i-1], prices[i] - minprice);
        }
        return dp[n - 1];
    }
};

代码（7.24 二刷自解）

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

代码（8.28 三刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int dp_0 = 0, dp_1 = -prices[0];
        for(int& price : prices) {
            dp_0 = max(dp_0, dp_1 + price);
            dp_1 = max(-price, dp_1);
        }
        return dp_0;
    }
};

代码（9.10 四刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int dp0 = 0, dp1 = -prices[0];
        for(int& pirce : prices) {
            dp0 = max(dp0, dp1+pirce);
            dp1 = max(dp1, -pirce);
        }
        return dp0;
    }
};

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

题目

在这里插入图片描述
Leetcode 122. 买卖股票的最佳时机 II

代码（首刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        // vector<vector<int>> dp(n, vector<int>(2));
        // dp[0][1] = -prices[0];
        int dp_i_0 = 0;
        int dp_i_1 = -prices[0];
        for(int i = 1; i < n; i++) {
            dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
            dp_i_1 = max(dp_i_1, dp_i_0 - prices[i]);
        }
        return dp_i_0;
    }
};

代码（7.24 二刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        // vector<vector<int>> dp(n+1, vector<int>(2));
        // dp[0][1] = -prices[0];
        int dp_i_0 = 0, dp_i_1 = -prices[0];
        for(int i = 0; i < n; i++) {
            dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
            dp_i_1 = max(dp_i_1, dp_i_0 - prices[i]);
            // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i-1]);
            // dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i-1]);
        }
        return dp_i_0;
    }
};

代码（8.28 三刷看解析）

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

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

题目

在这里插入图片描述
Leetcode 123. 买卖股票的最佳时机 III

代码（首刷看解析模板）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp_i_1_0 = 0, dp_i_1_1 = INT_MIN;
        int dp_i_2_0 = 0, dp_i_2_1 = INT_MIN;
        for(auto& price : prices) {
            dp_i_1_0 = max(dp_i_1_0, dp_i_1_1 + price);
            dp_i_1_1 = max(dp_i_1_1, -price);
            dp_i_2_0 = max(dp_i_2_0, dp_i_2_1 + price);
            dp_i_2_1 = max(dp_i_2_1, dp_i_1_0 - price);
        }
        return dp_i_2_0;
    }
};

代码（7.24 二刷部分看解析）

如果用常数变量的话，第一次卖出是-price[i]，因为这是第一次，前面的金额是0。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        // vector<<vector<int>> dp(2, vector<int>(2));
        int dp_i_1_0 = 0, dp_i_1_1 = -prices[0];
        int dp_i_2_0 = 0, dp_i_2_1 = -prices[0];
        for(int i = 0; i < n; i++) {
            dp_i_1_0 = max(dp_i_1_0, dp_i_1_1 + prices[i]);
            dp_i_1_1 = max(dp_i_1_1, -prices[i]);
            dp_i_2_0 = max(dp_i_2_0, dp_i_2_1 + prices[i]);
            dp_i_2_1 = max(dp_i_2_1, dp_i_1_0 - prices[i]);
        }
        return dp_i_2_0;
    }
};

代码（8.28 三刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int dp_0_0 = 0, dp_0_1 = -prices[0];
        int dp_1_0 = 0, dp_1_1 = dp_0_1;
        for(int& price : prices) {
            dp_0_0 = max(dp_0_0, dp_0_1 + price);
            dp_0_1 = max(dp_0_1, -price);
            dp_1_0 = max(dp_1_0, dp_1_1 + price);
            dp_1_1 = max(dp_1_1, dp_0_0 - price);
        }
        return dp_1_0;
    }
};

Leetcode 188. 买卖股票的最佳时机 IV（万能模板）

题目

在这里插入图片描述
Leetcode 188. 买卖股票的最佳时机 IV

代码（首刷自解）

实际上可以发现，第i天这一层是可以优化掉的，因为每一次的新状态只和相邻状态有关

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        vector<vector<int>> dp(k+1, vector<int>(2));
        for(int i = 1; i <= k; i++) {
            dp[i][1] = INT_MIN;
        }
        for(auto& price : prices) {
            for(int j = 1; j <=k; j++) {
                dp[j][0] = max(dp[j][0], dp[j][1] + price);
                dp[j][1] = max(dp[j][1], dp[j-1][0] - price);
            }
        }
        return dp[k][0];
    }
};

代码（7.24 二刷部分看解析）

要注意base case：每一次的购买前都需要是INT_MIN

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(k+1, vector<int>(2));
        for(int i = 1; i <= k; i++)
            dp[i][1] = INT_MIN;
        for(int& price : prices) {
            for(int i = 1; i <= k; i++) {
                dp[i][0] = max(dp[i][0], dp[i][1] + price);
                dp[i][1] = max(dp[i][1], dp[i-1][0] - price);
            }
        }
        return dp[k][0];
    }
};

代码（8.28 三刷部分看解析）

用go好麻烦，下次不用go了，还是得注意base case：每一次的购买前都需要是INT_MIN

func maxProfit(k int, prices []int) int {
    n := len(prices)
    dp := make([][][]int, n+1)
    for i:= 0; i <= n; i++ {
        dp[i] = make([][]int, k+1)
        for q := 0; q <= k; q++ {
            dp[i][q] = make([]int, 2)
        }
    }
    
    for i := 0; i <= k; i++ {
        dp[0][i][1] = -1 << 31
    }

    for i := 1; i <= n; i++ {
        for q := 1; q <= k; q++ {
            dp[i][q][0] = max(dp[i-1][q][0], dp[i-1][q][1] + prices[i-1])
            dp[i][q][1] = max(dp[i-1][q][1], dp[i-1][q-1][0] - prices[i-1])
            fmt.Println(dp[i][q][0], dp[i][q][1])
        }
    }
    return dp[n][k][0]
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

代码（9.10 四刷自解）

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        vector<vector<int>> dp(k+1, vector<int>(2));
        for(int i = 1; i <= k; i++)
            dp[i][1] = INT_MIN;
        for(int& price : prices) {
            for(int i = 1; i <= k; i++) {
                dp[i][0] = max(dp[i][0], dp[i][1]+price);
                dp[i][1] = max(dp[i][1], dp[i-1][0]-price);
            }
        }
        return dp[k][0];
    }
};

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

题目

在这里插入图片描述
Leetcode 309. 最佳买卖股票时机含冷冻期

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i])
解释：第 i 天选择 buy 的时候，要从 i-2 的状态转移，而不是 i-1 。

代码（7.24 首刷自解）

base case：第一天的为-price[0]；
另外，由于需要冻结一天，所以下一次购买的条件中需要是dp[i-2][0] - price[i-1]

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

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

题目

在这里插入图片描述

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)
解释：相当于买入股票的价格升高了。
在第一个式子里减也是一样的，相当于卖出股票的价格减小了。

代码(7.24 首刷自解）

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n+1, vector<int>(2));
        dp[0][1] = -prices[0] - fee;
        for(int i = 1; i <= n; i++) {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i-1]);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i-1] - fee);
        }
        return dp[n][0];
    }
};
JehanRio
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode股票问题总结篇!
gyjllll的博客
02-01 918
那么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][0] + prices[i] - fee);所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
LeetCode打卡day49-51 -- 买卖股票系列
weixin_45872648的博客
06-29 820
今天补上了这几天落下的东西, 然后这一篇将概括LeetCode上买卖股票的系列问题, 并且提供了解决该问题的模版.
【经典算法】LeetCode 121. 买卖股票的最佳时机(Java/C/Python3实现含注释说明,Easy)
最新发布
2401_84427485的博客
04-20 1185
对比项一次遍历（贪心算法）动态规划解题思路每次选择当前状态下的最优解，不考虑未来的变化构建状态转移方程，逐步求解，保存中间结果适用场景局部最优选择能直接导致全局最优，如连续上涨的市场涉及多次买入卖出、考虑冷冻期、手续费等复杂情况空间复杂度O(1)，较低，只需保存当前状态信息O(n)，较高，需保存多个状态的最优解时间复杂度O(n)， 较低，通常一次遍历即可O(n)，较高，需遍历所有可能状态全局最优性保证不一定能保证全局最优解可以得到全局最优解灵活性较低，适用于简单直接的交易策略。
[LeetCode刷题笔记]122 - 买卖股票的最佳时机 II（C++/Python3/Java/暴力/动态规划/贪心）
qq_40430360的博客
05-12 1200
[LeetCode刷题笔记]122 - 买卖股票的最佳时机 II（C++/Python3/Java/暴力/动态规划/贪心）
leetcode热题100.买股票的最佳时机
qq_51118755的博客
04-02 892
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。示例 1：示例 2：提示：1
LeetCode122之股票买卖的最好时机（相关话题：动态规划，记忆搜索，状态机，贪心算法）
击水三千里的专栏
03-14 499
动态规划，记忆搜索，状态机，贪心算法
leetcode卡-Collection:算法集合和leetcode的题集合
07-06
leetcode卡 代码集合 该项目，是一个比较零散代码的集合，例如数据结构，算法等集合（java） 项目结构 内部排序算法 （内存中执行） sort ...买卖股票的最佳时机 旋转数组 存在重复 只出现一次的数字
股票买卖最佳时机leetcode-Algorithms:我在不同算法集合上解决问题的方法
07-07
股票买卖最佳时机leetcode 问题包括： 什么是世纪： 给定一年，返回它所在的世纪。第一个世纪从第 1 年到第 100 年，第二个从第 101 年到第 200 年，以此类推。 苹果选股： 编写编程面试问题并没有让我变得富有……...
LeetCode解题总结
10-09
LeetCode解题总结 1. 数组 1.1 从有序数组中删除重复元素 1.2 在排序数组被旋转后进行查找 1.3 寻找两个排序数组的中位数 1.4 最长连续序列 1.5 累加和 1.6 移除数组中指定值 1.7 下一个排列 1.8 第n个全排列 1.9 ...
leetcode2sumc-LeetCodeCSharp:我对LeetCode问题的C#解决方案
07-06
leetcode ...买卖股票的最佳时机 简单的 136 单号 简单的 141 链表循环 简单的 153 在旋转排序数组中查找最小值 中等的 200 岛屿数量 中等的 206 反向链表 简单的 217 包含重复 简单的 242 有效字谜 简单的
股票买卖最佳时机leetcode-Eargo:耳高
07-07
股票买卖最佳时机leetcode 耳高 练习 1 -该函数将返回列表、向量或数字集合，这些数字表示将产生正确变化的四分之一 (25)、角钱 (10)、镍 (5)、便士 (1) 的数量。 * Time Complexity = O(totalAmount * n) where n ...
买卖股票类问题动态规划解法（Leetcode题解-Python语言）
自动化研究生在读，此博客记录了我的学习与刷题经验，欢迎大家阅读交流
11-29 3186
在 Leetcode 中，关于买卖股票的问题共有6道，而这些题目是可以用相同的思维进行求解的，强烈推荐这篇总结，写得非常到位。 股票类问题的动态规划分三步走，1、首先明确方程的含义， T[i][k][0]：表示在第 i 天结束时，最多进行 k 次交易且在进行操作后持有 0 份股票的情况下可以获得的最大收益； T[i][k][1]：表示在第 i 天结束时，最多进行 k 次交易且在进行操作后持有 1 份股票的情况下可以获得的最大收益。 2、初始（基准）情况： T[-1][k][0] = 0, T[-1][k][
【算法基础】LeetCode股票交易类算法题目总结（一次交易，两次交易，无数次交易）...
fengdu78的博客
03-05 2941
大家好，前一段时间的基金市场波动很大啊，也就又诞生了很多“韭菜”，在这里千寻也提醒大家“股市有风险，入市需谨慎”，玩基金一定用不着急用的钱哦~刷算法题目，应该是很多同学的“噩梦”，尤其是非...
LeetCode动态规划基础题-股票买卖
忆_恒心的博客
05-02 968
动态规划leetcode
leetcode股票买卖问题
kevin的博客
12-31 1996
股票买卖问题 本人是大三学生，有问题欢迎及时指出呀 文章目录股票买卖问题1.[买卖股票的最佳时机](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/)2.[最佳买卖股票时机含冷冻期](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-...
[LeetCode]动态规划中股票问题的通用解法
Math & Code
09-14 1951
动态规划中股票问题的通用解法 有一类动态规划的问题是给定一个股票价格序列，然后计算买卖股票所能获得的最大收益，这类问题通常有很多变种，例如只允许交易一次，允许交易多次或者增收交易税等。即问题的最大收益通常由交易的时间和允许的最大交易次数（每次交易指一次买与一次卖的一个组合）决定的。 可以用T[i][k]表示在第i天结束的时候最多经过k次交易所能获得的最大收益，另外在第i天结束的时候可以有两种状...
买卖股票问题
selfsongs
09-24 531
买卖股票问题买卖股票问题I122. 买卖股票的最佳时机 II 买卖股票问题I 121. 买卖股票的最佳时机 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能
LeetCode股票问题通解（二）
算法岗从零到无穷
02-08 231
股票问题是动态规划中一类很恶心的题目，大家可以自己先去做一下，你一定会发现各个股票的问题解法都不一样，奇淫技巧特别多，让人觉得，我怎么想得到？再让我做一遍我也做不出来！ 那么今天，我将告诉大家一个通用的方法，一个方法，解决6道股票问题。同时也要感谢leetcode用户fun4LeetCode，本文参考：https://urlify.cn/zYbu2a 首先，我们用一个三维数组来存储状态的组合： ...
LeetCode - 股票交易题总结
virgilshi的博客
04-06 304
股票交易题总结 LeetCode中涉及到股票交易题，总共有四题： LeetCode - 121. 买卖股票的最佳时机 LeetCode - 122. 买卖股票的最佳时机 II LeetCode - 123. 买卖股票的最佳时机 III LeetCode - 714. 买卖股票的最佳时机含手续费 题121限制只进行一次交易，解题策略是，维护一个到目前为止最小的股票价格，然后将当天的股票价格减去它，得...
leetcode-常见考题4.pdf
02-23
在LeetCode中的编程面试题集中，"121. Best Time to Buy and Sell Stock" 和 "122. Best Time to Buy and Sell Stock II" 是两个经典的股票买卖问题，涉及动态规划算法的应用。这两个题目都是关于股票投资策略，目标...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值