【剑指offer】面试题63 六种买卖股票问题

最新推荐文章于 2024-05-12 13:48:18 发布
最新推荐文章于 2024-05-12 13:48:18 发布
阅读量862 收藏 5
点赞数 1
分类专栏： 剑指offer学习 文章标签： 买卖股票问题 动态规划 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzt629/article/details/98874193
版权

本文结合剑指offer的63题与leecode上的六种买卖股票问题进行了总结，综合来说，就是需要不断地考虑在不同的条件下，dp[i][k][j]的产生条件，往往为前一位与前一位买卖的相关操作的最大值。

1.第一种股票问题（单次买卖）

  • 动态规划实现第一类股票问题，单次买入卖出如果将最低收益设为0，那么初始值为0；如果考虑负收益 ，则初始值为INT_MIN

  • 思路1：动态规划，计算每个位置的卖出价最大值（如果将0作为最小值而不考虑负值时）

  • dp[i][0]代表第i + 1天没有持股票，dp[i][1]代表第i + 1天持有股票
  • 初始化：
    dp[0][0] = 0;       第一天没有持股，这时候相当于没有买入，故为0
    dp[0][1] = -prices[0];  第一天持股，相当于买入，这时候为 - pricrs[0]
  • 状态转移方程：
    未持股 = max(昨天没有持股今天维持现状, （昨天持股，今天卖出））
    dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
    持股 = max(昨天持股今天维持现状，（之前没有交易，今天买入)）【因为只能完成一笔交易，故今天买入，则前面就相当于一直没有进行利润为0】
    dp[i][1] = max(dp[i - 1][1], -1 * prices[i])（也相当于一直保持所有的dp[i][1]为买入价的最小值）
int MaxDiff1_1(const int* numbers, unsigned length)
{
	if (numbers == nullptr && length < 2)
		return 0;

	vector<vector<int>> dp(length, vector<int>(2));
	dp[0][0] = INT_MIN;
	dp[0][1] = -1 * numbers[0];
	for (int i = 1; i < length; i++)
	{
		dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + numbers[i]);
		dp[i][1] = max(dp[i - 1][1], 0 - numbers[i]);
	}

	return dp[length - 1][0];
}
  • 思路2：记录前面的最小值，不断地计算最大效益（注意不要只考虑正收益的最大值，还要包括负收益的）
int MaxDiff1_2(const int* numbers, unsigned length)
{
	if (numbers == nullptr && length < 2)
		return 0;

	int minValue = INT_MAX;
	int maxDiff = INT_MIN;

	for (int i = 0; i < length; i++)
	{
		if (numbers[i] < minValue)
		{
			maxDiff = max(maxDiff, numbers[i] - minValue);
			minValue = numbers[i];
		}
		else
			maxDiff = max(maxDiff, numbers[i] - minValue);
	}
	
	return maxDiff;
}

2.第二种股票问题（多次买卖）

  • dp[i][0]代表第i+1天没有持股票，dp[i][1]代表第i+1天持有股票
  • 初始化：
    dp[0][0] = 0;        第一天没有持股，这时候相当于没有买入，故为0
    dp[0][1] = -prices[0];   第一天持股，相当于买入，这时候为-prices[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])
int MaxDiff2_1(const int* numbers, unsigned length)
{
	if (numbers == nullptr && length < 2)
		return 0;

	vector<vector<int>> dp(length, vector<int>(2));
	dp[0][0] = INT_MIN;
	dp[0][1] = -1 * numbers[0];
	for (int i = 1; i < length; i++)
	{
		dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + numbers[i]);
		dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - numbers[i]);
	}

	return dp[length - 1][0];
}

3.第三种股票问题（多次买卖，含冷冻期）

  • dp[i][0]代表第i+1天没有持股票，dp[i][1]代表第i+1天持有股票
  • 初始化：（由于有了买入冷却期，所以在冷却期k前的所有时间dp[i][1]都应该为-price[i]，下面以k=1为例子）
    dp[0][0] = 0;                     //第1天没有持股，这时候相当于没有买入，故为0
    dp[1][0] = max(0,prices[1]-prices[0]); //第2天没有持股，这时候max(第一天没持股，第一天持股第二天卖出)
    dp[0][1] = -prices[0];               //第1天持股维持，相当于买入，这时候为-prices[0]
    dp[1][1] = max(-prices[0],-prices[1]); //第2天持股，这时候max(第一天持股维持，第一天没持股第二天买入)
  • 状态转移方程：
    没有持股 =max(昨天没有持股今天维持现状 , (昨天持股，今天卖出))
    dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i]);
    持股 = max(昨天持股今天维持现状，（前天没有持股，今天买入))即：第i天要买的时候，要从前天的状态进行判断
    dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i]);
class Solution 
{
public:
	int maxProfit3_1(vector<int>& prices) 
	{
		//1. k充当冷却期间
		int k = 1;
		if (prices.size() < 2)
			return 0;
		vector<vector<int>> dp(prices.size(), vector<int>(2));
		//2. 0位置的初始化
		dp[0][0] = 0;
		dp[0][1] = 0 - prices[0];
		//3. 状态转移方程，注意对初始k冷冻期间的日期特殊处理
		for (int i = 1; i < prices.size(); i++)
		{
			dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
			if (i <= k)
				dp[i][1] = max(dp[i - 1][1], 0 - prices[i]);
			else
				dp[i][1] = max(dp[i - 1][1], dp[i - k - 1][0] - prices[i]);
		}
		return dp[prices.size() - 1][0];
	}
};

4.第四类股票问题（多次买卖，含手续费）

  • dp[i][0]代表第i+1天没有持股票，dp[i][1]代表第i+1天持有股票（思想为在买入时扣除手续费，当然在卖出时计算也是可行的）
  • 初始化：
    dp[0][0] = 0;         第一天没有持股，这时候相当于没有买入，故为0
    dp[0][1] = 0 - prices[0] - fee;   第一天持股，相当于买入，这时候为 - prices[0] - fee ,本次以买入作为交易的开始，每次买入就扣除手续费，卖出的时候就不扣除手续费了。
  • 状态转移方程：
    没有持股 = 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] - fee);
class Solution
{
public:
	int maxProfit4_1(vector<int>& prices, int fee)
	{
		if (prices.size() < 2)
			return 0;
		vector<vector<int>> dp(prices.size(), vector<int>(2));
		//2. 0位置的初始化（思想为在买入时扣除手续费）
		dp[0][0] = 0;
		dp[0][1] = 0 - prices[0] - fee;
		//3. 状态转移方程，基本思路与第二种问题类似，多了手续费
		for (int i = 1; i < prices.size(); 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 dp[prices.size() - 1][0];
	}

	int maxProfit4_2(vector<int>& prices, int fee)
	{
		if (prices.size() < 2)
			return 0;
		vector<vector<int>> dp(prices.size(), vector<int>(2));
		//2. 0位置的初始化（思想为在卖出时扣除手续费）
		dp[0][0] = 0;
		dp[0][1] = 0 - prices[0];
		//3. 状态转移方程，基本思路与第二种问题类似，多了手续费
		for (int i = 1; i < prices.size(); i++)
		{
			dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);
			dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
		}
		return dp[prices.size() - 1][0];
	}
};

5.第五种股票问题（两次买卖）

  • （这里的交易k次注意，是指已经进行了交易的次数，本题中将买入的时候当做进行了一次交易）
    dp[i][k][0]代表第i+1天交易k次并且没有持股票，dp[i][k][1]代表第i+1天交易k次并且持有股票
    dp[i][k][0]代表第i+1天交易k次并且没有持股票，dp[i][k][1]代表第i+1天交易k次并且持有股票
  • 初始化：（在买入的时候算进行一次交易）
    dp[0][0][0] = 0 //第一天， 交易次数为0，没持股，相当于啥都没干，没有存在意义
    dp[0][1][0] = 0;       //第一天，交易次数为1，没持股，相当于买入再卖出
    dp[0][1][1] = - prices[0]; //第一天，交易次数为1，持股，相当于买入股票未卖出
    dp[0][2][0] = 0;      //第一天, 交易次数为2，没持股，相当于买入卖出买入卖出，没有盈利
    dp[0][2][1] = - prices[0]; //第一天，交易次数为2，持股，相当于买入再卖出（交易1次）再买入
  • 状态转移方程：
    第(i+1)天交易数为2，没持股 = max(前一天交易数为2没持股维持，前一天交易数为2持股今天卖出)
    dp[i][2][0] = max(dp[i-1][2][0],dp[i-1][2][1] + prices[i]);
    第(i+1)天交易数为2，持股 = max(前一天交易数为2持股维持，前一天交易数为1没持股今天买入)[买入之前必须卖出，故之前交易数应该为1而不是为2]
    dp[i][2][1] = max(dp[i-1][2][1],dp[i-1][1][0] - prices[i]);
    第(i+1)天交易数为1，没持股 = max(前一天交易数为1没持股维持，前一天交易数为1持股今天卖出)[卖出之前必须买入，故交易数为1而不是0]
    dp[i][1][0] = max(dp[i-1][1][0],dp[i-1][1][1] + prices[i]);
    第(i+1)天交易数为1，持股 = max(前一天交易数为1持股维持，(没交易，今天买入))
    dp[i][1][1] = max(dp[i-1][1][1],0 - prices[i]);
class Solution
{
public:
	int maxProfit5_1(vector<int>& prices)
	{
		//1. 边界条件
		if (prices.size() < 2)
			return 0;
		vector < vector<vector<int>>> dp(prices.size(), vector<vector<int>>(3, vector<int>(2)));
		//2. 0位置的初始化（针对第一天有无持股，交易次数进行的初始化操作）
		dp[0][0][0] = 0;
		dp[0][1][0] = 0;
		dp[0][1][1] = 0 - prices[0];
		dp[0][2][0] = 0;
		dp[0][2][1] = 0 - prices[0];
		//3. 状态转移方程，穷举了k为1和2时的情况
		for (int i = 1; i < prices.size(); i++)
		{
			//通过下面可见，可以通过循环将k穷举，这里只是单纯的全部写出来了
			dp[i][1][0] = max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i]);
			dp[i][1][1] = max(dp[i - 1][1][1], 0 - prices[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][1][0] - prices[i]);
		}
		return dp[prices.size() - 1][2][0];
	}
};

6.第六章股票问题（k次买卖）

  • （这里的交易k次注意，是指已经进行了交易的次数，本题中将买入的时候当做进行了一次交易）
    dp[i][k][0]代表第i+1天已经交易了k次并且没有持股票，dp[i][k][1]代表第i+1天已经交易了k次并且持有股票
  • 初始化：
    dp[0][k][0] = 0; 【k为交易成交的笔数】即第一天,持续的买入卖出买入卖出最后没有留股票，没收益
    dp[0][k][1] = 0 - prices[0]; 【k为交易成交的笔数】即第一天,持续的买入卖出买入最后留了股票，收益为买入的 -prices[0]
  • 状态转移方程：
    第(i+1)天交易数为j，没持股 = max(前一天交易数为j没持股维持，前一天交易数为j持股今天卖出)
    dp[i][j][0] = Math.max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
    第(i+1)天交易数为j，持股 = max(前一天交易数为j持股维持，前一天交易数为j-1没持股今天买入)
    dp[i][j][1] = Math.max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
  • 关于第六题有个核心问题，在于当k大于了prices大小的一半之后，就没有存在的意义了，所以要处理否则会超时
class Solution
{
public:
	int maxProfit6_1(int k, vector<int>& prices)
	{
		//1. 边界条件
		if (prices.size() < 2 || k <= 0)
			return 0;
		//由于k大小对于数据的影响，这里将根据k的大小进行第二种股票问题加第六种股票问题的实现

		//1.1第六种股票问题实现
		if (k < prices.size() >> 1)
		{
			vector < vector<vector<int>>> dp(prices.size(), vector<vector<int>>(k + 1, vector<int>(2)));
			//2. 0位置的初始化（针对第一天有无持股，交易次数进行的初始化操作）
			for (int i = 0; i <= k; i++)
			{
				dp[0][i][0] = 0;
				dp[0][i][1] = 0 - prices[0];
			}
			//3. 状态转移方程，具体为循环穷举不同k时的情况
			for (int i = 1; i < prices.size(); i++)
			{
				for (int j = 1; j <= k; j++)
				{
					dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);
					dp[i][j][1] = max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);
				}
			}
			return dp[prices.size() - 1][k][0];
		}
		//1.2 当k足够大时，第二种股票问题实现
		else
		{
			vector<vector<int>> dp(prices.size(), vector<int>(2));
			dp[0][0] = 0;
			dp[0][1] = 0 - prices[0];
			for (int i = 1; i < prices.size(); 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]);
			}
			return dp[prices.size() - 1][0];
		}
	}
};

参考文献：
[1] https://blog.csdn.net/qq_17556191/article/details/95209833
[2] https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/solution/yi-ge-fang-fa-tuan-mie-6-dao-gu-piao-wen-ti-by-l-3/
[3] 《剑指offer（第二版）》

方寸间沧海桑田
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
笔试算法题--股票买卖问题（两次买卖）
Ask马小向的专栏
09-23 6579
题目：一个人一天只能进行最多两次买和两次卖，并且只有卖了才能继续买。问一天可以获得的最大收益，要采用时间复杂度低的实现。 股票价格为：10，22,5,75,65,80.答案：87（10买，22卖，5买，80卖） 动态规划解决方法：设置数组dp[i][j]表示：prices[i]买入到prices[j]卖出的收益。则得出dp[i][j]为 0 12 -5 65 55 70   0 0 -
剑指 Offer 63. 股票的最大利润
Justdoforever的博客
02-09 350
剑指 Offer 63. 股票的最大利润 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例 2: 输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 限
剑指 offer第63题-股票的最大利润
ritagreen123的博客
07-27 360
可以有一次买入和一次卖出，买入必须在前。求最大收益。 使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。 Input: [7,1,5,3,6,4] Output: 5 Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. Not 7-1 = ...
面试必刷算法TOP101之买卖股票问题 TOP16
qq_50408340的博客
04-24 1064
一个思路解决下边买卖股票的问题 首先先分析下边的问题 121. 买卖股票的最佳时机 I 限定交易次数 k=1 122. 买卖股票的最佳时机 II 交易次数无限制 k = N 123. 买卖股票的最佳时机 III 限定交易次数 k=2 124. 买卖股票的最佳时机 IV 限定交易次数 最多次数为 k k还是有限制的 这些问题都是买卖股票的最佳时机，都是在通过买卖股票的来获取最大差值大，但是最大区别就是买卖股票的次数都是不一样的，所以将这些问题看作是一个问题，只不过是对于不同问题交易次数是不同的，因为是动态
动态规划----股票买卖问题（详解）
最新发布
2302_79862386的博客
05-12 2647
动态规划买卖股票的最佳时机是一个经典的算法问题。该问题的目标是在给定的股票价格数组中，找到最大的利润，即最佳的买入和卖出时间，使得买入时间早于卖出时间。
剑指offer | 面试题63：股票的最大利润
程序员大航子
03-14 392
转载本文章请标明作者和出处 本文出自《Darwin的程序空间》 本文题目和部分解题思路来源自《剑指offer》第二版 开始行动，你已经成功一半了，献给正在奋斗的我们 题目 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例一 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股...
【算法面试通关40讲】48 - 面试题：股票买卖系列
Melo
10-24 866
121（只能买卖一次），122（可以买卖无数次），123（只能买卖两次），309（加入了cool down），188（可以买卖k次），714（交易含有手续费怎么办） Leetcode-121. 买卖股票的最佳时机 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖...
剑指Offer-63：股票的最大利润
大树先生的博客
03-28 7323
股票的最大利润（一次卖出） 股票的最大利润（多次卖出） 股票的最大利润（至多两次交易）
面试题目总结——股票问题
weixin_45927758的博客
12-14 339
买卖股票的最佳时机系列问题 1.总共只买卖一次股票 var maxProfit = function(prices) { let ans=0,minNum=prices[0]; for(let i=1;i<prices.length;i++){ ans=Math.max(ans,prices[i]-minNum); minNum=Math.min(minNum,prices[i]); } return ans; }; 2.不限制股
[各种面试题] 买卖股票最多K次
a83610312的专栏
10-07 3866
题目描述： 给定一个大小为n的数组，数组的元素a[i]代表第i天的股票价格。 设计一个算法，计算在最多允许买卖k次（一买一卖记为一次）的条件下的最大收益。 需要注意的是，你不能同时拥有两份股票。也就是说在下次买入前，你必须把手头上原有的股票先卖掉。 输入： 输入可能包含多个测试案例。 对于每个测试案例，输入的第一行为两个整数n和k(1 输入的第二行包括n个整数
股票买卖问题总结
tc950318的博客
10-17 224
赶了一周的项目，有点动摇了，放假想了很多自己有点抑郁了好像，学会放过自己？承认自己是个菜逼吧，但是多学点总没错。 上题：一个数组表示股票当天价格都是非负数。问题分别是只允许买卖一次，可以无限次，只允许两次，可以允许k次。两次的在贝壳面试时候手撕过，当时还不会，哭泣。以下代码都是在leetcode上通过的，庆幸的是会写了以后现在已经可以一遍过了，感觉这是很重要的因为手撕代码没有机会让你改，越改分数...
leetcode关于股票买卖最大利润问题
weixin_40198941的博客
02-04 1231
leetcode中关于股票买卖最大利润问题题目详述解法详述穷举算法状态转移框架题目求解：第一题 题目详述 leetcode中总过有六道关于股票买卖获得最大利润的题，基本上要求如下： 给出一个数组，其数组中的值相应于某天的股票价格，如何买卖获得最大利润，其他变化无非限制交易次数，限制有无等待期。 解法详述 穷举算法 这些题目乍一看，一时难以解决， 其实该类题只需要一种所谓的状态转移解法就可以解全部的...
【剑指 Offer】63. 股票的最大利润
qq_44653420的博客
07-05 100
【剑指 Offer】63. 股票的最大利润
java实现股票的最大利润(一次卖出，多次卖出）--中金所笔试题
qiannuo_的博客
11-14 6103
一、股票的最大利润（一次卖出） 一个数组代表股票每天的价格，可以选择从某一天买入，然后之后的一天卖出，求能够获得的最大收益。 例如，一只股票在某些时间节点的价格为{9,11,8,5,7,12,16,14}。在价格为5的时候买入并在价格为16时卖出，则能获得最大的利润为11. 思路：记录当前最小值和最大差值           1.最大利润就是计算后面的数字减去前面的数字得到的一个最大的差值...
动态规划（股票交易）---只能进行两次的股票交易
weixin_30675247的博客
07-02 516
只能进行两次的股票交易 123. Best Time to Buy and Sell Stock III (Hard) 题目描述：   一共只能进行两次股票交易，求能够取得的最大利润。 思路分析：   这道题是Best Time to Buy and Sell Stock的扩展，现在我们最多可以进行两次交易。我们仍然使用动态规划来完成，事实上可以解决非常通用的情况，也就是最多进行k次交易的情况。 ...
Java详解剑指offer面试题63--股票的最大利润
快乐李同学的博客
09-26 498
Java详解剑指offer面试题63–股票的最大利润 假设某股票的价格按照时间先后顺序存储在数组中，问买卖该股票一次可能获得的最大利润是多少？ 如一支股票在某段时间内的价格为{9, 11, 8, 5, 7, 12, 16, 14}那么能在价格为5的时候购入并在价格为16时卖出，能获得最大利润11 咋一看好像只要求出数组中的最大/最小值就完事了，但是数组中的值是按照时间顺序排列的，这就是说假如数组中最小值在最大值之后，它们的差值不会是股票的最大利润。因此我们要求的是数组中排在后面的数（售出价格）与排在前面
《剑指offer》第六十三题（股票的最大利润）
weixin_30820151的博客
03-17 119
// 面试题63：股票的最大利润 // 题目：假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖交易该股 // 票可能获得的利润是多少？例如一只股票在某些时间节点的价格为{9, 11, 8, 5, // 7, 12, 16, 14}。如果我们能在价格为5的时候买入并在价格为16时卖出，则能 // 收获最大的利润11。 #include <iostream> /...
美团点评2016研发题目-[编程题-美团] 股票交易日(两次买卖)
mine_song的博客
07-25 2091
美团点评2016研发题目-[编程题-美团] 股票交易日(两次买卖)
Java版《剑指offer》面试题：单例模式与二维数组查找
"剑指offer（java版）.pdf，涵盖了Java编程语言中的面试题，包括设计模式和数组操作等主题。" 在Java编程中，单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。该模式在很多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

方寸间沧海桑田

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

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

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

打赏作者

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

抵扣说明：

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

余额充值