LeetCode刷题day58

最新推荐文章于 2023-08-26 22:32:07 发布
最新推荐文章于 2023-08-26 22:32:07 发布
阅读量2.2k 收藏 6
点赞数 5
分类专栏： LeetCode刷题 文章标签： java 设计模式 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LXYDSF/article/details/123810943
版权

🍏121. 买卖股票的最佳时机

🍊题目描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
🍇思路分析

动规五部曲

  1. 确认dp数组以及下标的含义

dp[i] [0]表示第i天持有股票所得最多现金.

dp[i] [1]表示第i天不持有股票所得最多现金.

注意: 这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态

  1. 确认题解公式

如果第i天持有股票即dp[i][0] :,那么可以由两个状态推出来

  • 第i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i-1] [0]
  • 第i-1天(包括i-1)未持有股票,第i天买入股票.所得现金就是买入今天的股票后所得现金即: -prices[i]

dp[i] [0]应该选择所得现金最大的,所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有骨片即dp[i] [1],也可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1] [1]
  • 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1] [0]

同样dp[i] [1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

  1. dp数组如何初始化

由以上两个递推公式可有看出,其基础都是要从dp[0] [0]和dp[0] [1]推导出的。

  • dp[0] [0]表示第0天持有股票,此时的持有股票一定是买入股票了,因为不可能由前一天推出来,所以 dp[0][0] -= prices[0];
  • dp[0] [1]表示第0天不持有股票,那么现金就是0,所以 dp[0] [1] = 0;
  1. 确定遍历顺序

从递推公式可以看出dp[i]都是从dp[i-1]推导出来的,那么一定是从前往后遍历的

  1. 举例推导dp数组

以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：

121.买卖股票的最佳时机

dp[5] [1]就是最终结果。

为什么不是dp[5] [0]呢？

因为本题中不持有股票状态所得金钱一定比持有股票状态得到的多！

🍑参考代码
#include<bits/stdc++.h>
using namespace std;


int maxProfit(vector<int>& prices) {
	vector<vector<int>> dp(prices.size(),vector<int>(2,0)) ;//dp[i][0]:持有股票  dp[i][1]:不持有股票
	//初始化
	dp[0][0] -= prices[0] ;
	dp[0][1] = 0;
	//进行递推
	for(int i = 1;i < prices.size(); 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[prices.size()-1][1];//返回最终获利 
}

🍌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 。

示例 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。
🍉思路分析

本题和上题的唯一区别在于 本题股票可以买卖多次 这就导致了动规的状态转移方程和上题稍有差别.

我们重点分析下递推公式(状态转移方程).

🍭🍭🍭如果第i天持有股票即dp[i][0] :那么可以由两个状态推出来

  • 第i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i-1] [0]
  • 第i天买入股票(第i-1天(包括i-1)未持有股票,).所得现金就是买入今天的股票后所得现金 即: dp[i-1] [1]-prices[i]

dp[i] [0]应该选择所得现金最大的,所以dp[i][0] = max(dp[i - 1][0], dp[i-1] [1]-prices[i]);

注意:

第二种就是 与上题不同第地方,上题股票全程只能买卖一次,所以如果买入股票,那么第i天持有股票dp[i] [0]一定就是-prices[i].

而本题,因为一只股票可以被买卖多次,所以当第i天买入股票的时候,所持有现金可能有之前买卖过的利润.所以所得现金就是昨天不持有股票的所得现金 减去 今天的股票价格 即：dp[i - 1][1] - prices[i]

🍬🍬🍬如果第i天不持有股票即dp[i] [1],也可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1] [1]
  • 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1] [0]

同样dp[i] [1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

🍅参考代码
#include<bits/stdc++.h>
using namespace std;

int maxProfit(vector<int>& prices) {
	vector<vector<int>> dp(prices.size(),vector<int>(2,0));
	dp[0][0] -= prices[0]; //持有 
	dp[0][1] = 0;//不持有
	for(int i = 1;i < prices.size();i++) {
		//dp[i][0] = max()//持有 
		dp[i][0] = max(dp[i-1][0],dp[i-1][1]-prices[i]);//持有时的获利: = max(之前持有的利润 ,之前未持有但是现在买入持有的利润) 
		dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]) ;//不持有时的获利: = max(之前不持有利润,之前持有本次卖出的利润) 
	}
	return dp[prices.size()-1][1] ;
}
  • 时间复杂度： O ( n ) O(n) O(n)
  • 空间复杂度： O ( n ) O(n) O(n)

🍒123. 买卖股票的最佳时机 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
🍎思路分析

这道题相对于 前两道题 难度又提升了不少.

关键在于 至多买卖两次,这就意味着可以买卖一次,买卖两次,也可以不买卖

我们还是按照动规五部曲来分析以下

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

一天股票有五种状态

  • 0 没有操作
  • 1 第一次买入
  • 2 第一次卖出
  • 3 第二次买入
  • 4 第二次卖出

dp[i] [j]中:i表示第i天,j为[0-4]五种状态,dp[i] [j]表示第i天状态j所得最大现金.

  1. 确定递推公式

达到dp[i] [1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i] [1] = dp[i-1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

dp[i] [1]一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

同理dp[i] [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] = 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]);

  1. dp数组如何初始化

  • 第0天没有操作,就是0, 即dp[0] [0] = 0

  • 第0天做第一次买入操作,dp[0] [1] = -prices[0]

  • 第0天做第一次卖出的操作,因为第0天嘛,都没股票(无法卖出),所以就是0了,即dp[0] [2] = 0

  • 第0天第二次买入操作.第二次买入依赖于第一次卖出的状态,就相当于第0天第一次买入了,然后又卖出了(一进一出获利为0).然后开始第二次买入. 即dp[0] [3] = -prices[0]

  • 第0天第二次卖出操作. dp[0] [4] = 0;

4.确定遍历顺序

从递归公式已经可以看出，一定是从前向后遍历，因为dp[i],依靠dp[i - 1]的数值。

  1. 举例推导dp数组

以输入[1,2,3,4,5]为例

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

大家可以看到红色框为最后两次卖出的状态。

现金最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。

所以最终最大利润是dp[4] [4]

🌽参考代码
#include<bits/stdc++.h>
using namespace std;

int maxProfit(vector<int>& prices) {
	vector<vector<int>> dp(prices.size(),vector<int>(5,0));//定义dp 
	//初始化
	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 < prices.size(); i++) {
		dp[i][0] = dp[i-1][0];
		dp[i][1] = max(dp[i-1][1],dp[i][0]-prices[i]);//第一次买入: max(之前第一次买入,之前没买这次第一次买入)
		dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i]);//第一次卖出:max(之前第一次卖出,之前没卖本次进行第一次卖出) 
		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

🍋题目描述

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

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

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
🍑思路分析

这道题算是上个题的进阶版,要求至多k次交易

动规五部曲

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

二维数组dp[i] [j] :第i天的状态为j,所剩下的最大现金是dp[i] [j]

j的状态表示为:

  • 0 表示不操作
  • 1 第一次买入
  • 2 第一次卖出
  • 3 第二次买入
  • 4 第二次卖出
  • …

可以发现规律: 除了0以外,偶数就是卖出,奇数就是买入.

题目要求最多K笔交易,那么j 的范围就是 0 - 2 * k (也就是2*k+1种状态)

  1. 确定递推公式

达到dp[i] [1]状态，有两个具体操作：

  • 操作一：第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]也有两个操作：

  • 操作一：第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])

同理可以类比剩下的状态，代码如下：

for(int j = 1;j <= 2*k; j+=2) {
    dp[i][j] = max(dp[i-1][j],dp[i-1][j-1]-prices[i]);//第j/2次买入的利润 
    dp[i][j+1] = max(dp[i-1][j+1],dp[i-1][j]+prices[i]);//第j/2次卖出的利润 
}
  1. dp数组如何初始化

  • 第0天没有操作,就是0, 即dp[0] [0] = 0

  • 第0天做第一次买入操作,dp[0] [1] = -prices[0]

  • 第0天做第一次卖出的操作,因为第0天嘛,都没股票(无法卖出),所以就是0了,即dp[0] [2] = 0

  • 第0天第二次买入操作.第二次买入依赖于第一次卖出的状态,就相当于第0天第一次买入了,然后又卖出了(一进一出获利为0).然后开始第二次买入. 即dp[0] [3] = -prices[0]

  • 第0天第二次卖出操作. dp[0] [4] = 0;

  • …

可以观察到,对于dp[0] [j],当j为奇数的时候都初始化为-prices[0],为偶数的时候都初始化为0

  1. 确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

  1. 举例推导dp数组

以输入[1,2,3,4,5]，k=2为例。

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

最后一次卖出，一定是利润最大的，**dp[prices.size() - 1] [2 * k]**即红色部分就是最后求解。

🍠参考代码
#include<bits/stdc++.h>
using namespace std;

int maxProfit(int k, vector<int>& prices) {
	if(prices.size()==0 || prices.size()==1) {
		return 0;
	}
	vector<vector<int>> dp(prices.size(),vector<int>(2*k+1,0));//dp定义
	//dp初始化  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 <= 2*k;i+=2){//奇数初始化为 -1*prices[0]
		dp[0][i] = -1*prices[0];
	}
	
	//进行递推 
	for(int i = 1; i < prices.size(); i++) {
		//持有dp[i][0]不用管,永远和上一个dp[i-1][0]相等. 
		for(int j = 1;j <= 2*k; j+=2) {
			dp[i][j] = max(dp[i-1][j],dp[i-1][j-1]-prices[i]);//第j/2次买入的利润 
			dp[i][j+1] = max(dp[i-1][j+1],dp[i-1][j]+prices[i]);//第j/2次卖出的利润 
		}
	}
	
	return dp[prices.size()-1][2*k];
	 
}

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

🍆题目描述

给定一个整数数组 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
🍌思路分析

相对于**[动态规划：122.买卖股票的最佳时机II]**，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。

唯一差别在于递推公式部分，所以接下来分析一下递推公式部分。

这里重申一下dp数组的含义：

dp[i] [0] 表示第i天持有股票所省最多现金。 dp[i] [1] 表示第i天不持有股票所得最多现金

🍍🍍🍍如果第i天持有股票即dp[i] [0]， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1] [0]
  • 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]

所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

🍠🍠🍠如果第i天不持有股票即dp[i] [1]的情况， 依然可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1] [1]
  • 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee

所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);

🍇参考代码
#include<bits/stdc++.h>
using namespace std;

int maxProfit(vector<int>& prices, int fee) {
	vector<vector<int>> dp(prices.size(),vector<int>(2,0));//定义dp
	//初始化
	dp[0][0] -= prices[0];//持有
	dp[0][1] = 0;//不持有

	for(int i = 1; i < prices.size(); i++) {
		dp[i][0] = max(dp[i-1][0],dp[i-1][1] - prices[i]);//持有时的获利: = max(之前持有的利润 ,之前未持有但是现在买入持有的利润)
		dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);//不持有时的获利: = max(之前不持有利润,之前持有本次卖出的利润)
	}
	return dp[prices.size()-1][1];
}

以上相关题解来源于卡尔大佬的代码随想录

如果有收获！！！ 希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客

爱编程的大李子
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
LeetCode 121. 买卖股票的最佳时机
tomjobs的博客
02-02 1013
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 示例 1： 输入：[7,1,5,3,6,4] 输出：5 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1
每日一题121-买卖股票的最佳时机
weixin_46398446的博客
02-14 410
1.题目详情 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 2.解题思路 动态规划（解析来源于力扣） 动态规划一般分为一维、二维、多维（使用状态压缩），对应形式为 dp(i)dp(i)、dp(i)(j)dp(i)(j)、二进制dp(i)(j)二进制dp
【Java - L - 0121】e - √ - 买卖股票的最佳时机
qq_38734403的博客
03-10 288
全局锁和表锁 《Mysql45-06》 按照锁的粒度分数据库锁有哪些？锁机制与InnoDB锁算法 在关系型数据库中，可以按照锁的粒度把数据库锁分为行级锁(INNODB引擎)、表级锁(MYISAM引擎)和页级锁(BDB引擎 )。 MyISAM和InnoDB存储引擎使用的锁： ◆ MyISAM采用表级锁(table-level locking)。 ◆ InnoDB支持行级锁(row-level locking)和表级锁，默认为行级锁 行级锁，表级锁和页级锁对比 1）行级锁 ◆ 行级锁是Mysql中锁定
给定一个数组，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择某一天买入这只股票，并选择在未来的一个不同的日子卖出该股票。【LeetCode Hot 100】
小型骷髅的博客
03-07 2792
力扣热题100之第121题： 先贴代码： class Solution { public int maxProfit(int[] prices) { /** * 遍历数组找到历史价格最低点，再往后遍历，如果出现那一天价格比最低点高，说明有利润（差值） * 记录下这个利润，继续往后遍历，记录下最大利润，如果最低点后面无元素了，说明 * 这笔交易里没有利润可赚。 */ //定义最低价格min，初始值
买卖股票的最佳时机含手续费（给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。）
qq_43109561的博客
05-17 2992
714. 买卖股票的最佳时机含手续费 给定一个整数数组prices，其中第i个元素代表了第i天的股票价格 ；非负整数fee代表了交易股票的手续费用。 你可以无限次地完成交易，但是你每次交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。 返回获得利润的最大值。 示例 1: 输入: prices = [1, 3, 2, 8, 4, 9], f...
leetcode卡-LeetCode-solution:LeetCode刷题打卡
07-06
LeetCode刷题打卡—监督自己！不懂的代码Debug一遍 Day1: 2021年5月31日 Day2: 2021年6月1日 Day3: 2021年6月2日 Day4: 2021年6月3日 Day5: 2021年6月4日 Day6: 2021年6月5日 Day7: 2021年6月6日 Day8: 2021年6月7日...
Leetcode扑克-LeetCodeJava:leetcode刷题java
06-30
Leetcode扑克 LeetCodeJava LeetCode部分习题Java版，包括多种解法，时间复杂度和空间复杂度自行分析。 Day01 逆波兰表达式求值 Day02 合并两个有序链表 Day03 合并K个排序链表 Day04 验证二叉搜索树 Day05 二叉树中...
LeetCode判断字符串是否循环-myLeetCode:leetcode刷题
07-01
leetcode刷题 语言：python 平台：jupyter notebook 字符串 day01 验证回文字符串 思路：先对字符串判断，是否为空，若为空，则为回文串 其次再对非空字符串判断，首先将字符串全部转化为小写字符，然后定义类似指针...
谷歌师兄的leetcode刷题笔记-day_7_Premiers_programmes:day_7_Premiers_programmes
06-30
谷歌师兄的leetcode刷题笔记第七天 列表练习： 多 Caesar 这里有两个版本都可以使用。 每个人都做了自己的。 雷曼兄弟 Google 运行脚本时要小心。 更改或注释要运行的函数。 莎士比亚 运行脚本时要小心。 更改或注释...
【LeetCode-简单】121. 买卖股票的最佳时机（详解）
丨康有为丨的博客
11-08 1168
java：暴力循环 、一次遍历
121. 买卖股票的最佳时机
syh's BF的博客
09-10 271
给定一个数组 prices ，它的第i 个元素prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 来源：力扣（LeetCode） 双指针 int maxProfit(int* prices, int pricesSize) { int maxProfit = 0; ...
力扣---2020.7.10
Carroll的博客
09-23 217
309. 最佳买卖股票时机含冷冻期 class Solution { public int maxProfit(int[] prices) { int m = prices.length; int[][] dp = new int[m+2][2]; int temp = 0; for(int i = m - 1;i >= 0;i--){ // 当手里无股票时：选择1：现在买，那么第i+1天就是有股票的，所以
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法
weixin_51286041的博客
10-20 3393
输入：[7,1,5,3,6,4] 输出：5 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 示例 2： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/pro...
leetcode每日一题·买卖股票问题(Python)
zjlwdqca的博客
05-04 1826
leetcode每日一题·买卖股票问题(Python) 买卖股票的最佳时机(股票最大利润) 题目链接 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 暴力法 直接遍历两次，记录最大利润 class Solution: def maxProfit(s
LeetCode：121.买卖股票的最佳时机——动态规划
Super algorithm 的博客，技术爱好者。
03-29 2510
121. 买卖股票的最佳时机(1、2)——动态规划、贪心策略 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择**某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票**。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 🍎道阻且长，行则将至。🍓！！！
leetcode——第121题——只买一次股票
linping_的博客
05-21 699
题目： 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 class Solution { public: // /***********************方法一：暴力解法***************************************/
【每日一题048】leetcode-121
qq_42799166的博客
12-02 208
目录题目思路相关思考代码（C++/力扣） 题目 题目来源 思路 相关思考 代码（C++/力扣）
LeetCode 每日一题之 股票求最大利润问题
m0_75276704的博客
08-26 328
此时，起点就是整段的局部最低点，起点之后的各点都可以作为卖出点，各求利润然后遇到更大的覆盖就行了；找到下一个起点的方法就是找到下一个比当前起点更低的点。以第一点为第一段的起点，水平画线，再次碰到k线之前为一段。
leetcode刷题手册c++版
最新发布
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱编程的大李子

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值