《dp补卡——买卖股票问题》

最新推荐文章于 2025-04-24 23:27:52 发布
最新推荐文章于 2025-04-24 23:27:52 发布
阅读量256 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： # 算法：DP leetcode刷题笔记 文章标签： 算法 买卖股票 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42604176/article/details/116105726
本文介绍了使用动态规划解决股票交易系列问题，包括最佳买卖时机、最佳时机II、最佳时机III、最佳时机IV以及含手续费和冷冻期的情况。通过贪心、滚动数组优化和多种状态转移方程来求解最大利润。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

121. 买卖股票的最佳时机

贪心

取最左最小值，取最右最大值，差值为最大利润

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

dp思路

step1:dp[i][0]表示第i天持有股票最大所得现金。本题中只能买卖一次，所以买入后金额为-price[i]。
dp[i][1]表示第i天不持有股票最大所得现金。持有不等同于买入。
step2:
如果第i天持有股票dp[i][0]可以由两个状态得到。
case1:第i-1持有股票，保持现状，dp[i][0] = dp[i-1][0]
case2:第i天买入股票，所得现金就是买入今天的股票后所得现金。即dp[i][0] = -price[i]
dp[i][0] = max(dp[i-1][0],-price[i]);
如果第i天不持有股票dp[i][1]可以由两个状态得到。
case1: 第i-1不持有股票，保持现状，dp[i][1] = dp[i-1][1]
case2: 第i-1持有股票，第i天卖出,dp[i][1] = dp[i-1][0] + price[i]
dp[i][1] = max(dp[i-1][1],dp[i-1][0]+price[i])
step3:
初始状态为dp[0][0]:第0天持有股票的金额 = -prices[0]
dp[0][1]第0天不持有股票的金额 = 0；
最终结果dp[n][1]而不是dp[n][0],是因为最终必须要把股票卖出才能有收益。不卖出一定更亏。

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

滚动数组优化

由于只用到了dp[i] 与dp[i-1]两个状态，所以只需一个2 * 2的数组即可。

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

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

dp[i][0]:第i天持有股票获取的最大现金
dp[i][1]:第i天不持有股票所得的最多现金
如果第i天持有股票，则dp[i][0]可以由两个状态推导;
case1:第i-1天就持有股票，保持现状，则dp[i][0] = dp[i-1][0]
case2:第i天买入股票，现金则为昨天不持有股票所得现金减去今天股票价格dp[i][0] = dp[i-1][1] - prices[i]
如果第i天不持有股票，则dp[i][1]可以由两个状态推导；
case1：第i-1天不持有股票，保持现状，dp[i][1] = dp[i-1][1]
case2：第i-1天持有股票，第i天卖出，dp[i][1] = dp[i-1][0] + prices[i]

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

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

至多买卖两次，即可以买卖一次，也可以买卖两次，也可以不买卖。
每一天由五个状态：
0、没有操作
1、第一次买入
2、第一次卖出
3、第二次买入
4、第二次卖出
dp[i][j]:i表示第i天，j为[0-4]五个状态，dp[i][j]表示第i天状态j所剩最大现金。

2、确定递推公式
举例dp[i][1]:表示第i天，买入股票的状态，并不是说一定要第i天买入股票。
达到dp[i][1]状态，有两个具体操作：
case1：第i天买入股票，那么dp[i][1] = dp[i-1][0] - prices[i]
case2：第i天没有操作，那么dp[i][1] = dp[i-1][1]
dp[i-1][1] = max(dp[i-1][0]-prices[i],dp[i-1][1]);
同理dp[i][2]也有两个操作：
case1：第i天卖出股票了，那么dp[i][2] = dp[i-1][1] + prices[i]
case2：第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]也有两个操作：
case1：第i天买入股票，dp[i][3] = dp[i-1][2] - prices[i]
case2：第i天没有操作，沿用前一天买入股票的状态，即：dp[i][3] = dp[i-1][3]
同理dp[i][4]也有两个操作：
case1：第i天卖出股票，dp[i][4] = dp[i-1][3] + prices[i]
case2：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][4] = dp[i-1][4]
那么如何初始化呢？
第0天没有操作的话，dp[0][0] = 0
第0天做第一次买入操作的话，dp[0][1] = -prices[0]
第0天做第一次卖出的操作，这个初始值为0。
第0天第二次买入，不管几次，手头上没有钱，只能减少dp[0][3] = -prices[0]
第0天第二次卖出，dp[0][4] = 0

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

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

step1:
这一题为上一题的进阶版本，定义二维dp数组。
使用二维数组dp[i][j]：第i天的状态为j，所剩下的最大现金是dp[i][j]
j的状态表示为：
0不操作、1第一次买入、2第一次卖出、…
除了0以外，偶数就是卖出，奇数就是买入。因为是最多有k笔交易，所以j的范围就定义为2*k+1.

vector<vector<int>> dp(prices.size(),vector<int>(2*k+1,0));

step2:

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

step3:
初始化，只要是买入操作，现金就会相应减少，卖出操作初值均为0

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

AC代码：

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

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

状态一：买入股票状态（可能是今天买入的，也有可能是之前就买入了然后没有操作）
对于卖出股票状态，有两种：
状态二：两天前就卖出了股票，度过了冷冻期，然后一直没有操作，今天仍然保持卖出股票状态
状态三：今天卖出了股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天
递推公式如下：
到达买入股票状态(状态一)即dp[i][0]，有两个具体操作：
case1：前一天就是这个状态，今天沿用该状态dp[i][0] = dp[i-1][0]
case2：今天买入，有两种情况(状态四)
前一天是冷冻期，前一天是保持卖出股票的状态(状态二),这两个情况今天都有可能买入
即：dp[i][0] = max(dp[i-1][0],max(dp[i-1][3],dp[i-1][1])-prices[i])
到达保持卖出状态(状态二)即：dp[i][1]，有两个具体操作：
case1：前一天就是状态二，沿用该状态
case2：前一天是冷冻期（状态四）
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],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数组的初始化：
状态一，持有股票，那么dp[0][0] = -prices[0]
状态二，保持卖出状态，dp[0][1] = 0
状态三，刚卖出股票，同样不会有收入dp[0][2] = 0
状态四，冷冻期，dp[0][3] = 0
最后的结果是从状态二到状态四中选取最大值。

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

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

与122. 买卖股票的最佳时机 II相比，多减去操作费用。

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

    }
};
Vue.js 表单实例教程：构建一个完整的补卡申请页面” “从零开始用 Vue.js 创建交互式补卡申请表单” “手把手教你用 Vue.js 实现动态表单，附带图片上传和审批流程” “Vue.js 实
南北极之间
11-07 644
在本教程中，我们将用 Vue.js 实现一个完整的补卡申请页面，包括输入字段、图片上传、审批流程展示和表单提交功能。这个项目适合 Vue.js 初学者学习如何绑定数据、处理用户交互和实现简单的逻辑功能。首先，我们需要创建一个 HTML 基础页面，并添加 Vue.js 库以及基本的 CSS 样式。这些样式可以帮助我们构建一个美观、简洁的页面布局。 3. 使用 Vue.js 设置数据绑定 将 Vue.js 引入到页面中，并创建一个新的 Vue 实例，初始化数据和方法。 4. 实现补卡申请的输入字段 在 对象
贵州名通考勤批量补卡程序V1.0.7.zip
06-19
贵州名通模拟手机批量补卡，模拟手机提交补卡信息。需要装jdk环境默认安装就可以了，环境装好后双击jar文件不需要解压jar直接运行。打卡记录表补卡.xlsx 里面账号，需要补卡的日期，状态一般0（缺卡or迟到，1表示...
买股票的最佳时机（六种题解dp）
YXXXYX的博客
08-01 506
引言 买股票的最佳时机类的题目也是很经典的动态规划题目，出题人通过各种花里胡哨的买股票方法来考察（虐待）你，下面我们就开始看看一类的题目的各种花样； 买股票的最佳时机 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 示例 1： 输入：[7,1,5,3,6,
《dp补卡——子序列问题》
hanhan的博客
04-25 291
300. 最长递增子序列 step1:dp[i]:下标<=i的最长子序列长度。即以 nums[i] 结尾 的「上升子序列」的长度，注意以nums[nums.size()-1]结尾的上升子序列长度并不一定是全局最优值，所以要从dp[i]中找到最大值。 step2:状态转移方程： if(nums[i] > nums[j]) dp[i] = max(dp[i],dp[j]+1); //取得dp[j]+1中最大的那个值作为dp[i] step3:初始化 每一个i，至少都是1. step4:遍历顺序，从
《dp补卡——完全背包问题》
hanhan的博客
04-24 287
N件物品和一个最多能背重量为W的背包。第i件物品的重量为weight[i]，得到的价值是value[i]。每件物品都有无限个(可以放入背包多次)，求解将哪些物品装入背包里物品价值总和最大。 01背包和完全背包唯一不同在于遍历顺序上。 01背包的核心代码： for(int i = 0; i < weight.size(); i++) //遍历物品 { for(int j = bagWeight; j >= weight[i]; j--) //遍历背包容量 { dp.
《dp补卡——01背包问题》
hanhan的博客
04-23 312
01背包 1、dp数组以及下标含义 dp[i][j]标识从下标为[0,1]的物品里任意取，放进容量为j的背包，价值总和最大是多少？ 2、确定递推公式 dp[i][j]可以由两个方向推出： 1、dp[i-1][j]，背包容量为j，里面不放入物品i的最大价值，此时dp[i][j] = dp[i-1][j] 2、dp[i-1][i-weight[i]]推出，背包容量为i-weight[i]的时候此时dp[i][j] = dp[i-1][j-weight[i]]+valuep[i]; 所以递推公式为： dp[i.
《dp补卡——多重背包》
hanhan的博客
04-24 233
多重背包简介： 有N种物品和一个容量为V的背包。第i种物品最多有Mi件可用，每件耗费的空间为Ci，价值为Wi。求解将哪些物品装入背包可使得这些物品耗费的空间总和不超过背包容量，且价值总和最大。 将Mi件摊开，就是一个01背包问题。 如下列两表就是等价的，图来源于代码随想录。 void test_multi_pack() { vector<int> weight = {1,3,4}; vector<int> value = {15,20,30}; vecto
《dp补卡——343. 整数拆分、96. 不同的二叉搜索树》
hanhan的博客
04-23 197
343. 整数拆分 1、确定dp数组以及下标含义。 dp[i]：分拆数字i，可以得到的最大的乘积 2、确定递推公式： dp[i]最大乘积出处：从1遍历j到i，j * dp[i-j] 与 j * (i-j)取最大值。( 拆分j的情况，在遍历j的过程中dp[i - j]其实都计算过了 ) 所以递推公式为： dp[i] =max(dp[i],max(j*(i-j),j*dp[i-j])); 3、dp的初始化 dp[0] = dp[1] = 0; dp[2] = 1; 4、确定遍历顺序 由于递推公式，dp[i]是
面试试题总结——欢迎前来补卡
觅_的博客
03-03 145
面试题javascriptvueHtmlcss3**欢迎来补卡~~~** javascript javascript中什么是闭包 一个数组如何去重 一个登录实现的流程 vue vue的生命周期 什么是VueX 你知道那些vue中的指令 组件之间如何传值 组件通讯 Html 什么是html html渲染过程 css3 有几种方法可以使元素垂直居中 css3中添加了那些新特性，请举例说明 translate()是什么？ 欢迎来补卡~~~ ...
代码随想录算法训练营第四十二天| DP9— 188. 买卖股票的最佳时机 IV，309. 买卖股票的最佳时机含冷冻期
最新发布
yuhao__z的博客
04-24 709
开始漫长的补卡计划，这次是买卖股票系列的最后一天。。分别对应K次买卖，包含冷冻期的买卖和包含手续费的买卖。包含手续费的买卖比较简单，直接把它当作股票价格涨了相应的费用就行。
代码随想录算法训练营Day53|LeetCode121买卖股票的最佳时机、LeetCode122买卖股票的最佳时机II(补卡)
m0_66412823的博客
02-22 302
LeetCode122买卖股票的最佳时机II。LeetCode121买卖股票的最佳时机。
行业分类-设备装置-一种补卡再售电的方法、平台.zip
08-28
标题中的“行业分类-设备装置-一种补卡再售电的方法、平台”表明这是一个关于智能电表或电力设备管理的专题，主要涉及设备的补卡和再售电操作。描述中的信息与标题相呼应，进一步确认了这个主题的焦点。标签“行业...
详细讲解设计跳表的三个步骤(查找、插入、删除)
hanhan的博客
12-03 7754
目录写在前面跳表概要查找步骤插入步骤删除步骤完整代码 写在前面 关于跳表的一些知识可以参考这篇文章,最好是先看完这篇文章再看详细的思路->代码的复现步骤: Redis内部数据结构详解(6)——skiplist 关于跳表的插入、删除基本操作其实也就是链表的插入和删除，所以如果不熟悉的话还得先回顾链表的插入以及删除是怎样的，可以参考： 【数据结构基础笔记】【链表】 相关代码以及其他语言的写法或者其他思路可以参考： 1206. 设计跳表 代码参考链接： https://leetcode-cn.com/p.
牛客网与leetcode刷题（高频题中简单or中等的）
hanhan的博客
03-06 1874
1、反转链表 反转链表 https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca?tpId=190&tqId=35203&rp=1&ru=%2Factivity%2Foj&qru=%2Fta%2Fjob-code-high-rd%2Fquestion-ranking&tab=answerKey
LeetCode 二叉树、N叉树的最大深度与最小深度(递归解)
hanhan的博客
10-18 1247
目录104. 二叉树的最大深度559. N叉树的最大深度111. 二叉树的最小深度 之前的笔记中，已经用层序遍历解决过这个问题了 现在试着用深度的解法去求解 104. 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / 9 20 / 15 7 返回它的最大深度 3 。 **选择深度遍历方式：**由于我们需要返回深度信息，所
《位运算技巧以及Leetcode的一些位运算题目》
hanhan的博客
04-27 1006
技巧 位运算的一些基础技巧： x ^ 0... = x x ^ 1... = ~x x ^ x = 0 x & 0... = 0 x & 1... = x x & x = x x | 0... = x x | 1... = 1... x | x = x 进阶技巧： n & (n-1) 可以去除n的位级表示中最低的一位： 如 n = 11110100 , n - 1 = 11110011 n & (n-1) = 11110000 n & (-
leetcode中使用c++需要注意的点以及各类容器的初始化、常用成员函数
hanhan的博客
12-10 978
目录1、传引用2、vector使用初始化方法常用成员函数3、字符串string初始化方法常用成员函数4、哈希表 unordered_map初始化常用成员函数示例：计数器5、哈希集合 unordered_set初始化常用成员函数6、队列 queue初始化成员函数7、栈stack初始化常用成员函数7、emplace_back 与 push_back的区别8、未完待续 1、传引用 C++函数参数默认是传值的，如果使用数组之类的容器作为参数，一般会加上&符号表示传引用。 没有加&，就是传值，会涉.
leetcode 51. N 皇后 思考分析
hanhan的博客
11-17 909
目录题目思考AC代码 题目 n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 思考 首先以N=4为例，画出解空间树的一部分： 根据模板： void backtracking(参数) { if(终止条件) { 存放结果; return; } for(选择：本层集合中元素(树中结点孩子的数量就是集合的大小)) { 处理结点; backtracking(路径,选择列表); //递归 回溯，撤销处理结果; } } 1、确.
二分法：两个有序数组长度为N，找到第N、N+1大的数
hanhan的博客
11-30 814
题目 两个数组长度为N，找到第N、N+1大的数 思路1：双指针，O(N)复杂度 简述思路： 如果当前A指针指向的数组A的内容小于B指针指向的数组B的内容，那么A指针往右移动，然后nums(当前已经遍历过的数字个数)也加一。 如果此时已经遍历过的数字个数等于N那么九江移动之前的A指针指向的A数组的内容送入result。 其他情况，以相反的逻辑进行。 //双指针法求解 vector<int> GetMid_On(vector<int>& A, vector<int>&
C#开发舒特考勤补卡系统加强版 功能全面升级
8. 连白班晚班的补卡：这是指补卡程序不仅支持白班的补卡，也支持晚班的补卡。这对于一些需要进行轮班工作的企业，具有重要的意义。 以上就是关于"舒特考勤补卡程序 c#写的舒特补卡加强版"的知识点。希望对你有所...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾牙慧者

欢迎请作者喝奶茶

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值