【算法优选】 动态规划之简单多状态dp问题——贰

文章目录

  • 🎋前言
  • 🌴[买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
    • 🚩题目描述
    • 🚩算法思路:
      • 🎈状态表示:
      • 🎈状态转移方程:
      • 🎈初始化:
      • 🎈填表顺序:
      • 🎈返回值:
    • 🚩代码实现
  • 🍃[买卖股票的最佳时期含手续费(medium)](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
    • 🚩题目描述
    • 🚩算法思路
      • 🎈状态表示:
      • 🎈状态转移方程:
      • 🎈初始化:
      • 🎈填表顺序:
      • 🎈返回值:
    • 🚩代码实现
  • 🌳[买卖股票的最佳时机 III](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/description/)
    • 🚩题目描述
    • 🚩算法思路
      • 🎈状态表示:
      • 🎈状态转移方程:
      • 🎈初始化:
      • 🎈填表顺序:
      • 🎈返回值:
    • 🚩代码实现
  • ⭕总结

🎋前言

动态规划相关题目都可以参考以下五个步骤进行解答:

  1. 状态表示

  2. 状态转移⽅程

  3. 初始化

  4. 填表顺序

  5. 返回值

后面题的解答思路也将按照这五个步骤进行讲解。

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

🚩题目描述

给定一个整数数组prices,其中第 prices[i] 表示第 i 天的股票价格

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

卖出股票后,你无法在第二天买入股票 (即冷冻期为 1 天)。

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

  • 示例 1:
    输入: prices = [1,2,3,0,2]
    输出: 3
    解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
  • 示例 2:
    输入: prices = [1]
    输出: 0
class Solution {public int maxProfit(int[] prices) {}
}

🚩算法思路:

🎈状态表示:

对于线性dp ,我们可以⽤「经验+题⽬要求」来定义状态表示:

  • 以某个位置为结尾…;
  • 以某个位置为起点…。

这里我们选择比较常⽤的⽅式,以某个位置为结尾,结合题目要求,定义⼀个状态表⽰:

由于有「买⼊」「可交易」「冷冻期」三个状态,因此我们可以选择⽤三个数组,其中:

  • dp[i][0] 表⽰:第 i 天结束后,处于「买⼊」状态,此时的最⼤利润;
  • dp[i][1]表⽰:第 i 天结束后,处于「可交易」状态,此时的最⼤利润;
  • dp[i][2] 表⽰:第 i 天结束后,处于「冷冻期」状态,此时的最⼤利润。

🎈状态转移方程:

我们要谨记规则:

  1. 处于「买⼊」状态的时候,我们现在有股票,此时不能买股票,只能继续持有股票,或者卖出股票;
  2. 处于「卖出」状态的时候:
    • 如果「在冷冻期」,不能买⼊;
    • 如果「不在冷冻期」,才能买⼊。

对于 dp[i][0] ,我们有「两种情况」能到达这个状态:

  1. 在 i - 1 天持有股票,此时最⼤收益应该和 i - 1 天的保持⼀致: dp[i - 1][0] ;
  2. 在 i 天买⼊股票,那我们应该选择 i - 1 天不在冷冻期的时候买⼊,由于买⼊需要花钱,所以此时最⼤收益为: dp[i - 1][1] - prices[i]

两种情况应取最⼤值,因此: dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]) 。

对于 dp[i][1] ,我们有「两种情况」能到达这个状态:

  1. 在 i - 1 天的时候,已经处于冷冻期,然后啥也不⼲到第 i 天,此时对应的状态为:dp[i - 1][2] ;
  2. 在 i - 1 天的时候,⼿上没有股票,也不在冷冻期,但是依旧啥也不干到第 i 天,此时对应的状态为 dp[i - 1][1] ;

两种情况应取最⼤值,因此: dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]) 。

对于 dp[1][i] ,我们只有「⼀种情况」能到达这个状态:

  1. 在 i - 1 天的时候,卖出股票。
  2. 因此对应的状态转移为: dp[i][2] = dp[i - 1][0] + prices[i]

🎈初始化:

三种状态都会用到前⼀个位置的值,因此需要初始化每⼀行的第⼀个位置:

  • dp[0][0] :此时要想处于「买⼊」状态,必须把第⼀天的股票买了,因此 dp[0][0] = -prices[0] ;
  • dp[0][1] :啥也不用干即可,因此 dp[0][1] = 0 ;
  • dp[0][2] :⼿上没有股票,买⼀下卖⼀下就处于冷冻期,此时收益为 0 ,因此 dp[0][2]= 0 。

🎈填表顺序:

根据「状态表示」,我们要三个表⼀起填,每⼀个表「从左往右」。

🎈返回值:

应该返回「卖出状态」下的最⼤值,因此应该返回 max(dp[n - 1][1], dp[n - 1][2])

🚩代码实现

class Solution {public int maxProfit(int[] prices) {int n = prices.length;int[][] dp = new int[n][3];dp[0][0] = - prices[0];for(int i = 1; i < n; i++) {dp[i][0] =  Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][2]);dp[i][2] = dp[i - 1][0] + prices[i];}return Math.max(dp[n - 1][1], dp[n - 1][2]);}
}

🍃买卖股票的最佳时期含手续费(medium)

🚩题目描述

给定一个整数数组 prices,其中 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
  • 示例 2:
    输入:prices = [1,3,7,5,10,3], fee = 3
    输出:6
class Solution {public int maxProfit(int[] prices, int fee) {}
}

🚩算法思路

🎈状态表示:

对于线性 dp ,我们可以⽤「经验 + 题⽬要求」来定义状态表⽰:

  1. 以某个位置为结尾,进行操作;
  2. 以某个位置为起点,进行操作。

这里我们选择比较常用的方式,以某个位置为结尾,结合题目要求,定义⼀个状态表示:

由于有「买⼊」「可交易」两个状态,因此我们可以选择用两个数组,其中:

  • f[i] 表示:第 i 天结束后,处于「买⼊」状态,此时的最大利润;
  • g[i] 表示:第 i 天结束后,处于「卖出」状态,此时的最大利润。

🎈状态转移方程:

我们选择在「卖出」的时候,支付这个手续费,那么在「买入」的时候,就不⽤再考虑⼿续费的问题。

对于 f[i] ,我们有两种情况能到达这个状态:

  1. 在 i - 1 天「持有」股票,第 i 天啥也不干。此时最⼤收益为 f[i - 1] ;
  2. 在 i - 1 天的时候「没有」股票,在第 i 天买⼊股票。此时最⼤收益为 g[i - 1] - prices[i])

两种情况下应该取最大值,因此 f[i] = max(f[i - 1], g[i - 1] -prices[i]) 。

对于 g[i] ,我们也有两种情况能够到达这个状态:

  1. 在 i - 1 天「持有」股票,但是在第 i 天将股票卖出。此时最大收益为: f[i - 1]+ prices[i] - fee) ,记得手续费;
  2. 在 i - 1 天「没有」股票,然后第 i 天啥也不干。此时最大收益为: g[i - 1] ;

两种情况下应该取最大值,因此 g[i] = max(g[i - 1], f[i - 1] + prices[i] - free) 。

class Solution {public int maxProfit(int[] prices, int fee) {int[] f = new int[prices.length];int[] g = new int[prices.length];f[0] = -prices[0];for (int i = 1; i < prices.length; i++) {f[i] = Math.max(f[i - 1],g[i - 1] - prices[i]);g[i] = Math.max(g[i - 1], f[i - 1] + prices[i] - fee); }return g[prices.length - 1];}
}

🎈初始化:

由于需要用到前面的状态,因此需要初始化第⼀个位置。

  • 对于 f[0] ,此时处于「买入」状态,因此 f[0] = -prices[0] ;
  • 对于 g[0] ,此时处于「没有股票」状态,啥也不干即可获得最大收益,因此 g[0] = 0

🎈填表顺序:

毫⽆疑问是「从左往右」,但是两个表需要⼀起填。

🎈返回值:

应该返回「卖出」状态下,最后⼀天的最大值收益: g[n - 1]

🚩代码实现

class Solution {public int maxProfit(int[] prices, int fee) {int[] f = new int[prices.length];int[] g = new int[prices.length];f[0] = -prices[0];for (int i = 1; i < prices.length; i++) {f[i] = Math.max(f[i - 1],g[i - 1] - prices[i]);g[i] = Math.max(g[i - 1], f[i - 1] + prices[i] - fee); }return g[prices.length - 1];}
}

🌳买卖股票的最佳时机 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
class Solution {public int maxProfit(int[] prices) {}
}

🚩算法思路

🎈状态表示:

对于线性 dp ,我们可以⽤「经验 + 题目要求」来定义状态表示:

  1. 以某个位置为结尾,进行一系列操作;
  2. 以某个位置为起点,进行一系列操作。

这里我们选择比较常⽤的⽅式,以某个位置为结尾,结合题目要求,定义⼀个状态表⽰:

由于有「买⼊」「可交易」两个状态,因此我们可以选择用两个数组。但是这道题⾥⾯还有交易次数的限制,因此我们还需要再加上⼀维,用来表示交易次数。其中:

  • f[i][j] 表⽰:第 i 天结束后,完成了 j 次交易,处于「买⼊」状态,此时的最⼤利润;

  • g[i][j] 表⽰:第 i 天结束后,完成了 j 次交易,处于「卖出」状态,此时的最⼤利润。

🎈状态转移方程:

对于 f[i][j] ,我们有两种情况到这个状态:

  1. 在 i - 1 天的时候,交易了 j 次,处于「买⼊」状态,第 i 天啥也不干即可。此时最大利润为: f[i - 1][j] ;
  2. 在 i - 1 天的时候,交易了 j 次,处于「卖出」状态,第 i 天的时候把股票买了。此时的最⼤利润为: g[i - 1][j] - prices[i] 。

综上,我们要的是「最⼤利润」,因此是两者的最⼤值: f[i][j] = max(f[i - 1][j],g[i - 1][j] - prices[i]) 。

对于 g[i][j] ,我们也有两种情况可以到达这个状态:

  1. 在 i - 1 天的时候,交易了 j 次,处于「卖出」状态,第 i 天啥也不⼲即可。此时的最大利润为: g[i - 1][j] ;
  2. 在 i - 1 天的时候,交易了 j - 1 次,处于「买⼊」状态,第 i 天把股票卖了,然后就完成了 j ⽐交易。此时的最⼤利润为: f[i - 1][j - 1] + prices[i] 。但是这个状态不⼀定存在,要先判断⼀下。

综上,我们要的是最⼤利润,因此状态转移方程为:

g[i][j] = g[i - 1][j];
if(j >= 1) {g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);
}

🎈初始化:

由于需要用到 i = 0 时的状态,因此我们初始化第⼀行即可。

  • 当处于第 0 天的时候,只能处于「买⼊过⼀次」的状态,此时的收益为 -prices[0] ,因此 f[0][0] = - prices[0] 。
  • 为了取 max 的时候,⼀些不存在的状态「起不到干扰」的作用,我们统统将它们初始化为 - INF (用 INT_MIN 在计算过程中会有「溢出」的风险,这⾥ INF 折半取0x3f3f3f3f ,足够小即可)

🎈填表顺序:

从「上往下填」每⼀行,每⼀行「从左往右」,两个表「⼀起填」。

🎈返回值:

返回处于「卖出状态」的最⼤值,但是我们也「不知道是交易了⼏次」,因此返回 g 表最后⼀行的最大值。

🚩代码实现

class Solution {public int maxProfit(int[] prices) {// 1. 创建 dp 表// 2. 初始化// 3. 填表// 4. 返回值int INF = 0x3f3f3f3f;int n = prices.length;int[][] f = new int[n][3];int[][] g = new int[n][3];for(int j = 0; j < 3; j++) {f[0][j] = g[0][j] = -INF;}f[0][0] = -prices[0];g[0][0] = 0;for(int i = 1; i < n; i++) {for (int j = 0; j < 3; j++) {f[i][j] = Math.max(f[i - 1][j], g[i - 1][j] - prices[i]);g[i][j] = g[i - 1][j];// 判断状态是否存在if (j - 1 >= 0) {g[i][j] = Math.max(g[i][j], f[i - 1][j - 1] + prices[i]);}}}//找出最后一行的最大值int ret = 0; for(int j = 0; j < 3; j++) {ret = Math.max(ret, g[n - 1][j]);}return ret;}
}

⭕总结

关于《【算法优选】 动态规划之简单多状态dp问题——贰》就讲解到这儿,感谢大家的支持,欢迎各位留言交流以及批评指正,如果文章对您有帮助或者觉得作者写的还不错可以点一下关注,点赞,收藏支持一下!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/805730.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Host Aware SMR

SMR 简介 首先给一点前置SMR知识。 SMR优势&#xff1a;Capacity的提升。 看图&#xff1a;由于重叠Track使得存储密度得到了提升。但是由于Track的重叠&#xff0c;使得SMR只能顺序写。 在SMR中&#xff0c;多个Track组成一个Band&#xff0c;各个Band之间可以随机写 这个 …

设计模式-依赖倒置原则

基本介绍 依赖倒转原则(Dependence Inversion Principle)是指: 高层模块不应该依赖低层模块&#xff0c;二者都应该依赖其抽象抽象不应该依赖细节&#xff0c;细节应该依赖抽象依赖倒转(倒置)的中心思想是面向接口编程依赖倒转原则是基于这样的设计理念:相对于细节的多变性&a…

94岁诺奖得主希格斯去世,曾预言「上帝粒子」的存在

ChatGPT狂飙160天&#xff0c;世界已经不是之前的样子。 新建了免费的人工智能中文站https://ai.weoknow.com 新建了收费的人工智能中文站https://ai.hzytsoft.cn/ 更多资源欢迎关注 一位用诗意的语言揭示宇宙秘密的人。 一位 94 岁伟大科学家的逝世&#xff0c;引发了人们广泛…

RUST语言值所有权之内存复制与移动

1.RUST中每个值都有一个所有者,每次只能有一个所有者 String::from函数会为字符串hello分配一块内存 内存示例如下: 在内存分配前调用s1正常输出 在分配s1给s2后调用报错 因为s1分配给s2后,s1的指向自动失效 s1被move到s2 s1自动释放 字符串克隆使用 所有整数类型,布尔类型 …

深入了解go的通道类型

目录 目录 一:类型介绍 二:通道操作 三:通道的特性 四:通道的注意事项

控制文件损坏处理

二、有rman备份的恢复 2.1 只损坏一个控制文件的情况 本文档的恢复场景都是针对的多控制文件的情况&#xff0c;如果你只有一个那当我没说&#x1f604;。 查看控制文件 SQL> show parameter control_files;NAME TYPE VALUE ---------------------…

nandgame中的Code generation(代码生成)

题目说明&#xff1a; 代码生成为语言的语法规则定义代码生成&#xff0c;以支持加法和减法。 您可以使用在前面级别中定义的堆栈操作&#xff08;如ADD和SUB&#xff09;。代码生成模板通常需要包含规则中其他符号的代码。 这些可以通过方括号中的符号名称插入。例如&#xf…

Linux生态系统:探索Linux的开源世界

Linux生态系统:探索Linux的开源世界 在前面的博客中,我们深入探讨了Linux的各种技能和技巧,从入门到进阶,再到高手级别。这一路走来,相信大家对Linux已经有了全面的认识和掌握。然而,Linux的魅力远不止于此。今天,我们将进一步探索Linux生态系统,了解Linux在开源世界中的重要地…

day03-java类型转换和运算符

3.1 表达式和语句 表达式一共分为三种&#xff1a; &#xff08;1&#xff09;变量或常量 运算符构成的计算表达式 &#xff08;2&#xff09;new 表达式&#xff0c;结果是一个数组或类的对象。&#xff08;后面讲&#xff09; &#xff08;3&#xff09;方法调用表达式&…

接口自动化进阶: Pytest之Fixture拓展及conftest.py加载机制!

Pytest是一个功能强大的Python测试框架&#xff0c;它提供了很多有用的功能和扩展机制。其中之一是Fixture&#xff0c;Fixture是pytest中的一个装饰器&#xff0c;可以用来提供测试所需的数据和对象。 本篇文章将从头开始&#xff0c;详细介绍如何使用Fixture进行接口自动化测…

关于moviepy出现must be real number, not NoneType

#降级装饰器版本 decorator4.4.2 不行就再降4.0.2 有的也可以通过省级mv解决更多解答https://stackoverflow.com/questions/68032884/getting-typeerror-must-be-real-number-not-nonetype-whenever-trying-to-run-wr

Linux安装Oracle11g(无图形界面下的静默安装)

Oracle11g安装文档-Linux静默安装 环境准备安装数据库配置监听器创建数据库测试打开防火墙 环境准备 创建组和用户 [rootlocalhost ~]# groupadd oinstall #创建oinstall组 [rootlocalhost ~]# groupadd dba  #创建dba组 [rootlocalhost ~]# useradd -g oinstall -G dba -m…

鸿蒙HarmonyOS开发实例:【分布式关系型数据库】

介绍 本示例使用[ohos.data.relationalStore]接口和[ohos.distributedDeviceManager] 接口展示了在eTS中分布式关系型数据库的使用&#xff0c;在增、删、改、查的基本操作外&#xff0c;还包括分布式数据库的数据同步同能。 效果预览 使用说明: 启动应用后点击“ ”按钮可…

《QT实用小工具·十七》密钥生成工具

1、概述 源码放在文章末尾 该项目主要用于生成密钥&#xff0c;下面是demo演示&#xff1a; 项目部分代码如下&#xff1a; #pragma execution_character_set("utf-8")#include "frmmain.h" #include "ui_frmmain.h" #include "qmessag…

ArrayList中多线程的不安全问题

ArrayList中的不安全问题 正常的输出 List<String> list Arrays.asList("1","2","3"); list.forEach(System.out::println);为什么可以这样输出&#xff0c;是一种函数是接口&#xff0c;我们先过个耳熟 Arrys.asList是返回一个ArrayL…

【leetcode面试经典150题】40. 同构字符串(C++)

【leetcode面试经典150题】专栏系列将为准备暑期实习生以及秋招的同学们提高在面试时的经典面试算法题的思路和想法。本专栏将以一题多解和精简算法思路为主&#xff0c;题解使用C语言。&#xff08;若有使用其他语言的同学也可了解题解思路&#xff0c;本质上语法内容一致&…

进程间通信 (匿名管道)

一、进程间通信的概念 进程间通信是一个进程把自己的数据交给另一个进程&#xff0c;它可以帮助我们进行数据传输、资源共享、通知事件和进程控制。 进程间通信的本质是让不同的进程看到同一份资源。因此&#xff0c;我们要有&#xff1a; 1、交换数据的空间。2、这个空间不能由…

端口号占用解决方法

进入cmd输入&#xff1a; 第一步输入&#xff1a;netstat -ano|findstr 8080 第二步输入&#xff1a;taskkill -pid **** -f (示例)&#xff1a; C:\Users\Administrator>netstat -ano|findstr 8080 TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING …

AcWing 790. 数的三次方根——算法基础课题解

AcWing 790. 数的三次方根 题目描述 给定一个浮点数 n&#xff0c;求它的三次方根。 输入格式 共一行&#xff0c;包含一个浮点数 n。 输出格式 共一行&#xff0c;包含一个浮点数&#xff0c;表示问题的解。 注意&#xff0c;结果保留 6 位小数。 数据范围 −10000≤…

Linux链接文件管理——硬链接、符号链接

Linux链接文件管理——硬链接、符号链接 硬链接 硬链接是对文件的另一个名字&#xff0c;对于硬链接的文件来说&#xff0c;他们拥有同样的inode号(索引节点号)&#xff0c;表示它们是同一个文件。 创建硬链接不会消耗新的inode和block。 删除硬链接文件&#xff0c;不会影响…