代码随想录——动态规划（三）：子序列系列

最新推荐文章于 2023-07-06 22:49:59 发布
最新推荐文章于 2023-07-06 22:49:59 发布
阅读量358 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/124079704
版权

题目来自《代码随想录》

文章目录

300. 最长递增子序列

https://leetcode-cn.com/problems/longest-increasing-subsequence/
注意，本题未要求连续

	/*
	 * 定义 dp[i] 为考虑前 i个元素，以第 i个数字结尾的最长上升子序列的长度，
	 * 注意 nums[i] 必须被选取。
	 */
	public int lengthOfLIS(int[] nums) {
		int len = nums.length;
		if(len <= 1) return len;
		
		int[] dp = new int[len];
		for(int i=0; i<len; i++) dp[i] = 1;//初始化
		
		int maxans = 1;

		for(int i=1; i<len; i++){
			for(int j=0; j<i; j++){
				if(nums[i] > nums[j]) {
					dp[i] = Math.max(dp[i], dp[j]+1);
				}
			}
			maxans = Math.max(maxans, dp[i]);
			show(dp);
		}
		
		return maxans;
	}
	
	public void show(int[] num){
		for(int i:num) System.out.print(i + " ");
		System.out.print("\n");
	}
	
	
	
	//注意不是连续！！错误！！
	public int lengthOfLIS2(int[] nums) {
		int len = nums.length;
		if(len <= 1) return len;
		
		int l = 0;
		int r = 1;
		int cur = 1;
		int res = 0;
		while(r<len){
			if(nums[r]>nums[r-1]){//严格递增
				System.out.println(nums[r] + ">" + nums[r-1] + ", 当前递增");
				System.out.println("l=" + l + ", r=" + r);
				cur++;
				r++;
				res = Math.max(cur, res);
			}else{
				System.out.println("l=" + l + ", r=" + r);
				l = r;
				r++;
				cur = 0;
			}
		}
		
		return res;
	}

674. 最长连续递增序列

https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/

	/*
	 * 2. 动态规划
	 * 执行用时：1 ms, 在所有 Java 提交中击败了99.77%的用户
	 * 内存消耗：42.2 MB, 在所有 Java 提交中击败了6.06%的用户
	 */
	public int findLengthOfLCIS2(int[] nums) {
		int len = nums.length;
		if(len <= 1) return len;
		
		int[] dp = new int[len];
		dp[0] = 1;
		
		int res = 1;
		for(int i=1; i<len; i++){
			if(nums[i] > nums[i-1]){
				dp[i] = dp[i-1]+1;
				res = Math.max(res, dp[i]);
			}else{
				dp[i] = 1;
			}
		}
		
		return res;
	}
	
	/*
	 * 1. 双指针
	 * 执行用时：1 ms, 在所有 Java 提交中击败了99.77%的用户
	 * 内存消耗：42.1 MB, 在所有 Java 提交中击败了12.63%的用户
	 * 
	 * 注意：
	 * 1. 一开始res要赋值为0
	 * 2. 一旦不递增，cur不归零，归1
	 */
	public int findLengthOfLCIS(int[] nums) {
		int len = nums.length;
		if(len <= 1) return len;
		
		int l = 0;
		int r = 1;
		int cur = 1;
		int res = 1;
		while(r<len){
			if(nums[r]>nums[r-1]){//严格递增
				System.out.print(nums[r] + ">" + nums[r-1] + ", 当前递增");
				//System.out.println("l=" + l + ", r=" + r);
				cur++;
				r++;
				res = Math.max(cur, res);	
				System.out.println("，当前cur:" + cur);
			}else{
				System.out.print(nums[r] + "<=" + nums[r-1] + ", 当前非递增");
				//System.out.println("l=" + l + ", r=" + r);
				l = r;
				r++;
				cur = 1;
				System.out.println("，当前cur:" + cur);
			}
		}
		
		return res;
	}

718. 最长重复子数组

https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/

	/*
	 * dp[i][j]：以下标i结尾的nums1和以下标j结尾的nums2的最长公共子序列为dp[i][j]
	 */
	public int findLength(int[] nums1, int[] nums2) {
		int len1 = nums1.length;
		int len2 = nums2.length;
		if(len1 == 0 || len2 == 0) return 0;
		
		int[][] dp = new int[len1+1][len2+1];
		
		int res = 0;
		
		for(int i=0; i<len1+1; i++){
			for(int j=0; j<len2+1; j++){
				if(i==0 || j==0) {//左边上边都是0
					dp[i][j] = 0;continue;
				}
				
				if(nums2[j-1] == nums1[i-1]){
					dp[i][j] = dp[i-1][j-1] + 1;
					res = Math.max(res, dp[i][j]);
				}
				show(dp);
			}
		}
		
		return res;
	}

	
	public void show(int[][] num){
		for(int i=0; i<num.length; i++){
			for(int j=0; j<num[0].length; j++){
				System.out.print(num[i][j] + " ");
			}
			System.out.print("\n");
		}
		System.out.println("*************");
	}

1143. 最长公共子序列

https://leetcode-cn.com/problems/longest-common-subsequence/

	/*
	 * dp[i][j]：长度为[0, i-1]的字符串text1与长度为[0, j-1]的字符串text2
	 * 			的最长公共子序列为dp[i][j]
	 */
	public int longestCommonSubsequence(String text1, String text2) {
		int len1 = text1.length();
		int len2 = text2.length();
		if(len1 == 0 || len2 == 0) return 0;
		
		int[][] dp = new int[len1+1][len2+1];
		int res = 0;
		
		for(int i=0; i<=len1; i++) {
			for(int j=0; j<=len2; j++) {
				if(i==0 || j==0) {//左边上边都是0
					dp[i][j] = 0;continue;
				}
				/*
				 * dp[i][j]来自三个方向：左上，左，上
				 */
				if(text1.charAt(i+1) == text2.charAt(j+1)){
					dp[i][j] = dp[i-1][j-1] + 1;
				}else{
					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
				}
				res = Math.max(dp[i][j], res);
			}
		}
		
		return res;
	}

1035. 不相交的线

https://leetcode-cn.com/problems/uncrossed-lines/
其实就是最长公共子序列。

	/*
	 * 直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，
	 * 且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。
	 */
	public int maxUncrossedLines(int[] nums1, int[] nums2) {
		int len1 = nums1.length;
		int len2 = nums2.length;
		if(len1 == 0 || len2 == 0) return 0;
		
		int[][] dp = new int[len1+1][len2+1];
		int res = 0;
		
		for(int i=0; i<=len1; i++) {
			for(int j=0; j<=len2; j++) {
				if(i==0 || j==0) {//左边上边都是0
					dp[i][j] = 0;continue;
				}
				/*
				 * dp[i][j]来自三个方向：左上，左，上
				 */
				if(nums1[i-1] == nums2[j-1]){
					dp[i][j] = dp[i-1][j-1] + 1;
				}else{
					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
				}
				res = Math.max(dp[i][j], res);
			}
		}
		
		return res;
	}

53. 最大子数组和

  1. 注意贪心的顺序
  2. 注意动规初始化
	/*
	 * 贪心
	 */
	public int maxSubArray(int[] nums) {
		int len = nums.length;
		if(len == 0) return 0;
		
		int cur = 0;
		int res = Integer.MIN_VALUE; 
		
		for(int i=0; i<len; i++){
			cur += nums[i];
			if(cur > res) res = cur;
			if(cur < 0) cur = 0;
		}
		
		return res;
	}
	
	/*
	 * 动规
	 */
	public int maxSubArray1(int[] nums) {
		int len = nums.length;
		if(len == 0) return 0;
		
		int[] dp = new int[len];
		dp[0] = nums[0];
		int res = nums[0];
		
		for(int i=1; i<len; i++){
			/*
			 * 两个来源，两个求max
			 * 1. 从自己这重新开始
			 * 2. 加入前一个
			 */
			dp[i] = Math.max(nums[i], dp[i-1]+nums[i]);
			res = Math.max(res, dp[i]);
			show(dp);
		}
		
		return res;
	}

392. 判断子序列

https://leetcode-cn.com/problems/is-subsequence/submissions/
这个题要好好再和别的对比一下

  1. 相等的时候左上角+1
  2. 不等的时候就是左边
  3. 没有取max的情况
	public boolean isSubsequence(String s, String t) {
		int len1 = s.length();
		int len2 = t.length();
		if(len1 == 0) return true;
		if(len2 == 0 || len1>len2) return false;
		
		int[][] dp = new int[len1+1][len2+1];
		
		for(int i=1; i<=len1; i++){
			for(int j=1; j<=len2; j++){
				if(s.charAt(i-1) == t.charAt(j-1)){
					dp[i][j] = dp[i-1][j-1]+1;
				}else{
					dp[i][j] = dp[i][j-1];
				}
//				show(dp);
			}
		}
		
		return dp[len1][len2] == len1;
	}

115. 不同的子序列

https://leetcode-cn.com/problems/distinct-subsequences/

	/*
	 * 输入：s = "rabbbit", t = "rabbit"
	 * 输出：3
	 * dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。
	 */
	public int numDistinct(String s, String t) {
		int len1 = s.length(); int len2 = t.length();
		if(len2 == 0) return 0;
		
		int[][] dp = new int[len1+1][len2+1];
		dp[0][0] = 1;
		
		for(int i=1; i<=len1; i++){
			for(int j=0; j<=len2; j++){
				if(j == 0){
					dp[i][j] = 1;continue;//初始化
				}
				
				if(s.charAt(i-1) == t.charAt(j-1)){//相等由两部分构成
					dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
				}else{
					dp[i][j] = dp[i-1][j];
				}
			}
		}
		
		return dp[len1][len2];
		
		
		/*
		 * 1. s[i - 1] 与 t[j - 1]相等
		 * 		一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。
		 * 		一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
		 * 2. s[i - 1] 与 t[j - 1] 不相等
		 * 		dp[i][j]只有一部分组成，不用s[i - 1]来匹配，即：dp[i - 1][j]
		 */
	}

583. 两个字符串的删除操作

https://leetcode-cn.com/problems/delete-operation-for-two-strings/
min的括号不要标错位置！

	/*
	 * word1 = "sea", word2 = "eat"，输出：2
	 * word1 = "leetcode", word2 = "etco"，输出：4
	 */
	public int minDistance(String word1, String word2) {
		int len1 = word1.length();
		int len2 = word2.length();
		if(len1 == 0) return len2;
		if(len2 == 0) return len1;
		
		int[][] dp = new int[len1+1][len2+1];
        for (int i=0; i<=len1; i++) dp[i][0] = i;
        for (int j=0; j<=len2; j++) dp[0][j] = j;
        
		for(int i=1; i<=len1; i++){
			for(int j=1; j<=len2; j++){
				if(word1.charAt(i-1) == word2.charAt(j-1)){
					//相等的时候就是左上角
					dp[i][j] = dp[i-1][j-1];
				}else{
					//不等的时候三种情况，1减一个，2减一个，一起减一个，三个求min
					dp[i][j] = Math.min(dp[i-1][j-1]+2, Math.min(dp[i][j-1]+1, dp[i-1][j]+1));
					
//					if(i == 2 && j == 2){
//						System.out.println("i = " + i + ", j = " + j);
//						System.out.println("dp[i-1][j-1]+2 = " + (dp[i-1][j-1]+2));
//						System.out.println("dp[i][j-1]+1 = " + (dp[i][j-1]+1));
//						System.out.println("dp[i-1][j]+1 = " + (dp[i-1][j]+1));
//						System.out.println((dp[i-1][j]+1) + "和" + (dp[i][j-1]+1) + 
//											"的最小值为：" + Math.min(dp[i][j-1]+1, dp[i-1][j]+1));
//						System.out.println("最后dp[i][j] = " + (dp[i][j]));
//					}
					
				}
			}
			show(dp);
		}
		
		return dp[len1][len2];
	}

72. 编辑距离

https://leetcode-cn.com/problems/edit-distance/

	public int minDistance(String word1, String word2) {
		int len1 = word1.length();
		int len2 = word2.length();
		if(len1 == 0) return len2;
		if(len2 == 0) return len1;
		
		int[][] dp = new int[len1+1][len2+1];
        for (int i=0; i<=len1; i++) dp[i][0] = i;
        for (int j=0; j<=len2; j++) dp[0][j] = j;
        
		for(int i=1; i<=len1; i++){
			for(int j=1; j<=len2; j++){
				//1.当前比较字符相同，直接等于左上角
				if(word1.charAt(i-1) == word2.charAt(j-1)){
					dp[i][j] = dp[i-1][j-1];
				}else{
					/*
					 * 1. 增或删
					 * 		①word1删，dp[i - 1][j] + 1
					 * 		①word2删，dp[i][j - 1] + 1
					 * 2. 替换
					 * 		dp[i - 1][j - 1] + 1
					 */								
					dp[i][j] = Math.min(dp[i-1][j-1], 
							Math.min(dp[i][j-1], dp[i-1][j])) + 1;
				}
			}
		}
		return dp[len1][len2];
	}

647. 回文子串

  1. dp含义
  2. 状态转移方程
  3. 遍历顺序
	public int countSubstrings(String s) {
		int len = s.length();
		if(len == 0) return 0;
		
		boolean[][] dp = new boolean[len][len];
		int res = 0;
		for(int i=len-1; i>=0; i--){
			for(int j=i; j<len; j++){
				
				if(s.charAt(i) == s.charAt(j)){
					if(i == j || j-i == 1 || dp[i+1][j-1] == true){
						dp[i][j] = true;
						res++;
					}
				}			
			}
			show(dp);
		}		
		return res;
	}

516. 最长回文子序列

https://leetcode-cn.com/problems/longest-palindromic-subsequence/

	public int longestPalindromeSubseq(String s) {
		int len = s.length();
		if(len == 0) return 0;
		
		int[][] dp = new int[len][len];
		for(int i=len-1; i>=0; i--){
			for(int j=i; j<len; j++){
				if(i == j){//对角线都是1
					dp[i][j] = 1; continue;
				}
				
				if(s.charAt(i) == s.charAt(j)){//相等时，左下角加2
					dp[i][j] = dp[i+1][j-1] + 2;
				}else{//不等时，左边或者下边的max
					dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
				}
			}
		}		
		return dp[0][len-1];
	}
平什么阿
关注
专栏目录
携程历年校园招聘笔试试题 -.docx
05-26
携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx携程历年校园招聘笔试试题 -.docx
携程——前端笔试（2022.4.14）
m0_51496194的博客
04-18 2583
题目 1.画一个大小为n的U 2.数组染色 3.01串变间隔串 4.字符串子序列是9的倍数 1.画一个大小为n的U 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 2.数组染色 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 3.01串变间隔串 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
lcs leetcode1143 dp
weixin_46186724的博客
08-07 351
最长公共子序列 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。 示例 1： 输入：text1 = “abcde”, tex.
2023.3.29 练习携程一轮3.7笔试题（牛客找的，附本人部分题解）+3.29二轮笔试题（亲自考的）
cxfool的博客
03-30 1166
超市开展了一个活动， 当游游花费原价买了一件商品时，她可以用半价买下一件右边相邻的商品(也可以用原价购买，这样该商品右边的商品就有 一次享受半价的机会)。游游准备开车出游，她的车非常特殊，油越多则最高速度越快，即最高速度和油量是成正比的。游游初始的钱为 x，她想要买的商品的喜爱度总和尽可能大，但总价格不能超过 x，你能帮帮她计算最大的喜爱度总和吗?游游正在逛超市，有n个商品摆成排，第个商品的价格为ai,游游对它的真爱度为b。换言之，如果游游想要半价买某一件商品，必须先用原价买下它相邻的左边的那个商品。
游游的9的倍数
最新发布
小飞猪的博客
07-06 338
你这么看肯定是看不懂的啊，你得看dp[4][1]里面的 1 是怎么来的，是a[i]+j 得到的，也就是（8+2）%9=1。首先是前一个位置余数是 (j+a[i])%9 的数量，也就是dp[i-1][(j+a[i])%9]，也就是说不算当前 i 位置的数，就已经有这些数量了。dp[i][(j+a[i])%9]，就应该是当前位置余数是(j+a[i])%9的数量加上当前位置之前的余数是 j 的数量，这样才是总数量。dp[i][(j+a[i])%9]：i 位置及之前余数是 (j+a[i])%9 的数量。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
「代码随想录」动态规划专题精讲（v1.2）.pdf
07-15
从给定的文件信息来看，「代码随想录」动态规划专题精讲（v1.2）.pdf 的内容涉及到编程算法中的动态规划专题的精讲。动态规划（Dynamic Programming，简称DP）是一种在数学、管理科学、计算机科学、经济学和生物信息...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录算法PDF.rar
08-06
4. **动态规划**：动态规划是一种解决最优化问题的强大工具，如背包问题、最长公共子序列、斐波那契数列等。它强调的是状态转移方程和最优子结构。 5. **回溯法与贪心策略**：回溯法用于解决组合优化问题，如八皇后...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
子串和子序列问题-动态规划向
weixin_45532984的博客
10-23 2046
有关于子序列和子串的问题是字符串或者数组经常会遇到的问题，一般我们经常使用多指针，滑动窗口，动态规划的方式去解决，而本篇重点关注能用动态规划解决或者说明显使用动态规划解决的子串问题和子序列问题。子串是字符串中的由连续字符组成的一个序列，重点在于连续。例如，"1AB2345CD"，那么"1AB23"，"5CD"都是相应的子串，而"12345CD"不是，已经不是连续的状态。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串，那么很明显，子序列和子串最大的区别就是可
2021-06-22-求字符串的子序列数
ITAK_fans的博客
06-22 671
求一个字符串的子序列数，输入一个字符串s和子序列数的长度n，输出子序列数， 输入： word，2 输出： 6 解释： word的长度为2的子串有：wo,wr,wd,or,wd,rd 解题思路： 1、考虑使用组合公式C(s.size(),n)，但是这样不能排除字符串中相邻的字符是相同的情况，比如s=“aaa”,n=2. 组合公式得到的结果是C(3.2)=3,但是实际答案只能是一种“aa”,所以直接组合公式是不正确的。 2、使用深度优先搜索，对于重复的子序列用set去重 #include <bits/s
子序列问题
errors_F的博客
03-07 1459
子序列问题（双指针，动态规划） 例题一：判断子序列（力扣392） 链接：https://leetcode-cn.com/problems/is-subsequence/ 题目描述： 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。 进阶： 如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需
动态规划-子序列问题（判断子序列、不同的子序列、两个字符串的删除操作、编辑距离、回文子串、最长回文子序列）
m0_58761900的博客
04-07 702
动态规划-子序列问题（判断子序列、不同的子序列、两个字符串的删除操作、编辑距离、回文子串、最长回文子序列）
代码随想录动态规划——最大子数组和
qq_39473176的博客
11-02 237
刷题总结
代码随想录算法训练营第五十三天| LeetCode1143. 最长公共子序列、LeetCode1035. 不相交的线、LeetCode53. 最大子数组和
weixin_48323589的博客
12-05 427
代码随想录算法训练营第五十三天| LeetCode1143. 最长公共子序列、LeetCode1035. 不相交的线、LeetCode53. 最大子数组和
一分钟搞定leetcode子序列与子串的问题
corlor_龙的博客
08-12 228
子序列问题 1. 最长递增子序列—— leetcode_300 定义 dp[i] 为考虑前0到 i - 1 个元素，以第 i - 1个数字结尾的最长递增子序列的长度，就是前i个元素最长递增子序列的长度。 我们从小到大计算 dp 数组的值，在计算 dp[i] 之前，我们已经计算出 dp[0…i−1] 的值，则状态转移方程为： dp[i]=max(dp[j])+1，其中0≤j<i且num[j]<num[i]。比如num = [3,1,6,5,7]，dp[4]是dp[1]、dp[2]的最大值加1，为什
最大子列和问题-MaxSubseqSum
高一少年的博客
10-20 452
暴力遍历解法 优化解法 在线处理解法 分治法 个人觉得解法1最先想到，再仔细观察是解法2 解法3不好想到，但理解起来不算太难；解法4是真的不好理解(本人对递归理解较弱) def maxsubseqsum(seq): n= len(seq) maxsum = 0 for i in range(n): for j in range(i,n): ...
数据结构与算法--最大子列和代码汇总（C语言）
xiaoxiaozhunaoke的博客
05-05 232
/*求最大子列和算法比较*/ #include<stdio.h> #define N 10 int MaxSubseqSum1(int a[], int n); //n^3的算法复杂度 int MaxSubseqSum2(int a[], int n); //n^2的算法复杂度 int MaxSubseqSum3(int a[], int n); //nlog n的算法复杂度...
「代码随想录」动态规划详解：核心概念与实践技巧
"「代码随想录」动态规划专题精讲（v1.1）.pdf" 这篇资源是关于动态规划的深入讲解，适合正在学习或想要提升算法能力的编程爱好者，尤其是对LeetCode等在线编程挑战平台感兴趣的读者。动态规划是一种在计算机科学中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

平什么阿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值