算法力扣刷题记录 八十八【122.买卖股票的最佳时机 II】

于 2024-08-21 11:40:15 发布
阅读量667 收藏 14
点赞数 27
分类专栏： # 贪心算法章节 # 动态规划章节 算法小白力扣刷题记录 文章标签： 算法 leetcode 职场和发展 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/danaaaa/article/details/141351988
版权

前言

在本文之前，纠正了回溯章节中去重方式和排序之间的关系，可以去：记录 八十【491.递增子序列及去重方式——排序关系】中回顾。

贪心章节第5篇。动态规划第11篇。记录 八十八【122.买卖股票的最佳时机 II】

一、题目阅读

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

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

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
最大总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。

提示：

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

二、尝试实现

2.1 分析题目，确定方法

  1. 题目要求最大利润。虽然可以同一天购买，同一天出售，但是这个利润是0。所以先不考虑同一天买同一天卖这种情况；

  2. 分析示例，确定如何获得最大值：启发——记录 七十九【376. 摆动序列】，所以才想到改成折线图看看。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  3. 所以：贪心算法可以解决。

  • 局部最优：每个单调递增坡的最低点买入，最高点卖出；一个递增坡获得最大利润
  • 全局最优：所有的递增坡获得整体的最大利润。

2.2 贪心思路实现

  1. 沿用记录 七十九【376. 摆动序列】的思路和细节进行处理；用pridiff和curdiff表示递增还是递减。
  2. 定义 int pay = 0；代表股票买入的价格。int sale = 0;表示股票卖出的价格。
  3. 以示例1，较为规律的序列：

  • if(pridiff < 0 && curdiff > 0) ，代表一个单调递增坡的起点，应该买入。类似节点1，节点3；

  • if(pridiff > 0 && curdiff < 0)，代表一个单调递增坡的终点，应该卖出。类似节点5，节点6；

  • for循环：从0开始到prices.size()-1结束；

  • pridiff初始为0；curdiff = prices[i+1]-prices[i];。

  • 同时result代表全局的最大利润，应该求和每一个单调递增坡的最大利润。result += sale-pay;

  • 所以这种情况下：代码如下——

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int pridiff = 0;
        int curdiff = 0;
        int pay = 0;//购入的价格
        int sale = 0;//出售的价格
        for(int i = 0;i < prices.size()-1;i++){
            curdiff = prices[i+1]-prices[i];
            if(pridiff < 0 && curdiff > 0) {
                pay = prices[i];
            }
            if(pridiff > 0 && curdiff < 0){
                sale = prices[i];
                result += sale-pay; //求和每次买卖的价格
            }
            pridiff = curdiff;
        }
        
        return result;
    }
};
  1. 补充情况一：起点和终点如何处理：
  • 在记录 七十九【376. 摆动序列】起点构造了一个平坡，pridiff = 0。在这里起点应该构造一个下降的坡。理由如下：
    在这里插入图片描述
  • 终点处理：扩展for循环到prices.size()-1停止。终止的curdiff = -1，表示终点是一个单调坡的最高点。理由如下：
    在这里插入图片描述
  • 所以：起点和重点的处理，使得始终单调递增（示例2）和始终单调递减（示例3）得以解决，所以代码更改：
    • pridiff = -1;初始化。//构造起点的下降坡
    • for循环范围到i < prices.size()；
    • if(i == prices.size()-1) curdiff = -1;//构造终点的下降坡
    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int pridiff = -1;//构造起点的下降坡
        int curdiff = 0;
        int pay = 0;//购入的价格
        int sale = 0;//出售的价格
        for(int i = 0;i < prices.size();i++){
            if(i == prices.size()-1) {
                curdiff = -1;//构造终点的下降坡
            }else{
                curdiff = prices[i+1]-prices[i];
            }
            if(pridiff < 0 && curdiff > 0) {
                pay = prices[i];
            }
            if(pridiff > 0 && curdiff < 0){
                sale = prices[i];
                result += sale-pay; //求和每次买卖的价格
            }
            pridiff = curdiff;
        }
        
        return result;
    }
};
  1. 补充情况二：如果遇到平坡怎么办？以平坡的最后一个元素作为买/卖的节点。

  • 所以两个pridiff和curdiff的判断条件改成：

  • if(pridiff <= 0 && curdiff > 0) 和 if(pridiff >= 0 && curdiff < 0)
    在这里插入图片描述
    所以代码改变：

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int pridiff = -1;//构造起点的下降坡
        int curdiff = 0;
        int pay = 0;//购入的价格
        int sale = 0;//出售的价格
        for(int i = 0;i < prices.size();i++){
            if(i == prices.size()-1) {
                curdiff = -1;//构造终点的下降坡
            }else{
                curdiff = prices[i+1]-prices[i];
            }
            if(pridiff <= 0 && curdiff > 0) {
                pay = prices[i];
            }
            if(pridiff >= 0 && curdiff < 0){
                sale = prices[i];
                result += sale-pay; //求和每次买卖的价格
            }
            pridiff = curdiff;
        }
        
        return result;
    }
};
  1. 补充情况三：单调坡中有平坡怎么办？所以pridiff = curdiff;不应该每个节点都更新。

  • 更新pay时，更新pridiff；更新sale时，更新pridiff。

  • 所以pridiff = curdiff;放到两个if条件里面。
    在这里插入图片描述
    代码更新：

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int pridiff = -1;
        int curdiff = 0;
        int pay = 0;//购入的价格
        int sale = 0;//出售的价格
        for(int i = 0;i < prices.size();i++){
            if(i == prices.size()-1) {
                curdiff = -1;
            }else{
                curdiff = prices[i+1]-prices[i];
            }
            if(pridiff <= 0 && curdiff > 0) {
                pay = prices[i];
                pridiff = curdiff;
            }
            if(pridiff >= 0 && curdiff < 0){
                sale = prices[i];
                result += sale-pay;
                pridiff = curdiff;
            }
            
        }
        
        return result;
    }
};

2.3 代码实现【贪心算法】

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int pridiff = -1;
        int curdiff = 0;
        int pay = 0;//购入的价格
        int sale = 0;//出售的价格
        for(int i = 0;i < prices.size();i++){
            if(i == prices.size()-1) {
                curdiff = -1;
            }else{
                curdiff = prices[i+1]-prices[i];
            }
            if(pridiff <= 0 && curdiff > 0) {
                pay = prices[i];
                pridiff = curdiff;
            }
            if(pridiff >= 0 && curdiff < 0){
                sale = prices[i];
                result += sale-pay;
                pridiff = curdiff;
            }
            
        }
        
        return result;
    }
};

三、参考学习

【122.买卖股票的最佳时机 II】 参考学习链接

3.1 【122.买卖股票的最佳时机 II】贪心思路

  1. 回到题目中：“在每一天，你可以决定是否购买 和/或出售股票。”——含义是：当天可以只买入或者只卖出或者既买入又卖出。很明显：同一天买入同一天卖出没有利润，因此至少需要两天完成一个交易。所以利润可以进行拆分：
  2. 如何进行利润拆分？如下图：
    在这里插入图片描述
  3. 总结：
  • 个人思路：从记录 七十九【376. 摆动序列】中获得区间单调坡的概念，所以使用区间的利润可以找到一个最低点买入，最高点卖出。但是情况思考比较多，处理细节也繁琐。
  • 参考思路：发现利润可以拆分，所以只搜集正数即可。

3.2 代码实现【贪心：参考思路】

边遍历边搜集利润中的正数。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for(int i = 1;i < prices.size();i++){
            result += max(prices[i]-prices[i-1],0);//只搜集正数
        }
        return result;
    }
};

3.3 动态规划思路

3.3.1思考

  1. 买卖股票系列是动态规划章节内容，但是贪心算法可以帮助一些题目巧妙解决，并不代表贪心可以解决所有买卖股票系列的题目。
  2. 那么尝试动态规划实现：
  3. 定义dp数组和下标：dp[i]代表在第i天卖出股票，所能获得的最大利润是dp[i]。
  4. 递推公式：内层循环 j 遍历第i天之前的每一天，dp[i] = max(dp[i] , dp[j] + prices[i] - prices[j])；
    在这里插入图片描述
  5. 初始化：dp[0] = 0；在第0天卖出只能第0天买入，所以利润是0.
  6. 遍历顺序：从递推公式知道外层for循环从前往后。
  7. 返回值是dp数组中什么？所以dp数组的含义设定不正确。那么该如何设定dp数组？

3.3.2 正确思路

  1. dp数组含义：
  • dp[i][0]：在第i天持有股票得到的现金dp[i][0]；
  • dp[i][1]：在第i天不持有股票得到的现金dp[i][1]；
  • 因为最多持股一个，所以当天要么有股票（1个），要么没有股票。
  • 所得现金 = 利润是一个累积值。返回值：最后一天不持有股票时所得现金，即dp[最后一个][1]。
  1. 递推公式：
  • 求dp[i][0]，在第i天持有股票，得到多少钱？
    • 第i天持有股票，要么第i-1天持有股票，今天继续持有不卖出，钱不增加不减少。所得现金：dp[i-1][0]。
    • 第i天持有股票，，要么第i-1天不持有股票，今天重新买入。钱在dp[i-1][1]的基础上减去买入的prices[i]。所得现金：dp[i-1][1] - prices[i]。
    • 取两者的最大值。dp[i][0] = max(dp[i-1][0]，dp[i-1][1] - prices[i])。
  • 求dp[i][1]，在第i天不持有股票，得到多少钱？
    • 第i天不持有股票，要么第i-1天持有股票，今天以prices[i]卖出。钱在dp[i-1][0]基础上多了prices[i]。所得现金：dp[i-1][0] + prices[i]；
    • 第i天不持有股票，要么第i-1天不持有股票，今天也不买入。钱依然是第i-1天不持有股票所得的钱。所以现金：dp[i-1][1]。
    • 取两者的最大值。dp[i][1] = max(dp[i-1][0] + prices[i]，dp[i-1][1])。
  1. 初始化：
  • dp[0][0] = -prices[0]。先买入，花掉了-prices[0]。
  • dp[0][1] = 0；相当于不买入。钱没花没赚。
  1. 遍历顺序：从递推公式看，从前往后。

3.4 代码实现【动态规划】

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        //定义dp数组
        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]);
            dp[i][1] = max(dp[i-1][0] + prices[i],dp[i-1][1]);
        }
        return dp[len-1][1];
    }
};

总结

本文：

danaaaa
关注
  • 27
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode HOT 100 (Java 版)
dwtianwen的博客
07-14 742
一刷 Leetcode HOT 100 记录
“法力无边”的ChatGPT及其负算力.pdf
12-23
"法力无边”的ChatGPT及其负算力 随着技术的迅速发展，人工智能（AI）已经渗透到了我们日常生活的各个方面。其中，ChatGPT作为一个revolutionary的语言生成模型，能够生成各种意识与信息文本，成为智媒研发的最高...
手把手带你刷Leetcode力扣 学习总结
qq_39223444的博客
07-05 1711
文章目录1. 总体规划2. 算法复杂度2.1 时间复杂度2.2 空间复杂度3. 数据结构3.1 数组【Array】3.1.1 Python常用操作3.1.2 Java常用操作3.1.3 练习题3.2 链表【Linked List】3.2.1 Python常用操作3.2.2 Java常用操作3.2.3 练习题3.3 队列【Queue】3.3.1 Python常用操作3.3.2 Java常用操作3.3.3 练习题3.4 栈【Stack】3.4.1 Python常用操作3.4.2 Java常用操作3.4.3 练习
力扣 --- CodeTop --- 2022前端高频面试算法题归纳详解，附带面试中出现频率，冲刺面试算法（JS实现）（持续更新中、）
秋天，黄叶坠地，凉风有信。
03-07 4848
力扣 — 前端面试高频算法题总结（codeTop） 附带题目链接，题目详解，面试中出现的频率，以及最近出现的时间，前端高频算法归纳，冲刺前端算法！使用JavaScript（JS）实现，持续更新中····
ProjectManaTea:恢复法力。 . . 一次一杯
06-30
5. **数据持久化**：如果项目涉及到存储用户的偏好或历史记录，可能使用了数据库技术，如SQLite，这是Java中常用的轻量级数据库。 6. **日历和定时器API**：为了实现定时提醒功能，项目可能利用了Java的Calendar和...
31拓展 10：法力无边 —— Redis Lua 脚本执行原理(1).md
04-01
31拓展 10：法力无边 —— Redis Lua 脚本执行原理(1)
嵌入式系统/ARM技术中的Altera的Quartus II软件支持即插即用信号完整性...
12-04
Altera公司日前公布了即插即用信号完整性技术，这一创新的系统解决方案由最新的Quartus II设计软件提供支持，目前可以在产品级Stratix II GX FPGA中实现。即插即用信号完整性支持单卡配置，在系统功耗允许范围内，可...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 319
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 764
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 492
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
铁马冰河入梦来
08-20 198
哈希表解决存在重复元素二问题
智能微气候:精准调控背后的算法革命
最新发布
u010079117的博客
08-20 653
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
算法之递归和迭代
qq_28576837的博客
08-16 374
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
柠檬喝汽水的博客
08-19 541
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 333
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
算法笔记：空间填充曲线
qq_40206371的博客
08-17 287
六次迭代的希尔伯特曲线：
算法：DFS之记忆化搜索
一名还在努力学习技术的程序员的博客
08-18 662
本篇博客是关于 记忆化搜索 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值