算法题解 （双指针）

已于 2022-03-14 14:20:54 修改
阅读量181 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 leetcode 双指针
于 2021-07-27 16:59:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45234510/article/details/116265560
版权

文章目录

leetcode官网：https://leetcode-cn.com/problems
CS-Notes：https://www.cyc2018.xyz/

1、两数之和 II - 输入有序数组（7/21-167）

在这里插入图片描述
在这里插入图片描述

解题思路：

使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。

如果两个指针指向元素的和 sum == target，那么得到要求的结果；
如果 sum > target，移动较大的元素，使 sum 变小一些；
如果 sum < target，移动较小的元素，使 sum 变大一些。

数组中的元素最多遍历一次，时间复杂度为 O(N)。只使用了两个额外变量，空间复杂度为 O(1)。

在这里插入图片描述

java代码实现：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if(numbers == null) return null;
        int i = 0, j = numbers.length - 1;
        while(i<j) {
            int sum = numbers[i] + numbers[j];
            if(sum == target) {
                return new int[]{i+1,j+1};
            }else if(sum < target){
                i++;
            }else{
                j--;
            }
        }
        return null;
    }
}

2、平方数之和（7/21-633）

在这里插入图片描述
在这里插入图片描述

解析：

可以看成是在元素为 0~target 的有序数组中查找两个数，使得这两个数的平方和为 target，如果能找到，则返回 true，表示 target 是两个整数的平方和。

本题和 167. Two Sum II - Input array is sorted 类似，只有一个明显区别：一个是和为 target，一个是平方和为 target。本题同样可以使用双指针得到两个数，使其平方和为 target。

本题的关键是右指针的初始化，实现剪枝，从而降低时间复杂度。设右指针为 x，左指针固定为 0，为了使 02 + x2 的值尽可能接近 target，我们可以将 x 取为 sqrt(target)。

因为最多只需要遍历一次 0~sqrt(target)，所以时间复杂度为 O(sqrt(target))。又因为只使用了两个额外的变量，因此空间复杂度为 O(1)。

Java实现：

class Solution {
    public boolean judgeSquareSum(int c) {
        int left = 0, right = (int)Math.sqrt(c);
        while(left <= right) {
            int sum = left*left + right*right;
            if(sum == c) {
                return true;
            }else if(sum < c) {
                ++left;
            }else {
                --right;
            }
        }
        return false;
    }
}

在这里插入图片描述

3、反转字符串中的元音字母（7/21-345）

在这里插入图片描述

解析：

使用双指针，一个指针从头向尾遍历，一个指针从尾到头遍历，当两个指针都遍历到元音字符时，交换这两个元音字符。

为了快速判断一个字符是不是元音字符，我们将全部元音字符添加到集合 HashSet 中，从而以 O(1) 的时间复杂度进行该操作。

时间复杂度为 O(N)：只需要遍历所有元素一次
空间复杂度 O(1)：只需要使用两个额外变量

在这里插入图片描述
在这里插入图片描述

Java实现：

class Solution {
    //元音字母集合
    private final static HashSet<Character> vowels = new HashSet<>( //创建HashSet集合对象
        Arrays.asList('a','e','i','o','u','A','E','I','O','U')
    );

    public String reverseVowels(String s) {
        if(s == null) return null;
        int left = 0, right = s.length() -1;
        char[] result = new char[s.length()];
        while(left <= right) {
            char cl = s.charAt(left);  // charAt返回第i个位置的字符
            char cr = s.charAt(right);
            if(!vowels.contains(cl)) {
                result[left++] = cl;   //如果不包含就存如直接数组
            } else if(!vowels.contains(cr)) {
                result[right--] = cr;  //如果不包含就存如直接数组
            } else {
                result[left++] = cr;   //当左右两边都包含就先交换再存入数组
                result[right--] = cl;
            }
        }
        return new String(result); 
    }
}

在这里插入图片描述

4、验证回文字符串 Ⅱ（7/21-680）

在这里插入图片描述
在这里插入图片描述

解析：

所谓的回文字符串，是指具有左右对称特点的字符串，例如 “abcba” 就是一个回文字符串。

使用双指针可以很容易判断一个字符串是否是回文字符串：令一个指针从左到右遍历，一个指针从右到左遍历，这两个指针同时移动一个位置，每次都判断两个指针指向的字符是否相同，如果都相同，字符串才是具有左右对称性质的回文字符串。
在这里插入图片描述
本题的关键是处理删除一个字符。在使用双指针遍历字符串时，如果出现两个指针指向的字符不相等的情况，我们就试着删除一个字符，再判断删除完之后的字符串是否是回文字符串。

在判断是否为回文字符串时，我们不需要判断整个字符串，因为左指针左边和右指针右边的字符之前已经判断过具有对称性质，所以只需要判断中间的子字符串即可。

在试着删除字符时，我们既可以删除左指针指向的字符，也可以删除右指针指向的字符。
在这里插入图片描述

Java实现：

class Solution {
    public boolean validPalindrome(String s) {
        for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
            }
        }
        return true;
    }

    private boolean isPalindrome(String s, int i, int j) {
        while (i < j) {
            if (s.charAt(i++) != s.charAt(j--)) {
                return false;
            }
        }
        return true;
    }

}

在这里插入图片描述

5、合并两个有序数组（7/27-88）

在这里插入图片描述
在这里插入图片描述

解析：

需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。

Java实现：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i1 = m-1, i2 = n-1;
        int i3 = m+n-1;
        while(i2 >= 0){
            if(i1 < 0){
                nums1[i3--] = nums2[i2--];
            }else if(i2 < 0){
                nums1[i3--] = nums1[i1--];
            }else if(nums1[i1] > nums2[i2]){
                nums1[i3--] = nums1[i1--];
            }else{
                nums1[i3--] = nums2[i2--];
            }
        } 
    }
}

在这里插入图片描述

6、环形链表（7/27-141）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

解析：

使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。

Java实现：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }
        ListNode l1 = head, l2 = head.next;
        while(l1 != null && l2 != null && l2.next != null){
            if(l1 == l2){
                return true;
            }
            l1 = l1.next;
            l2 = l2.next.next;
        }
        return false;
    }
}

在这里插入图片描述

7、通过删除字母匹配到字典里最长单词（7/27-524）

在这里插入图片描述
在这里插入图片描述

解析：

通过删除字符串 s 中的一个字符能得到字符串 t，可以认为 t 是 s 的子序列，我们可以使用双指针来判断一个字符串是否为另一个字符串的子序列。

Java实现：

class Solution {
    public String findLongestWord(String s, List<String> dictionary) {
        String longsetWord = "";
        for(String targer : dictionary){
            int l1 = longsetWord.length(), l2 = targer.length();
            if(l1 > l2 || (l1 == l2 && longsetWord.compareTo(targer) < 0)){ //longsetWord.compareTo(targer)如果此字符串小于字符串参数，则返回一个小于 0 的值；
                continue;
            }
            if(isSubstr(s,targer)){
                longsetWord = targer;
            }
        }
        return longsetWord;
    }

    //判断两个字符串是否相等
    private boolean isSubstr(String s, String targer) {
        int i = 0, j = 0;
        while(i < s.length() && j < targer.length()) {
            if(s.charAt(i) == targer.charAt(j)) {  // s.charAt(i) 表示：获取s中下标为i的字符
                j++;
            } 
            i++;
        }
        return j == targer.length();
    }
}

在这里插入图片描述

*剑指 Offer 18. 删除链表的节点

剑指 Offer 18. 删除链表的节点

在这里插入图片描述

解析：设置一个虚拟头结点再进行删除操作。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode dummy  = new ListNode(-1);
        dummy.next = head;
        ListNode cur = dummy;
        while(cur.next != null){
            if(cur.next.val == val){ //如果相等，就跳到下一个，就是删除
                cur.next = cur.next.next;
            }else{
                cur = cur.next; //移动到下一个
            }
        }
        return dummy.next;
    }
}

在这里插入图片描述

*剑指 Offer 22. 链表中倒数第k个节点

剑指 Offer 22. 链表中倒数第k个节点

在这里插入图片描述

解析：先让快指针移动k个节点，再同时移动，最后返回慢指针即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast = head; //快指针
        ListNode slow = head; //慢指针
        for(int i=0; i<k; i++){
            fast = fast.next; //先让快指针移动k个节点
        }
        while(fast != null){ //再同时移动，最后返回慢指针即可
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

在这里插入图片描述

*剑指 Offer 25. 合并两个排序的链表

剑指 Offer 25. 合并两个排序的链表
在这里插入图片描述

解析：双指针，比较两个链表的节点值，哪个小就把新链表指向它，最后把剩下的直接拼接到新链表末尾。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        ListNode dummy = new ListNode(-1); //创建虚拟头节点
        ListNode res = dummy; 
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){ //如果l1的值小于等于l2的值，就添加l1
                res.next = l1; //赋值
                l1 = l1.next;   //添加元素后的链接移动
            }else{  //如果l1的值大于l2的值，就添加l2
                res.next = l2;
                l2 = l2.next;
            }
            res = res.next; //新链表移动
        }
        //剩下的直接拼接到新链表后面
        if(l1 == null) res.next = l2;
        if(l2 == null) res.next = l1;
        return dummy.next;

    }
}

在这里插入图片描述

剑指 Offer 52. 两个链表的第一个公共节点

剑指 Offer 52. 两个链表的第一个公共节点

在这里插入图片描述

解析：使用双指针，先计算出两个链表的长度，然后让长的链表先移动“差值”，然后再一起移动，一起移动时碰到两个节点相同就返回，否则就一起移动到下一个节点。

注意：是节点相等，而不是值相等。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null && headB == null) return null;
        ListNode curr1 = headA;
        ListNode curr2 = headB;
         //算出两个链表的长度
        int len1=0, len2=0;
        while(curr1 != null){
            ++len1;
            curr1 = curr1.next;
        }
        while(curr2 != null){
            ++len2;
            curr2 = curr2.next;
        }
        //重置头指针
        curr1 = headA;
        curr2 = headB;
        
        //如果链表1比链表2长
        if(len1 > len2){
            //链表1先移动
            for(int i=0; i<(len1-len2); i++){
                curr1 = curr1.next;
            }
            //再同时移动,如果发现结点相等，就返回
            for(int j=0; j<len2; j++){
                if(curr1 == curr2){
                    return curr1;
                }else{
                    curr1 = curr1.next;
                    curr2 = curr2.next;
                }
            }
        }else{
            //链表2先移动
            for(int i=0; i<(len2-len1); i++){
                curr2 = curr2.next;
            }
            //再同时移动,如果发现结点相等，就返回
            for(int j=0; j<len2; j++){
                if(curr2 == curr1){
                    return curr2;
                }else{
                    curr1 = curr1.next;
                    curr2 = curr2.next;
                }
            }            
        }
        return null; 
    }
}

在这里插入图片描述

*剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

在这里插入图片描述

解析：双指针，分别从左右两边开始，判断如果是 偶奇，交换后都移动；奇偶，都移动；奇奇，移动左；偶偶，移动右。

class Solution {
    public int[] exchange(int[] nums) {
        if(nums == null || nums.length <= 0) return nums;
        int left = 0;
        int right = nums.length-1;
        while(left < right){
            if(nums[left] % 2 == 0 && nums[right] % 2 != 0){  //偶奇，交换后都移动
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }else if(nums[left] % 2 != 0 && nums[right] % 2 == 0){ //奇偶，都移动
                left++;
                right--;               
            }else if(nums[left] % 2 != 0 && nums[right] % 2 != 0){ //奇奇，移动左
                left++;             
            }else { //偶偶，移动右
                right--;               
            }
        }
        return nums;

    }
}

在这里插入图片描述

*剑指 Offer 57. 和为s的两个数字

剑指 Offer 57. 和为s的两个数字
在这里插入图片描述

解析：双指针

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int left = 0, right = nums.length-1;
        while(left < right){
            if(nums[left] + nums[right] == target){ //相等，直接返回
                return new int[]{nums[left],nums[right]};
            }else if(nums[left] + nums[right] < target){ //和 小于 目标值，移动左
                left++;
            }else{ //和 大于 目标值，移动右
                right--;
            }
        }
        return new int[]{};

    }
}

在这里插入图片描述

剑指 Offer 58 - I. 翻转单词顺序

剑指 Offer 58 - I. 翻转单词顺序
在这里插入图片描述在这里插入图片描述

解法一：分割+倒序

class Solution {
    public String reverseWords(String s) {
        String[] new_s = s.trim().split(" "); // 删除首尾空格，分割字符串
        StringBuilder res = new StringBuilder();
        //从后往前添加单词数组
        for(int i=new_s.length-1; i>=0; i--){
            if(new_s[i].equals("")) continue; //如果遇到空单词，就跳过
            if(i != 0){
                res.append(new_s[i] + " ");
            }else{
                res.append(new_s[i]); //添加最后一个时，不需要加空格
            }
        }
        return new String(res);
    }
}

在这里插入图片描述

解法二：双指针

class Solution {
    public String reverseWords(String s) {
        s = s.trim(); // 删除首尾空格
        int j = s.length() - 1, i = j;
        StringBuilder res = new StringBuilder();
        while(i >= 0) {
            while(i >= 0 && s.charAt(i) != ' ') i--; // 搜索首个空格
            res.append(s.substring(i + 1, j + 1) + " "); // 添加单词
            while(i >= 0 && s.charAt(i) == ' ') i--; // 跳过单词间空格
            j = i; // j 指向下个单词的尾字符
        }
        return res.toString().trim(); // 转化为字符串并返回
    }
}

在这里插入图片描述

NC41 最长无重复子数组 - 3.14

NC41 最长无重复子数组

在这里插入图片描述

解析：双指针，i遍历数组，start为不重复子数组的起始位置，如果当前元素已经存在，则更新 不重复子数组的起始位置。

import java.util.*;


public class Solution {
    /**
     * 
     * @param arr int整型一维数组 the array
     * @return int整型
     */
    public int maxLength (int[] arr) {
        if(arr.length == 0) return 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        int max = 0;
        //双指针，i遍历数组，start为不重复子数组的起始位置
        for(int i=0,start=0; i<arr.length; i++){
            //如果当前元素已经存在，则更新 不重复子数组的起始位置
            if(map.containsKey(arr[i])){
                start = Math.max(start, map.get(arr[i])+1);
            }
            //添加元素
            map.put(arr[i], i);
            //更新最长值
            max = Math.max(max, i-start+1);
        }
        return max;
    }
}

在这里插入图片描述

x-dragon8899
关注
专栏目录
java-leetcode面试题解双指针之第977题有序数组的平方.zip
03-25
本资源“java_leetcode面试题解双指针之第977题有序数组的平方”聚焦于解决LeetCode上的第977题，这是一道与双指针技术和有序数组相关的算法问题。下面我们将深入探讨这个题目及其解决方案。 **题目描述：** ...
LeedCode算法思想-双指针
Jason王祖龙
03-09 998
文章目录1. 有序数组的 Two Sum2. 两数平方和3. 反转字符串中的元音字符4. 回文字符串5. 归并两个有序数组6. 判断链表是否存在环7. 最长子序列 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。 1. 有序数组的 Two Sum 167. Two Sum II - Input array is sorted (Easy) Leetcode / 力扣 Input:...
LeetCode双指针经典题（一）15道
CodePanda@GPF的博客
04-28 1988
LeetCode双指针类型题目
【leetcode】双指针算法题
最新发布
weixin_69380220的博客
07-05 1322
双指针算法
Leetcode每日一题：面试题02.02.kth-node-from-end-of-list-lcci（返回倒数第k个节点）
CodeLuweir 的博客
09-28 3192
思路：典型得快慢指针问题，快指针与慢指针中间隔着k-2个节点，那么同时++快慢指针，当快指针指向链表结尾节点时，慢指针指向倒数第k个节点； struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int kthToLast(ListNode *head, int k) { ListNode *left = head, *right = head; int count = 1; .
双指针经典练习：
qq_51797890的博客
07-21 133
双指针经典练习： 1 ：题目大意 ： 输入一个数组 ， 求子序列的个数（子序列连续并且不包含重复元素）（题目链接） Input ： 5 1 1 2 1 5 Output ： 9 样例解释 ：子序列有 （1）（1）（1，2）（2）（2，1）（2，1，5）（1）（1，5）（5） 解题思路1 ： 1 ：设置一个集合记录不重复元素序列的个数 2 ：ans += 集合中的值的大小 3： 用 i 指针来记录答案 ，j 指针始终使集合中不出现重复元素 AC代码1： #include<bits/...
【习题】双指针法（详解）
Shun_Hua的博客
02-02 777
双指针习题
java-leetcode面试题解双指针之第42题接雨水.zip
03-25
双指针是一种常见的算法思想，它通过维护两个指针（通常一个从数组的起始位置开始，另一个从结尾开始），以不同的速度或方向遍历数组，从而解决一系列问题，如查找、排序、合并等。在“接雨水”问题中，双指针策略被...
java-leetcode面试题解双指针之第15题三数之和.zip
03-25
本压缩包文件“java-leetcode面试题解双指针之第15题三数之和.zip”包含了解决这道问题的Java代码实现。 题目描述：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c，使得a + b + c = 0？要求找...
java-leetcode面试题解双指针之第925题长按键入.zip
03-25
这个题目涉及到双指针技术，这是一种在数组或字符串处理中广泛使用的优化技巧。 双指针是一种在处理线性数据结构时非常有效的策略，它通常涉及两个指针，分别从数组或字符串的两端开始，向中间移动，以实现查找、...
java-leetcode面试题解双指针之第125题验证回文串.zip
03-25
以上就是关于Java LeetCode面试题解双指针之第125题验证回文串的详细解析，包括问题描述、解题思路、代码实现以及相关的知识点拓展。这个题目不仅测试了基础的字符串操作，还考察了对双指针技巧的理解和应用，是Java...
双指针算法(超详细带8道例题及算法解析) —— 包含力扣题目有283移动零、1089复写零、202快乐数、11盛水最多的容器、611有效三角形的个数、179双数之和、15三数之和、18四数之和
dream_ready的博客
12-11 182
双指针是一种思想，而不是说真的就是定义了两个指针，它和语言没有关系，比如C++，Java，Python等都可以使用双指针算法解题，而且是一种非常常见的算法 常见的双指针有两种形式，一种是左右指针，一种是快慢指针 左右指针 一般用于顺序结构中，也称对撞指针 左右指针从两端向中间移动。一个指针从最左端开始，另一个从最右端开始，然后逐渐往中间逼近 左右指针的终止条件一般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是： left == right （两个指针指向同一个位置）
算法刷题总结—双指针算法
qq_54780782的博客
05-17 185
双指针算法是解题过程中常用的优化算法，可将两重for循环通过双指针算法进行优化时间复杂度O（n），i最多遍历n次，j最多遍历n次关键点：分析i和j之间满足的单调性下面看几道具体的双指针算法的例子。
有两个字符串s 和t，如果即从s 中删除一些字符，将剩余的字符连接起来，即可获得t。则称t是s 的子序列。请你开发一个程序，判断t是否是s的子序列。
weixin_67271870的博客
12-08 705
有两个字符串s 和t，如果即从s 中删除一些字符，将剩余的字符连接起来，即可获得t。则称t是s 的子序列。请你开发一个程序，判断t是否是s的子序列。解析：思路：定义两个字符串str1 和 str2，接收输入，然后定义两个循环变量i 和 j，令j = 0。从i = 0 ~ str1.length() - 1判断，如果str1[i] == str2[j]，则 j ++， i ++；否则i ++，继续判断。直到i == str1.length()或j == str2.length()，退出循环。 如果j =
【C++双指针法】5道题带你认识双指针法
xzt12138的博客
11-22 1187
所谓双指针法，就是利用两个指针（不一定是真指针，能储存相应元素的位置就行）分别标识两个位置，然后通过指针所指元素的性质对数组（或者链表结点）进行修改，同时移动指针完成目标的方法。
【算法练习】高频「双指针」类型题目总结
在路上的德尔菲的博客
07-18 458
题目一
【双指针精选题目】详解8道题
m0_74044018的博客
01-10 965
双指针8道经典题目：1、移动零 2、复写零 3、快乐数 4、盛最多水的容器 5、有效三角形的个数 6 7 8为两数之和 三数之和 和 四数之和
C指针专项练习
番茄炒蛋不吃西红柿的博客
09-13 502
文章目录数组名的意义题1题2题3题4题5 本章主要讲解关于指针的经典练习。 数组名的意义 首先回顾一下关于数组名的相关知识： 1.sizeof(数组名)：这里数组名表示整个数组； 2.&数组名：这里数组名表示整个数组； 3.其他情况下，数组名都表示数组首元素地址 再回顾一下strlen和sizeof操作符: strlen库函数：求字符串长度 sizeof操作符：求变量或者类型创建的变量所占空间的大小（单位是字节） 题1 //代码1 int main() { //一维数组 int a[] = {
指针题目特训（答案加解析）走进大厂笔试
weixin_67900732的博客
07-04 5385
八道大厂指针笔试题
剑指Offer：算法题解与代码
这里可以使用一种叫做“快慢指针”或者“龟兔赛跑”的方法来解决。由于数组中的元素值范围是0到n-1，我们可以创建一个大小为n的新数组，用新数组的下标表示原数组中的元素，值表示新数组中对应位置的元素出现的次数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值