买卖股票问题-代码随想录-刷题笔记

最新推荐文章于 2024-07-22 16:24:23 发布
最新推荐文章于 2024-07-22 16:24:23 发布
阅读量296 收藏 1
点赞数 1
文章标签： 笔记 动态规划 算法 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63787588/article/details/131222325
版权

image.png

121. 买卖股票的最佳时机：买卖一次

暴力超时

//时间复杂度：O(n^2)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            for (int j = i + 1; j < prices.size(); j++){
                result = max(result, prices[j] - prices[i]);
            }
        }
        return result;
    }
};

贪心

因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。

//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int low = INT_MAX;
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            low = min(low, prices[i]);  // 取最左最小价格
            result = max(result, prices[i] - low); // 直接取最大区间利润
        }
        return result;
    }
};

动态规划

  1. 确定dp数组（dp table）以及下标的含义

dp[i][0]:表示第i天持有股票所得最多现金
dp[i][1] 表示第i天不持有股票所得最多现金
“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2.确定递推公式
dp[i][0]可以由2个状态推出来

  • 第i-1天就持有股票，保持现状，即dp[i-1][0]
  • 第i天买入股票,-prices[i]
  • 即dp[i][0] = max(dp[i - 1][0], -prices[i]);

dp[i][1]可以由2个状态推出来

  • 第i-1天就不持有股票，即dp[i-1][1]
  • 第i天卖出股票,dp[i-1][0]+prices[i]
  • 即dp[i][1] = max(dp[i - 1][1], dp[i-1][0]+prices[i]);

3.初始化
那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4.确定遍历顺序
从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
5.举例推导dp数组
image.png

整体代码

// 版本一
//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        }
        return dp[len - 1][1];
    }
};

滚动数组优化

// 版本二
//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

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

贪心

class Solution {
public:
    int maxProfit(vector<int>& prices) {
       //只要今天买，明天卖赚钱就行
       int sum=0;
       for(int i=1;i<prices.size();i++){
         if(prices[i]>prices[i-1]){
             sum+=prices[i]-prices[i-1];
         }
       }
       return sum;
    }
};

动态规划

1）dp数组的含义
dp[i][0]:表示第i天持有股票所得最多现金
dp[i][1] 表示第i天不持有股票所得最多现金
“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2）递推公式
因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格 即：dp[i - 1][1] - prices[i]。

整体代码

//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        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]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[len - 1][1];
    }
};

滚动数组

// 版本二
//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; 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], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

123.买卖股票的最佳时机III-最多买卖2次

至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
1）dp数组的含义
一天一共就有五个状态
0.没有操作 （其实我们也可以不设置这个状态）

  1. 第一次持有股票
  2. 第一次不持有股票
  3. 第二次持有股票
  4. 第二次不持有股票

dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
需要注意：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。
例如 dp[i][1] ，并不是说 第i天一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。
2）递推公式
达到dp[i][1]状态，有2个具体操作
一：第i天买入股票了，dp[i][1]=dp[i-1][0]-prices[i]
二：第i天没有操作，沿用前一天的状态，dp[i][1]=dp[i-1][1]
选最大的dp[i][1]=max(dp[i-1][0]-prices[i],dp[i-1][1])

达到dp[i][2]状态，有2个具体操作
一：第i天卖出股票了，dp[i][2]=dp[i-1][1]+prices[i]
二：第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]状态，有2个具体操作
一：第i天第二次买入股票了，dp[i][3]=dp[i-1][2]-prices[i]
二：第i天没有操作，沿用前一天卖出股票的状态，dp[i][3]=dp[i-1][3]
选最大的dp[i][3]=max(dp[i-1][2]-prices[i],dp[i-1][3])

达到dp[i][4]状态，有2个具体操作
一：第i天第二次卖出股票了，dp[i][4]=dp[i-1][3]+prices[i]
二：第i天没有操作，沿用前一天卖出股票的状态，dp[i][4]=dp[i-1][4]
选最大的dp[i][4]=max(dp[i-1][3]+prices[i],dp[i-1][4])

3.dp数组如何初始化
dp[0][0] = 0;
dp[0][1] = -prices[0];
dp[0][2] = 0;dp[0][3] = -prices[0];
dp[0][4] = 0;

4.确定遍历顺序
一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5.举例推导dp数组
image.png

整体代码

// 版本一
//时间复杂度：O(n)
//空间复杂度：O(n × 5)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); 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[prices.size() - 1][4];
    }
};

空间优化

// 版本二
//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<int> dp(5, 0);
        dp[1] = -prices[0];
        dp[3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[1] = max(dp[1], dp[0] - prices[i]);
            dp[2] = max(dp[2], dp[1] + prices[i]);
            dp[3] = max(dp[3], dp[2] - prices[i]);
            dp[4] = max(dp[4], dp[3] + prices[i]);
        }
        return dp[4];
    }
};

扩展

可以不设置“0. 没有操作” 这个状态，因为没有操作，手上的现金自然就是0

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

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

1）dp数组的含义
一天一共就有2k+1个状态
0.没有操作 （其实我们也可以不设置这个状态）

  1. 第一次持有股票
  2. 第一次不持有股票
  3. 第二次持有股票
  4. 第二次不持有股票
  5. 第三次持有股票
  6. 第三次不持有股票

…
dp[i][j]中 i表示第i天，j为 [0-2k] 2k+1个状态，dp[i][j]表示第i天状态j所剩最大现金。
2）递推公式:发现规律，奇数买，偶数卖

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

3.dp数组如何初始化

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

4.确定遍历顺序
一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值
5.举例推导dp数组
image.png

整体代码

//时间复杂度: O(n * k)，其中 n 为 prices 的长度
//空间复杂度: O(n * k)
class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {

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

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

1）dp数组的含义
image.png
一天一共有4个状态
状态1：持有股票:今天买入股票，或者之昨天就有了保持
不持有股票：
状态2：保持卖出股票的状态:两天前就卖出了股票，度过一天冷冻期，或者昨天卖出保持
状态3：今天卖出股票
状态4：今天是冷冻期，只有一天
j的状态为：

  • 0：状态一
  • 1：状态二
  • 2：状态三
  • 3：状态四

dp[i][j]中 i表示第i天，j为 0-3个状态，dp[i][j]表示第i天状态j所剩最大现金
2）递推公式
**状态1：dp[i][0]**持有股票
操作一：昨天持有股票保持dp[i][0]=dp[i-1][0]
操作二：今天买入了
1.昨天是冷冻期，今天买入dp[i][0]=dp[i-1][3]-prices[i]
2.昨天保持不持有股票的状态，今天买入dp[i-1][1]-prices[i]
dp[i][0]=max{dp[i-1][0],dp[i-1][3]-prices[i],dp[i-1][1]-prices[i]}
**状态2：dp[i][1]**不持有股票
**操作一：**两天前就卖出了股票，度过一天冷冻期dp[i][1]=dp[i-1][3]
**操作二：**昨天卖出然后保持,dp[i][1]=dp[i-1][1]
dp[i][1]=max(dp[i-1][3],dp[i-1][1])
**状态3：dp[i][2]**不持有股票
昨天持有，今天卖出
dp[i][2]=dp[i-1][0]+prices[i]
状态4：今天是冷冻期
昨天卖出了股票，今天才冷冻
dp[i][3]=dp[i-1][2]
3.dp数组如何初始化
dp[0][0]=-prices[0];
dp[0][1]=0
dp[0][2]=0
dp[0][3]=0
4.方向
从前到后
5.举例
image.png

整体代码

//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0) return 0;
        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][3] - prices[i], 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];
        }
        return max(dp[n - 1][3], max(dp[n - 1][1], dp[n - 1][2]));
    }
};

714.买卖股票的最佳时机含手续费：买卖多次
1）dp[i][j]表示第i天状态j所剩最大现金
状态0持有，状态1不持有
2）递推公式
dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[0])
dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[0]-fee)
3)初始化
dp[0][0]=-prices[0]
4)方向
从前到后

整体代码

//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            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);//注意手续费
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};

贪心：麻烦一点

//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int result = 0;
        int minPrice = prices[0]; // 记录最低价格
        for (int i = 1; i < prices.size(); i++) {
            // 情况二：相当于买入
            if (prices[i] < minPrice) minPrice = prices[i];

            // 情况三：保持原有状态（因为此时买则不便宜，卖则亏本）
            if (prices[i] >= minPrice && prices[i] <= minPrice + fee) {
                continue;
            }

            // 计算利润，可能有多次计算利润，最后一次计算利润才是真正意义的卖出
            if (prices[i] > minPrice + fee) {
                result += prices[i] - minPrice - fee;
                minPrice = prices[i] - fee; // 情况一，这一步很关键，避免重复扣手续费
            }
        }
        return result;
    }
};
Wind哥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 472
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
贪心算法-代码随想录-刷题笔记
Coderwind的博客
05-24 438
贪心算法-代码随想录-刷题笔记
代码随想录刷题笔记
Twoton的博客
07-12 582
代码随想录对应题目链接 数组是有序数组，是使用二分查找的基础条件。 以后大家只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。或者说可以转换在一个有序数组中找一个数的题目。 同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。代码随想录对应题目链接 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 对于使用双指针的题目，需要明确双指针的含义，针对其含义去思考题解方式。 双指针法（快慢指针法）在数组和链
代码随想录刷题｜一刷总结
东东唯一指定铲屎官
04-21 1182
成果汇报经验总结为什么要刷题未来计划以及附件资源，里面有所有pdf，需要自取。我会在末尾放上pdf，点击思维导图的右上角的【箭头】可以直接跳转到leetcode，提供一键跳转方便复习。
代码随想录刷题笔记（个人记录使用，不作参考）
清风的博客
01-11 517
1.10从二叉树开始。
代码随想录——刷题笔记
qq_63782783的博客
01-18 450
统计两个数组找出两个数组中均存在的元素。快乐数（LeetCode202）按照逻辑写循环代码，终止条件为得到结果为1或出现重复项。
代码随想录刷题笔记9——贪心算法
xhj12138的博客
09-25 135
代码随想录的刷题笔记，这一篇是贪心法的相关内容
Leetcode刷题笔记（代码随想录）
KingGue的博客
03-18 1338
刷《代码随想录》做的笔记，感谢代码随想录给予我的刷题路线。
代码随想录刷题笔记-Day32
qq_53711959的博客
03-08 725
53. 最大子数组和给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组：是数组中的一个连续部分。
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文-面试
04-25
代码随想录的大厂八股文面试相关知识点非常广泛，包括了编程基础、算法设计、代码组织、问题解决等多方面的知识点。为了通过面试，考察者需要具备扎实的编程基础和实践经验，能够熟练掌握多种编程语言和技术，能够写...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
deepseek-vl 论文阅读笔记
最新发布
samoyan的博客,记录技术成长~
07-22 665
我们的语言模型基于DeepSeek LLM（DeepSeek-AI，2024），其微设计大体遵循LLaMA（Touvron等，2023a,b）的设计，采用带有RMSNorm（Zhang和Sennrich，2019）函数的Pre-Norm结构，并使用SwiGLU（Shazeer，2020）作为前馈网络（FFN）的激活函数，中间层维度为8/3模型维度。此外，我们引入了一种新的“模态预热”策略。为了促进创新并支持广泛的应用需求，我们公开了两个版本的模型，分别为1.3B和7B，以满足不同计算能力的需求。
OpenGL笔记十四之GLM数学库的配置与使用
小勇博客
07-20 344
— 2024-07-20 中午。
【Blockly图形化积木编程二次开发学习笔记】5.自动保存与恢复
乙酸氧铍的博客
07-21 150
/ 用户离开页面时自动将块备份到本地存储中。关闭后再次打开，工作区仍存在。// 从本地存储中恢复块。
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 842
Shell脚本的使用
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值