股票问题总结

最新推荐文章于 2024-10-18 10:39:20 发布
最新推荐文章于 2024-10-18 10:39:20 发布
阅读量188 收藏 1
点赞数 1
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Desperate_gh/article/details/116457243
版权

1. 只能买卖一次
在这里插入图片描述
在这里插入图片描述
贪心：

class Solution {
    public int maxProfit(int[] prices) {
        int minPrice = prices[0], profit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] < minPrice) {
                minPrice = prices[i];
            } else {
                profit = Math.max(profit, prices[i] - minPrice);
            }
        }
        return profit;
    }
}

动态规划：

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int[][] dp = new int[len][2];
        dp[0][1] = -prices[0];
        for (int i = 1; i < len; 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], -prices[i]);
        }
        return dp[len - 1][0];
    }
}

简化空间：

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int profit0 = 0, profit1 = - prices[0];
        for (int i = 1; i < len; i++) {
            profit0 = Math.max(profit0, profit1 + prices[i]);
            profit1 = Math.max(profit1, -prices[i]);
        }
        return profit0;
    }
}

2. 可以多次买卖
在这里插入图片描述
在这里插入图片描述
贪心：

class Solution {
    public int maxProfit(int[] prices) {
        int profit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                profit += prices[i] - prices[i - 1];
            }
        }
        return profit;
    }
}

动态规划：

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

简化空间：

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int profit0 = 0, profit1 =  -prices[0];
        for (int i = 1; i < len; i++) {
            int newProfit0 = Math.max(profit0, profit1 + prices[i]);
            int newProfit1 = Math.max(profit1, profit0 - prices[i]);
            profit0 = newProfit0;
            profit1 = newProfit1;
        }
        return profit0;
    }
}

3. 只能交易 2 次
在这里插入图片描述在这里插入图片描述
动态规划：

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

简化空间：

class Solution {
    public int maxProfit(int[] prices) {
        int buy1 = -prices[0], sell1 = 0;
        int buy2 = -prices[0], sell2 = 0;
        for (int i = 1; i < prices.length; i++) {
            buy1 = Math.max(buy1, -prices[i]);
            sell1 = Math.max(sell1, buy1 + prices[i]);
            buy2 = Math.max(buy2, sell1 - prices[i]);
            sell2 = Math.max(sell2, buy2 + prices[i]);
        }
        return sell2;
    }
}

4. 可以交易 k 次
在这里插入图片描述
在这里插入图片描述

class Solution {
    public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        if (len == 0 || len == 1) {
            return 0;
        }
        if (k >= (len / 2)) { // 退化成 k 无穷大的情况
            return maxProfit(prices);
        }
        int[][][] dp = new int[len][k + 1][2];
        for (int i = 1; i <= k; i++) {
            dp[0][i][0] = 0;
            dp[0][i][1] = -prices[0];
        }
        for (int i = 1; i < len; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);
                dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);
            }
        }
        return dp[len - 1][k][0];
    }

    public int maxProfit(int[] prices) {
        int len = prices.length;
        int[][] dp = new int[len][2];
        dp[0][1] = -prices[0];
        for (int i = 1; i < len; 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][0] - prices[i]);
        }
        return dp[len - 1][0];
    }
}

简化空间：

class Solution {
    public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        if (len == 0 || len == 1) {
            return 0;
        }
        if (k >= (len / 2)) { // 退化成 k 无穷大的情况
            return maxProfit(prices);
        }
        int[][] dp = new int[k + 1][2];
        for (int i = 1; i <= k; i++) {
            dp[i][0] = 0;
            dp[i][1] = -prices[0];
        }
        for (int i = 1; i < len; i++) {
            for (int j = 1; j <= k; j++) {
                dp[j][0] = Math.max(dp[j][0], dp[j][1] + prices[i]);
                dp[j][1] = Math.max(dp[j][1], dp[j - 1][0] - prices[i]);
            }
        }
        return dp[k][0];
    }

    public int maxProfit(int[] prices) {
        int len = prices.length;
        int profit0 = 0, profit1 = -prices[0];
        for (int i = 1; i < len; i++) {
            profit0 = Math.max(profit0, profit1 + prices[i]);
            profit1 = Math.max(profit1, profit0 - prices[i]);
        }
        return profit0;
    }
}

5. 买卖含冷冻期
在这里插入图片描述
动态规划：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0 || prices.length == 1) {
            return 0;
        }
        int len = prices.length;
        int[][] dp = new int[len][2];
        dp[0][1] = -prices[0];
        for (int i = 1; i < len; 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], (i > 2 ? dp[i - 2][0] : 0) - prices[i]);
        }
        return dp[len - 1][0];
    }
}

简化空间：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0 || prices.length == 1) {
            return 0;
        }
        int len = prices.length;
        int profit0 = 0, preProfit0 = 0, profit1 = -prices[0];
        for (int i = 1; i < len; i++) {
            int nextProfit0 = Math.max(profit0, profit1 + prices[i]);
            int nextProfit1 = Math.max(profit1, (i > 2 ? preProfit0 : 0) - prices[i]);
            preProfit0 = profit0;
            profit0 = nextProfit0;
            profit1 = nextProfit1;
        }
        return profit0;
    }
}

6. 买卖需要手续费
在这里插入图片描述
在这里插入图片描述
动态规划：

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int len = prices.length;
        if (len == 1) {
            return 0;
        }
        int[][] dp = new int[len][2];
        dp[0][1] = -prices[0] - fee;
        for (int i = 1; i < len; 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][0] - prices[i] - fee);
        }
        return dp[len - 1][0];
    }
}

简化空间：

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

重要参考：
https://leetcode-cn.com/circle/article/qiAgHn/
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/zui-jian-dan-2-ge-bian-liang-jie-jue-suo-71fe/

Desperate_gh
关注
专栏目录
LEETCODE力扣股票问题总结
码农ZZK的博客
05-06 837
在力扣网站中，最常见的动态规划问题就是股票系列的问题 这里我把题号给放上来 121 122 123 188 309 714 股票问题总思路 既然涉及到动态规划，那么我们肯定是需要根据题意来定义状态转移方程的 对于股票的操作，我们一共有3个，分别是买，卖，不交易 我们可以定义一个三维的数组，维度分别代表天数，交易次数，状态（用0，1代表没持有股票还是持有股票） dp[i][k][0] = max(...
股票问题
yleave的博客
01-10 704
文章目录121.买卖股票的最佳时机解法1：122.买卖股票的最佳时机 II解法1：贪心1解法2：贪心2解法3：动态规划空间优化123. 买卖股票的最佳时机 III解法1：动态规划188. 买卖股票的最佳时机 IV解法1：动态规划309. 最佳买卖股票时机含冷冻期解法1：动态规划714. 买卖股票的最佳时机含手续费解法1：贪心解法2：动态规划股票问题小结 总结一下力扣上的股票交易问题。有： 121.买卖股票的最佳时机 122. 买卖股票的最佳时机 II 123. 买卖股票的最佳时机 III 1
股票问题汇总
chuxuezhe8483的博客
04-04 702
股票问题汇总 这篇文章是动态问题股票问题的汇总，希望可以找到一种通用的框架解决股票问题，其中还有一些别的算法可以解决，暂时就不放代码了 121. 买卖股票的最佳时机 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 思路：动态规划 class Solutio
Leetcode——买卖股票问题汇总
Michael_Jay的博客
12-14 1554
本篇文章汇总了股票买卖的五种问题，采取动态规划算法循序渐进解题。
LeetCode股票问题总结java
热门推荐
Hello World程序员的博客
07-10 1万+
股票问题总结java 个人博客 https://www.b2bchain.cn/6492.html 309. 最佳买卖股票时机含冷冻期 //给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。 // // 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: // // // 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 // 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 // // /.
股票问题汇总（待总结）
无问西东的博客
12-08 160
LeetCode股票问题汇总
StephenYou的自习室
08-26 644
目录 LeetCode股票问题汇总 问题描述 思路分析 穷举框架 状态转移框架 股票问题秒杀 Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 LeetCode股票问题汇总 在刷LeetCode时碰到了股票买卖的系列问题，本质上他们的解法都可以用状态机动态规划的解法进行求解，在这里总结一下。 本篇文章借鉴了一个方法...
Leetcode股票问题总结篇!
gyjllll的博客
02-01 982
那么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][0] + prices[i] - fee);所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
股票问题总结篇
weixin_46367158的博客
12-14 919
动态规划五步曲：动态规划五步曲：动态规划五步曲：动态规划五步曲：
【Leetcode刷题篇/面试篇】经典动态规划-买卖股票问题总结汇总
Mind_programmonkey的博客
12-17 769
经典动态规划-买卖股票问题 一、一次买卖股票-121. 买卖股票的最佳时机 Leetcode121 剑指offer63 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
股票开户常见问题总结.docx
01-23
股票开户常见问题总结.docx
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 545
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
Leetcode 1168. 水资源分配优化
m0_51437455的博客
10-14 492
对于每个房子 i，我们有两种可选的供水方案：一种是直接在房子内建造水井，成本为 wells[i – 1] （注意 -1 ，因为 索引从0开始 ）；另一种是从另一口井铺设管道引水，数组 pipes 给出了在房子间铺设管道的成本，其中每个 pipes[j] = [house1_j, house2_j, cost_j] 代表用管道将 house1_j 和 house2_j连接在一起的成本。第二步，使用Prim算法模板或者Kruskal算法模板解除最小生成树的权值和（详情可以看下代码的注释）
【力扣 | SQL题 | 每日4题】力扣1164，3293，1308，1270
2301_80912559的博客
10-17 873
4 mid，四题都比较简单，没什么难度。
LeetCode：1884. 鸡蛋掉落-两枚鸡蛋（dp Java）
Cosmoshhhyyy的博客
10-14 533
f[i]为i层需要的最小次数。 第一次如果第 i 层碎了，那么说明f位于1- i之间，最后一次尝试i - 0次。 第一次如果没碎，那么说明位于i~n之间，那么就转换为n - j层的子问题。
力扣10.13
qq_40052678的博客
10-13 476
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 343
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
Leetcode 721. 账户合并
最新发布
m0_51437455的博客
10-18 855
请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是 按字符 ASCII 顺序排列 的邮箱地址。第一步，构建email->username的映射，同时构建邮箱之间的并查集（同一个账户的邮箱属于一个集合）
力扣股票问题动态规划解法总结
"本文主要探讨了LEETCODE力扣网站上的股票问题，涉及动态规划的解题策略，并给出了典型的状态转移方程。" 在LEETCODE力扣网站上，股票问题是一个常见的动态规划主题，这类问题通常围绕着如何在给定的股票价格序列中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值