LeetCode-买卖股票问题

最新推荐文章于 2024-07-22 15:41:09 发布
最新推荐文章于 2024-07-22 15:41:09 发布
阅读量142 收藏
点赞数
分类专栏： LeetCode刷题 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38087674/article/details/107591622
版权

目录

股票题

前言

在这里插入图片描述

此题是k = 2

利用「状态」进行穷举。我们具体到每一天，看看总共有几种可能的「状态」，再找出每个「状态」对应的「选择. 我们要穷举所有「状态」，穷举的目的是根据对应的「选择」更新状态

for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 择优(选择1，选择2...)

每天都有三种「选择」：买入、卖出、无操作，我们用 buy, sell, rest 表示这三种选择

并不是每天都可以任意选择这三种选择的，因为 sell 必须在 buy 之后，buy 必须在 sell 之后

rest 操作还应该分两种状态，一种是 buy 之后的 rest（持有了股票），一种是 sell 之后的 rest（没有持有股票）

我们还有交易次数 k 的限制，就是说你 buy 还只能在 k > 0 的前提下操作

dp[3][2][1] 的含义就是：今天是第三天，我现在手上持有着股票，至今最多进行 2 次交易。再比如 dp[2][3][0] 的含义：今天是第二天，我现在手上没有持有股票，至今最多进行 3 次交易。很容易理解，对吧？

状态转移框架

在这里插入图片描述
状态转移方程:

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,             选择 sell      )
​解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。
​dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )
​解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

如果 buy，就要从利润中减去 prices[i]，如果 sell，就要给利润增加 prices[i]


定义base case
dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0 。
dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，用负无穷表示这种不可能。
dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0 。
dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能。

总结
base case：
dp[-1][k][0] = dp[i][0][0] = 0
dp[-1][k][1] = dp[i][0][1] = -infinity
​
状态转移方程：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

121. 买卖股票的最佳时机

在这里插入图片描述
思路
此时K == 1 可以先忽略不计
dp[i][0]:表示第i天没有持有股票 : 1.保持前一天没持有; 2.昨天持有,但是卖了
dp[i][1]:表示第i天有持有 : 1.他保持前一天持有; 2.今天买了

int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int dp[prices.size()][2];
        for (int i = 0; i < prices.size(); i++) {
            if (i - 1 == -1) {
                dp[i][1] = -prices[i];
                dp[i][0] = 0;
                continue;
            }
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            //因为只买卖一次 K=1的情况下, dp[i][1] 不需要考虑当前余额,如果需要就要dp[i - 1][0]  -prices[i]
            dp[i][1] = max(dp[i - 1][1], -prices[i]);
        }
        return dp[prices.size() - 1][0];
    }

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

在这里插入图片描述

思路
与上题相比, k是无限,可以多次交易

 int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int dp[prices.size()][2];
        for (int i = 0; i < prices.size(); i++) {
            if (i - 1 == -1) {
                dp[0][0] = 0;
                dp[0][1] = -prices[i];
                continue;
            }
            //因为是多次交易,所以需要保存temp, temp是昨天为持有的收益,可能是已经卖了
            int temp = 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], temp - prices[i]);
        }
        return dp[prices.size() - 1][0];
    }

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

在这里插入图片描述

思路
就是在卖出的时候加上手续费就行

int maxProfit(vector<int>& prices, int fee) {
        if (prices.size() < 2) return 0;
        int dp[prices.size()][2];
        for (int i = 0; i < prices.size(); i++) {
            if (i == 0) {
                dp[0][0] = 0;
                dp[0][1] = -prices[0];
                continue;
            }
            int temp = dp[i - 1][0];
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);
            dp[i][1] = max(dp[i - 1][1], temp - prices[i]);
        }
        return dp[prices.size() - 1][0];
    }

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

在这里插入图片描述

思路
就是买的话是从[i - 2] 开始

//f1 因为可能冻结期有2 3 4天, 此方法不靠谱
int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int dp[prices.size()][2];
        for (int i = 0; i < prices.size(); i++) {
            if (i == 0) {
                dp[0][0] = 0;
                dp[0][1] = -prices[0];
                continue;
            }
            if (i == 1) {
                dp[1][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
                dp[1][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
                continue;
            }
            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]);
        }
        return dp[prices.size() - 1][0];
    }
    
//f2
int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        //前两天未持有
        int pre2_i_0 = 0;
        //第i天未持有
        int dp_i_0 = 0;
        //第i天持有
        int dp_i_1 = INT_MIN;
        for (int i = 0; i < prices.size(); i++) {
            int temp = dp_i_0;
            dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
            dp_i_1 = max(dp_i_1, pre2_i_0 - prices[i]);
            pre2_i_0 = temp;
        }
        return dp_i_0;
    }

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

在这里插入图片描述

思路
K == 2了, 需要创建一个三维的dp

int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int max_k = 2;
        int dp[prices.size()][max_k + 1][2];
        //初始化这块内存区域,全部设置为0
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < prices.size(); i++) {
            for (int k = max_k; k >= 1; k--) {
                if (i - 1 == -1) {
                    dp[0][k][0] = 0;
                    dp[0][k][1] = -prices[0];
                    continue;
                }
                //dp[i][k][0] 第i天还有k次交易机会没持有: 没持有原因是 保持昨天或者昨天买今天卖
                dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
                dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);
            }
        }
        return dp[prices.size() - 1][max_k][0];
    }

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

在这里插入图片描述
思路
和上题k = 2 一样, 只不过这次k > 2, 那么因为股票买进卖出最多是 prices.size / 2次, 大于的话就相当于k=无限
那么就可以忽略k了

//k为不限制的function
int moewMaxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int dp[prices.size()][2];
        for (int i = 0; i < prices.size(); i++) {
            if (i - 1 == -1) {
                dp[0][0] = 0;
                dp[0][1] = -prices[i];
                continue;
            }
            //因为是多次交易,所以需要保存temp, temp是昨天为持有的收益,可能是已经卖了
            int temp = 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], temp - prices[i]);
        }
        return dp[prices.size() - 1][0];
    }
	
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() < 2) return 0;
        //如果k > 一半的话就是无限的
        if (k > prices.size() / 2) {
            return moewMaxProfit(prices);
        }
                int max_k = k;
                int dp[prices.size()][max_k + 1][2];
                memset(dp, 0, sizeof(dp));
                for (int i = 0; i < prices.size(); i++) {
                    for (int k = max_k; k >= 1; k--) {
                        if (i - 1 == -1) {
                            dp[0][k][0] = 0;
                            dp[0][k][1] = -prices[0];
                            continue;
                        }
                        dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
                        dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);
                    }
                }
        return dp[prices.size() - 1][max_k][0];
    }
qqchqiuqiuyy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode买卖股票问题集合（六种股票问题）
weixin_47692079的博客
05-23 2092
一、买卖股票的最佳时机 （LeetCode 121） 简单的动态规划问题，只能完成一次买卖，定义二维 dp[i] [] 数组，dp [i] [0]表示没有股票的状态，dp [i] [1]表示持有股票的状态，由于只能买卖一次股票所以 dp [i] [1]不受dp [i-1] [0]的影响 public int maxProfit(int[] prices) { int[][] dp = new int[prices.length][2]; dp[0][0] = 0;
leetcode-买卖股票
qq_46127986的博客
02-23 6110
买卖股票的最佳时机 题目 给定一个数组 prices ，其中 prices[i] 表示股票第 i 天的价格。 在每一天，你可能会决定购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以购买它，然后在 同一天 出售。 返回 你能获得的 最大 利润 。 代码 /** * @param {number[]} prices * @return {number} */ var maxProfit = function(prices) { var get = 0; var c
【Leetcode】股票买卖类问题
董小虫的专栏
06-03 282
股票买卖类算法题模板解法
Leetcode 买卖股票
一只老风铃
05-22 419
题目描述 假设你有一个数组，其中第i个元素是某只股票在第i天的价格。 设计一个算法来求最大的利润。你最多可以进行两次交易。 注意: 你不能同时进行多个交易(即，你必须在再次购买之前出售之前买的股票)。 示例1 输入 复制 [1,4,2] 输出 复制 3 思路：采取四个变量记录买入卖出 buy1 sell1 buy2 sell2 假设你现在手里的钱数为0。 buy1，记录的是在从第1天到第i天你能买到的最低价格（买了，所以欠账，所以记录为负数，所以用max）， sel...
买卖股票问题系列（Leecode刷题）
李耳日的博客
09-09 289
121. 买卖股票的最佳时机 点击跳转 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利...
LeetCode动态规划基础题-股票买卖
忆_恒心的博客
05-02 969
动态规划leetcode
Leetcode——买卖股票问题汇总
Michael_Jay的博客
12-14 1312
本篇文章汇总了股票买卖的五种问题，采取动态规划算法循序渐进解题。
leetCode-买卖股票的最佳时机 II
wyp07108的博客
05-15 417
题目描述：https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/22/给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股...
Leetcode-买卖股票的时机
一只禾的博客
01-04 197
Leetcode:122. 买卖股票的最佳时机 II - 力扣（LeetCode） (leetcode-cn.com) 1.贪心法： 时间复杂度：O（n) 空间复杂度：O（1） 代码如下： class Solution(object): def maxProfit(self, prices): """ :type prices: List[int] :rtype: int """ res=0
leetcode-买卖股票的最佳时机
gs_albb的博客
07-09 282
leetcode 本质就是寻找数组中差值 (相对靠后的元素的值-相对靠前的元素值) 最大的两个元素。容易想到使用双指针，指针front 指向相对靠前的元素，初始值为0; 指针back指向相对靠后的元素，初始值为nums.length-1; int max 表示当前遍历到的所有情况下的最大差值。 现在的目标就是寻找一种移动,指针的方式，遍历所有可能的情况，获得最大差值。1 . 记录; 2 . 如果且， 表示front后的一个元素比front当前元素可能更小，那么与back结合形成的差值就更大。所以 可以使f
股票买卖最佳时机leetcode-stock-trading:股票交易
07-07
股票买卖最佳时机leetcode 评估前端架构 编码模式。 组件雇佣制和组织 如果需要，使用预先React功能。 在时间范围内从模型升级设计 解决方案 跑步 克隆这个项目并 cd 到项目中 运行 npm 安装 运行 npm 服务 建筑学 ...
股票买卖最佳时机leetcode-leetcode-challenges:leetcode-挑战
07-07
股票买卖最佳时机leetcode leetcode-挑战 一个包含我从 LeetCode 完成的所有编码挑战的存储库。 我不拥有这些问题的权利，只是为了修改目的而保存我的提交。 字符串挑战 整数 数组 数学 链表 排序 二叉树 递归
股票买卖最佳时机leetcode-OmniTrade:股票交易推荐系统
07-07
股票买卖最佳时机leetcode 全方位交易 高级描述 简而言之： 使用神经网络根据历史市场数据生成买入或卖出信号 自动模型构建和调整（超参数搜索） 自动更新股价数据 灵活便于实验，例如。 对于不同的股票组合，不同的...
鸡蛋掉落leetcode-LeetCode-Solutions:LeetCode-解决方案
07-06
0188.买卖股票的最佳时机 IV 0240.搜索二维矩阵 II 0260.只出现一次的数字 III 0887.鸡蛋掉落 模拟 0134.加油站 0146.LRU缓存机制 0202.快乐数 0289.生命游戏 0371.两整数之和 0412.Fizz Buzz 数组 0152.乘积最大子...
leetcode1239-LeetCode-Golang:LeetCode-Golang
07-01
leetcode 1239 LeetCode-Golang 大批 题号 题目 难度 3总和 中等的 4sum 中等的 从排序数组中删除重复项 简单的 ...买卖股票的最佳时机 简单的 房屋强盗 中等的 房屋强盗 II 中等的 最长递增子序列 中等
C++ 继承篇
2301_79201049的博客
07-18 675
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 176
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 368
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C语言动态内存管理
最新发布
m0_62183318的博客
07-22 677
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
LeetCode股票买卖问题：动态规划解法
- 这道题考察的是单次买卖股票的问题。函数`maxProfit(prices)`接收一个整数数组`prices`，表示股票在不同日期的价格。通过遍历整个价格序列，找到最低价`min_price`，然后计算在每一步卖出时的利润（当前价格减去...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值