代码随想录算法训练营第六天| 454. 四数相加 II、383. 赎金信、15. 三数之和、18. 四数之和

最新推荐文章于 2024-07-10 16:47:58 发布
最新推荐文章于 2024-07-10 16:47:58 发布
阅读量643 收藏 19
点赞数 30
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79744698/article/details/139626551
版权

目录

454. 四数相加 II

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

383. 赎金信

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

15. 三数之和

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

18. 四数之和

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

454. 四数相加 II

题目链接：

454. 四数相加 II - 力扣（LeetCode）

题目要求：

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

  • 0 <= i, j, k, l < n
  • nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

题目用例：

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

实现思路：

1.使用HashMap来存储nums1和nums2中所有可能的和以及它们出现的次数

2. 遍历nums1和nums2，计算它们的和，并将和作为键，出现的次数作为值存储在map中

3.初始化计数器（count）

4.遍历nums3和nums4，计算它们的和的相反数，并查看相反数在map中是否存在，如果存在，则将对应的次数加到计数器上

5.返回结果

实现代码：

import java.util.HashMap;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        // 使用HashMap来存储nums1和nums2中所有可能的和以及它们出现的次数
        HashMap<Integer, Integer> map = new HashMap<>();

        // 遍历nums1和nums2，计算它们的和，并将和作为键，出现的次数作为值存储在map中
        for (int num1 : nums1) {
            for (int num2 : nums2) {
                int sum = num1 + num2;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }

        // 初始化计数器
        int count = 0;

        // 遍历nums3和nums4，计算它们的和的相反数
        for (int num3 : nums3) {
            for (int num4 : nums4) {
                int targetSum = -(num3 + num4); //查看相反数在map中是否存在
                if (map.containsKey(targetSum)) {
                    // 如果存在，则将对应的次数加到计数器上
                    count += map.get(targetSum);
                }
            }
        }

        // 返回结果
        return count;
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
   /*     示例 1：

        输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
        输出：2

        示例 2：

        输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
        输出：1*/
        Solution solution=new Solution();

        //示例1：
        int[]nums01={1,2};
        int[]nums02={-2,-1};
        int[]nums03={-1,2};
        int[]nums04={0,2};
        System.out.println(solution.fourSumCount(nums01,nums02,nums03,nums04));

        //示例2：
        int[]nums11={0};
        int[]nums12={0};
        int[]nums13={0};
        int[]nums14={0};
        System.out.println(solution.fourSumCount(nums11,nums12,nums13,nums14));
    }
}

383. 赎金信

题目链接：

383. 赎金信 - 力扣（LeetCode）

题目要求：

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

题目用例：

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

提示：

  • 1 <= ransomNote.length, magazine.length <= 105
  • ransomNote 和 magazine 由小写英文字母组成

实现思路：

1. 如果ransomNote的长度大于magazine的长度，那么它肯定不能由magazine构成

2. 创建一个长度为26的数组，用于记录每个小写字母出现的次数

3.遍历magazine字符串，对于每个字符，增加对应字母在result数组中的计数

4.遍历ransomNote字符串，对于每个字符，减少对应字母在result数组中的计数

5.遍历result数组，检查是否有任何字母的计数小于0，如果有返回false，否则返回true

实现代码：


class Solution {
    /*给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

       如果可以，返回 true ；否则返回 false 。

       magazine 中的每个字符只能在 ransomNote 中使用一次。*/
    public boolean canConstruct(String ransomNote, String magazine) {
        // 如果ransomNote的长度大于magazine的长度，那么它肯定不能由magazine构成
        if(ransomNote.length()>magazine.length()){
            return false;
        }
        // 创建一个长度为26的数组，用于记录每个小写字母出现的次数
        int []result=new int[26];
        // 遍历magazine字符串，对于每个字符，增加对应字母在result数组中的计数
        for (int i = 0; i < magazine.length(); i++) {
            result[magazine.charAt(i) - 'a']++;
        }
        // 遍历ransomNote字符串，对于每个字符，减少对应字母在result数组中的计数 
        for (int i = 0; i < ransomNote.length(); i++) {
            result[ransomNote.charAt(i) - 'a']--;
        }
        // 遍历result数组，检查是否有任何字母的计数小于0 
        for (int i:result){
            if(i<0){
                return false;
            }
        }
        return true;

    }
}

测试代码：

public class Test {
/*
    示例 1：

    输入：ransomNote = "a", magazine = "b"
    输出：false
    示例 2：

    输入：ransomNote = "aa", magazine = "ab"
    输出：false
    示例 3：

    输入：ransomNote = "aa", magazine = "aab"
    输出：true
*/

    public static void main(String[] args) {
        Solution01 solution = new Solution01();
        //示例1：
        String ransomNote1 = "a", magazine1 = "b";
        System.out.println(solution.canConstruct(ransomNote1,magazine1));
        //示例2：
        String ransomNote2 = "aa", magazine2 = "ab";
        System.out.println(solution.canConstruct(ransomNote2,magazine2));
        //示例3：
        String ransomNote3 = "aa", magazine3= "aab";
        System.out.println(solution.canConstruct(ransomNote3,magazine3));
    }
}

15. 三数之和

题目链接：

15. 三数之和 - 力扣（LeetCode）

题目要求：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

题目用例：

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

实现思路：

1.声明结果集（res）

2.检查数组长度

3.对nums进行排序，方便后续双指针方法使用

4.进入for循环，循环次数为：i < nums.length-2，跳过重复的数字以避免重复的三元组

5.在循环中，定义左右指针，分别为：left=i+1;  right=nums.length-1;

6.在for循环中，嵌套一个while循环，条件为：left<right，定义一个sum用来计算nums[i]+nums[left]+nums[right]相加的和

7.在while循环中，根据sum的值：

如果sum为0的话，直接往结果集中添加数据，并且跳过（left++）重复的left以避免重复的三元组和跳过（right--）重复的right以避免重复的三元组，再次移动左右指针位置（left++，right--）

如果比0小，移动左指针，扩大sum的值

如果比0大，移动右指针，缩小sum的值

8.返回结果集（res）

实现代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
 /*   给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，
      同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

    你返回所有和为 0 且不重复的三元组。

    注意：答案中不可以包含重复的三元组。*/
    public List<List<Integer>> threeSum(int[] nums) {
        //声明结果集
        List<List<Integer>> res = new ArrayList<>();
        // 检查数组长度
        if (nums == null || nums.length < 3) {
            return res;  
        }
        //排序nums
        Arrays.sort(nums);
        for (int i = 0; i < nums.length-2; i++) {
            // 跳过重复的数字以避免重复的三元组
            if (i > 0 && nums[i] == nums[i-1]) continue;
            int left=i+1;
            int right=nums.length-1;
            while(left<right){
                int sum = nums[i]+nums[left]+nums[right];
                if(sum==0){
                   res.add(Arrays.asList(nums[i],nums[left],nums[right]));
                   while(left<right && nums[left]==nums[left+1]) left++;
                   while(left<right && nums[right]==nums[right-1]) right--;
                    left++;
                    right--;
                }

                else if(sum<0){
                    left++;
                }
                else if(sum>0){
                    right--;
                }
            }
        }
        return res;

    }
}

测试代码：

import java.util.List;

public class Test {
    /*
    示例 1：

    输入：nums = [-1,0,1,2,-1,-4]
    输出：[[-1,-1,2],[-1,0,1]]

    示例 2：

    输入：nums = [0,1,1]
    输出：[]

    示例 3：

    输入：nums = [0,0,0]
    输出：[[0,0,0]]
 */
    public static void main(String[] args) {
        Solution solution = new Solution();

        //示例1：
        int[]nums01={-1,0,1,2,-1,-4};
        List<List<Integer>> res01= solution.threeSum(nums01);
        for (List<Integer> list : res01) {
            System.out.print(list+"");
        }
        System.out.println();
        //示例2：
        int[]nums02={0,1,1};
        List<List<Integer>>res02=solution.threeSum(nums02);
        for (List<Integer> list : res02) {
            System.out.print(list+"");
        }
        System.out.println();
        //示例3：
        int[]nums03={0,0,0};
        List<List<Integer>>res03=solution.threeSum(nums03);
        for (List<Integer> list : res03) {
            System.out.print(list+"");
        }
        System.out.println();
    }
}

18. 四数之和

题目链接：

18. 四数之和 - 力扣（LeetCode）

题目要求：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

  • 0 <= a, b, c, d < n
  • a、b、c 和 d 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

题目用例：

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

实现思路：

1.声明结果集（res）

2.检查数组长度

3.对nums进行排序，方便后续双指针方法使用

 4.固定两个数（外层循环）： 

使用两个嵌套的循环（k和i）来固定两个数（即四元组中的前两个数）。由于数组已经排序，所以k从0开始，i从k+1开始。

在每次迭代中，都要跳过与上一个元素相同的数（k和i），以避免产生重复的四元组。

5.使用双指针（内层循环）:

在固定了两个数之后，使用双指针left和right来分别指向剩余数组的开始和结束位置。

在每次迭代中，计算当前四个数的和sum，并与目标值target进行比较。

6.处理找到的四元组:

如果sum等于target，则将当前四元组添加到结果集res中。

然后，移动left和right指针，同时跳过与当前元素相同的数，以避免产生重复的四元组。

7.调整指针位置:

如果sum小于target，说明需要更大的和，因此将left指针向右移动。

如果sum大于target，说明需要更小的和，因此将right指针向左移动

8.返回结果集（res）

实现代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        //定义结果集
        List<List<Integer>> res = new ArrayList<>();
        //检查数组长度
        if(nums == null || nums.length < 4) return res;
        //排序数组
        Arrays.sort(nums);
        //进入循环
        for (int k = 0; k < nums.length - 3; k++) {
                //跳过重复的数字以避免重复的四元组
                if(k>0&&nums[k]==nums[k-1])continue;
                for(int i=k+1;i<nums.length-2;i++){
                    if(i>k+1&&nums[i]==nums[i-1])continue;
                    // 如果 nums[k] + nums[i] 已经大于 target，并且 target 是负数，则无需继续循环
                    //if (nums[k] + nums[i] > target && target < 0) break;
                    //long leftSumTarget = (long) target - nums[i] - nums[k]; // 使用 long 类型
                    int left = i+1;
                    int right = nums.length-1;
                    while(left<right){
                        long sum =(long) nums[k]+nums[i]+nums[left]+nums[right];
                        if(sum==target){
                            res.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
                            while(left<right&&nums[left]==nums[left+1])left++;
                            while(left<right&&nums[right]==nums[right-1])right--;
                            left++;
                            right--;
                        }
                        else if(sum<target){
                            left++;
                        }
                        else {
                            right--;
                        }
                    }
                    
                }



        }
        return res;

    }
}

测试代码：

import java.util.List;

public class Test {
    public static void main(String[] args) {
        /*示例 1：

        输入：nums = [1,0,-1,0,-2,2], target = 0
        输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
        示例 2：

        输入：nums = [2,2,2,2,2], target = 8
        输出：[[2,2,2,2]]*/

        Solution solution = new Solution();
        //示例1：
        int[]nums01={1,0,-1,0,-2,2};
        int target1=0;
        List<List<Integer>> res01= solution.fourSum(nums01,target1);
        for (List<Integer> list : res01) {
            System.out.print(list+"");
        }
        System.out.println();
        //示例2：
        int[]nums02={2,2,2,2,2};
        int target2=8;
        List<List<Integer>>res02=solution.fourSum(nums02,target2);
        for (List<Integer> list : res02) {
            System.out.print(list+"");
        }
        System.out.println();

    }
}

空.白251
关注
  • 30
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法训练营第6天 | 454. 四数相加 II 383. 赎金信 15. 三数之和 18. 四数之和
miracle_world的博客
10-31 2705
哈希表
代码随想录算法训练营第六天 | 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和
weixin_64591091的博客
01-16 380
数值大小不可控，不可以用array；题意要统计元组出现的次数，所以我们需要有key-value的键值对, 所以说用Map。3.注意Java中String / char /int 语法。可以，但是要去重，选择双指针。1.哈希表的思维考虑，根据题意的大小。2.可以用数组或者map。2.不返回下标，那就排序。3.去重a（后一位对比）
代码随想录算法训练营第六天|454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和
weixin_62540227的博客
12-05 55
4.轮到left和right，先判断三个指针所在的值的和想加是否是我们想要的值，如果是，先记录结果，然后再对两个指针进行去重，再移动。5.轮到left和right，先判断三个指针所在的值的和想加是否是我们想要的值，如果是，先记录结果，然后再对两个指针进行去重，再移动。和前面三数之和其实流程差不多，多了个循环，加上剪枝和去重的细节要注意，还有和不是0,了，和是target了。2.存的时候要是发现已经有这个值了，就在原来的值上+1，要是没有这个值，就初始化赋值为0再加1也就是1。
代码随想录算法训练营第六天| 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和
qq_43602569的博客
06-28 782
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2]注意： 答案中不可以包含重复的三元组。
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录知识星球精华（第四版）最强八股文-算法篇.rar
03-19
《代码随想录知识星球精华（第四版）最强八股文-算法篇》是一份集大成的算法学习资源，其22M的大小蕴含着丰富的编程智慧与算法精髓。这份资料全面覆盖了算法领域的核心知识点，对于程序员尤其是对算法有深入需求的IT...
36. Adam 算法详解
最新发布
qq_41238579的博客
07-10 681
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
D1.排序
2302_79232710的博客
07-07 202
快速排序和归并排序
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 305
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
十一、作业
weixin_58543820的博客
07-07 460
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
【排序 - 堆排序】
2302_80393814的博客
07-10 356
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1236
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 1702
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 921
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 675
单调队列（自定义一种队列规则）使用场景1.
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，例如先看视频、了解自己所使用的编程语言、使用日志等方法来提高刷题效果和语言掌握程度。 训练营中的讨论内容非常丰富，涵盖了各种算法知识点和解题方法。例如，在第14天的训练营中，讲解了二叉树的理论基础、递归遍历、迭代遍历和统一遍历的内容。此外，在讨论中还分享了相关的博客文章和配图，帮助学员更好地理解和掌握二叉树的遍历方法。 训练营还提供了每日的讨论知识点，例如在第15天的讨论中，介绍了层序遍历的方法和使用队列来模拟一层一层遍历的效果。在第16天的讨论中，重点讨论了如何进行调试（debug）的方法，认为掌握调试技巧可以帮助学员更好地解决问题和写出正确的算法代码。 总之，代码随想录算法训练营是一个提供优质学习和讨论环境的平台，可以帮助学员系统地学习算法知识，并提供了丰富的讨论内容和刷题建议来提高算法编程能力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [代码随想录算法训练营每日精华](https://blog.csdn.net/weixin_38556197/article/details/128462133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值