Leetcode 刷题笔记(十) —— 栈与队列篇之经典题目

已于 2022-02-10 12:22:52 修改
阅读量1.5k 收藏 2
点赞数 3
分类专栏： 算法 文章标签： leetcode 链表 算法
于 2022-02-07 22:06:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1241692733/article/details/122799273
版权

文章目录

系列文章目录

一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
更新中 … …

前言

刷题路线来自 ：代码随想录

栈和队列的简单使用

栈： 先进后出

	// 栈
	Stack<Integer> stack = new Stack<>();
	// 入栈
	stack.push(1);  // 返回入栈元素
	stack.add(2);  // 返回 boolean 类型
	// 出栈，返回出栈元素
	stack.pop();
	// 返回栈顶元素
	stack.peek();

队列： 先进先出

	// 队列
	Queue<Integer> queue = new LinkedList<>();
	// 入队列
	queue.offer(1);  // 返回 boolean 类型
	queue.add(2);  // 返回 boolean 类型
	// 出队列，返回出队列元素
	queue.poll();
	// 返回队头元素
	queue.peek();

双端队列： 双端队列可以返回队头和队尾元素，并且两端都可以进行出队和入队操作

	// 双端队列
	Deque<Integer> deque = new ArrayDeque<>();
	Deque<Integer> deque1 = new LinkedList<>();
	// 入队列，返回 boolean 类型
	deque.addFirst(1); // 头插
	deque.addLast(1);  // 尾入
	
	// 出队列
	deque.pollFirst();  // 队头
	deque.pollLast();   // 队尾
	
	// 返回队头元素和队尾元素
	deque.peekFirst();  // 队头
	deque.peekLast();   // 队尾

优先级队列（堆）： 默认为小根堆（队头为最大或最小元素，入队时会自己调整）

	// 优先级队列
	PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
	// 方法同 Queue
	...
	// 大堆的创建
    PriorityQueue<Integer> maxHeap=new PriorityQueue<>(new Comparator<Integer>(){
       @Override
       public int compare(Integer o1,Integer o2){
           return o2-o1;
       }
   });

题录

232. 用栈实现队列

Leetcode 链接
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：
输入：
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

题解：
队列为先进先出，而栈为先进后出，所以使用栈模拟队列，模拟队列在出队列时需要将栈中元素按顺序出栈放到另外一个栈中再次出栈才能保证先进先出。也就是把一个栈中的元素放入另一个栈，会改变顺序。

class MyQueue {
	// 负责进栈
    Stack<Integer> stackIn = null;
    // 负责出栈
    Stack<Integer> stackOut = null;
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    // 模拟进队列
    public void push(int x) {
        stackIn.push(x);
    }
    // 模拟出队列
    public int pop() {
    	// 1.stackOut 为空：将 stackIn 中元素全部以出栈顺序入栈
    	// 2.stackOut 中右元素，直接出栈
        if (stackOut.isEmpty()) {
            while (!stackIn.isEmpty()) {
                stackOut.push(stackIn.pop());
            }
        }
        return stackOut.pop();
    }
    // 返回队列对头元素
    public int peek() {
    	// 同模拟出队列一样
        if (stackOut.isEmpty()) {
            while (!stackIn.isEmpty()) {
                stackOut.push(stackIn.pop());
            }
        }
        // 最后返回 stackOut 栈顶元素
        return stackOut.peek();
    }
    // 队列是否为空
    public boolean empty() {
    	// stackIn 和 stackOut 都为空，队列才为空
        return stackIn.isEmpty() && stackOut.isEmpty();
    }
}

225. 用队列实现栈

Leetcode 链接
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：
输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]
解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

题解：
如果像上题一样想着用一个输入队列，一个输出队列，是不行的。因为队列中的数据导入另一个队列中，数据的顺序并没有变。这里使用一个队列，模拟出栈时，将元素从队头移动到队尾直到原队列队尾元素为现在的队头。

class MyStack {
	// 模拟栈用的队列
    Queue<Integer> queue = null;
    public MyStack() {
        queue = new LinkedList<>();
    }
    // 入栈
    public void push(int x) {
        queue.add(x);
    }
    // 出栈
    public int pop() {
    	// 移动 n 次，队尾元素移动到队头
        int n = queue.size() - 1;
        while (n-- > 0) {
            queue.add(queue.poll());
        }
        // 此时队头元素为原队尾元素，出队列并返回
        return queue.poll();
    }
    // 返回栈顶元素
    public int top() {
    	// 同出栈一样，最后得到原队尾元素后再添加到队尾即可
        int n = queue.size() - 1;
        while (n-- > 0) {
            queue.add(queue.poll());
        }
        int res = queue.peek();
        queue.add(queue.poll());
        return res;
    }
    // 返回栈是否为空
    public boolean empty() {
        return queue.isEmpty();
    }
}

20. 有效的括号

Leetcode 链接
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：
输入：s = “()”
输出：true

示例 2：
输入：s = “()[]{}”
输出：true

示例 3：
输入：s = “(]”
输出：false

示例 4：
输入：s = “([)]”
输出：false

示例 5：
输入：s = “{[]}”
输出：true
题解：
使用栈模拟匹配过程，遍历 s ，若是左括号入栈。若是右括号，如与栈顶括号匹配，弹出栈顶元素；若不匹配或者剩下和不够都意味着不能全部匹配上返回 false。

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(' || ch == '[' || ch == '{') {
            	// 是左括号，入栈
                stack.push(ch);
            } else {
            	// 右括号，判断是否与栈顶元素匹配
                if (!stack.isEmpty() && isMate(stack.peek(), ch)) {
                	// 不匹配，弹出栈顶元素
                    stack.pop();
                } else {
                	// 没有左括号与其匹配，返回 false
                    return false;
                }
            }
        }
        // 如剩下左括号，栈不为空，返回 fasle；若全部匹配成功，栈空，返回 true
        return stack.isEmpty();
    }
	// 判断两个括号是否匹配
    public boolean isMate(char l, char r) {
        if (l == '(' && r == ')') return true;
        if (l == '{' && r == '}') return true;
        if (l == '[' && r == ']') return true;
        return false;
    }
}

优化：如果是左括号，入栈时可以用宇宙匹配的右括号入栈，这样在判断是否与栈顶元素匹配时只需要判断两个右括号是否相同即可

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(') stack.push(')');
            else if (ch == '{') stack.push('}');
            else if (ch == '[') stack.push(']');
            else if (!stack.isEmpty() && ch == stack.peek()) {
                stack.pop();
            } else {
                return false;
            }
        }
        return stack.isEmpty();
    }
}

1047. 删除字符串中的所有相邻重复项

Leetcode 链接
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在 S 上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：
输入：“abbaca”
输出：“ca”
解释：例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

题解：
消消乐：遍历 s, 栈为空或者 字符与栈顶元素不同，入栈；如果栈不为空，并且字符与栈顶元素相同，弹出栈顶元素

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        // 遍历 s
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (!stack.isEmpty() && ch == stack.peek()) {
            	// 如果栈不为空，并且与栈顶元素相同，弹出栈顶元素
                stack.pop();
            } else {
            	// 栈为空或者与栈顶元素不同，入栈
                stack.push(ch);
            }
        }
        // 拼接栈中剩余字符并返回
        StringBuilder sb = new StringBuilder();
        for (char ch : stack) {
            sb.append(ch);
        }
        return String.valueOf(sb);
    }
}

优化：StringBuilder 可以充当栈，StringBuilder 有 deleteCharAt 可以删除指定下标元素

class Solution {
    public String removeDuplicates(String s) {
        StringBuilder sb = new StringBuilder();
        // 栈顶元素指针，始终指向栈顶元素，需要在入栈和出栈时动态维护
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (top >= 0 && ch == sb.charAt(top)) {
                sb.deleteCharAt(top);
                top--;
            } else {
                sb.append(ch);
                top++;
            }
        }
        return sb.toString();
    }
}

双指针法：出栈和入栈由数组中元素的覆盖代替，慢指针指向栈顶元素，快指针遍历字符

    public String removeDuplicates(String s) {
        char[] arr = s.toCharArray();
        int slow = 0;
        for (int fast = 1; fast < s.length(); fast++) {
            if (slow >= 0 && arr[fast] == arr[slow]) {
            	// 相同时，出栈，栈顶指针 slow--
                slow--;
            } else {
            	// 不相同时，应入栈。入栈位置在栈顶位置后，所以 slow++，再覆盖
                slow++;
                arr[slow] = arr[fast];
            }
        }
        return String.valueOf(arr).substring(0, slow + 1);
    }

150. 逆波兰表达式求值

Leetcode 链接
根据 逆波兰表示法，求表达式的值。有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
注意 两个整数之间的除法只保留整数部分。可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：
输入：tokens = [“2”,“1”,"+",“3”,"*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：
输入：tokens = [“4”,“13”,“5”,"/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：
输入：tokens = [“10”,“6”,“9”,“3”,"+","-11","","/","",“17”,"+",“5”,"+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
题解：
遍历 tokens ，第一次遇见运算符结合前两个数运算即可，如果遇见两个连载一起的运算符怎么办呢？
需要解决掉第一个运算符，并更新前两个数字，这样第二个运算符前边依旧是两个数字，这里使用栈去维护

  1. 如果是运算符，弹出栈顶两个数运算，并将运算结果入栈；
  2. 不是运算符，转为数字入栈
  3. 返回栈顶结果
class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            String str = tokens[i];
            // 1.如果是运算符，弹出栈顶两个数运算，并将运算结果入栈
            if (str.equals("+")) {
                stack.push(stack.pop() + stack.pop());
            } else if (str.equals("-")) {
                int num = stack.pop();
                stack.push(stack.pop() - num);
            } else if (str.equals("*")) {
                stack.push(stack.pop() * stack.pop());
            } else if (str.equals("/")) {
                int num = stack.pop();
                stack.push(stack.pop() / num);
            } else {
            	// 2.不是运算符，转为数字入栈
                stack.push(Integer.valueOf(str));
            }
        }
        // 3.返回栈顶结果
        return stack.pop();
    }
}

239. 滑动窗口最大值

Leetcode 链接
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回 滑动窗口中的最大值 。

示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口 的 位置 | 最大值

[1 3 -1] -3 5 3 6 7 | 3
1 [3 -1 -3] 5 3 6 7 | 3
1 3 [-1 -3 5] 3 6 7 | 5
1 3 -1 [-3 5 3] 6 7 | 5
1 3 -1 -3 [5 3 6] 7 | 6
1 3 -1 -3 5 [3 6 7] | 7

示例 2：
输入：nums = [1], k = 1
输出：[1]
题解：[ . . . .] 表示窗口中的值，窗口中有些区间的数不可能作为窗口中最大的数，我们先来分析分析

  1. [1,2,3,4,3,2,1] 中 前边123都不要，因为左边 [1,2,3,4] 中4让最大值不可能在 小于4 的123中出现，所以窗口中保留 [4,3,2,1];

  2. 那 4 后边的 321 还有用吗？有用，因为[4,3,2,1] 当 4 移出窗口后，3便成为了最大的数

  3. [4,3,2,1] 这时来了个5，[6,3,2,1,5] 中只有 [6,5] 有用，因为只要有 321 在 5 左边并且和 5 同时存在作为窗口左边一部分时，最大值只可能在5 或者 5 右边的窗口中出现。

所以我们来维护一个队列保存窗口中有用的数，保证队列中数从左到右，从大到小，也就是一个单调队列。比如窗口 [5,1,2,3]，新来一个数4，单调队列中应保存 [5,4]。而单调队列最左边就为最窗口中的最大数

那么当 k = 5 时，窗口右移，5 要出队列，怎么判断队头元素是否该出队列呢？
队列中应保存下标，如 5 下标是 2，新来的数下标是 7，通过下标差值判断队头元素是否要出队列。

为什么要使用双端队列呢？
窗口 [5,1,2,3,4]，4是新来的 --> 队列 [5,4]，需要新来的 4 和队尾元素比较，因为 4 大于队尾元素，队尾元素依次出队列

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length - k + 1];
        // 双端队列
        Deque<Integer> deque = new ArrayDeque<>();
        // 遍历数组
        for (int i = 0; i < nums.length; i++) {
        	// 队列不为空，deque.peekFirst() == i - k（窗口右移后，队头元素下标在窗口外）
            if (!deque.isEmpty() && deque.peekFirst() == i - k) {
            	// 队头元素下标出队列
                deque.pollFirst();
            }
			// 窗口不为空，新来的 nums[i] 大于 队尾元素，队尾元素出队列
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            // 新来的数下标入队列
            deque.addLast(i);
			// 从第 k - 1 个数入窗口开始，就要记录窗口中最大数了
            if (i >= k - 1) {
            	// 队头就为窗口中最大数下标，记录在返回数组中
                res[i - k + 1] = nums[deque.peek()];
            }
        }
        return res;
    }
}
a1241692733
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
【Leetcode刷题笔记】栈
12-22
【栈在LeetCode中的应用】 在LeetCode等算法题库中，栈是一种非常常见的数据结构，用于解决多种问题。本文将深入探讨栈在处理有效括号问题中的应用，即LeetCode第20题《有效的括号》。 1. **有效的括号问题**： -...
Leetcode 刷题笔记(十一) —— 栈与队列篇之 top-K 问题
a1241692733的博客
02-09 631
面试常见算法 top-K 问题
Leetcode 刷题笔记(七) —— 字符串篇之经典题目
a1241692733的博客
02-04 427
Leetcode 刷题笔记， 字符串篇之经典题目，反转字符串、左旋字符串、替换空格，反转单词
Leetcode 刷题笔记(六) —— 哈希表篇之经典题目
a1241692733的博客
01-23 548
Leetcode 刷题笔记 —— 哈希表篇之哈希表的遍历方式和一些经典题目
leetcode刷题笔记7-栈与队列
infinite2020的博客
04-02 263
首先我们在栈与队列：来看看栈和队列不为人知的一面 (opens new window)中讲解了栈和队列的理论基础。C++中stack，queue 是容器么？我们使用的stack，queue是属于那个版本的STL？我们使用的STL中stack，queue是如何实现的？stack，queue 提供迭代器来遍历空间么？相信不仅仅是C++中有这些问题，那么大家使用其他编程语言，也可以考虑一下这四个问题，栈和队列是如何实现的。
Leetcode 刷题笔记(八) —— 字符串篇之 KMP
a1241692733的博客
02-05 2628
Leetcode 刷题笔记(八) —— 字符串篇之 KMP算法的理解
Leetcode 刷题笔记(二十三) ——动态规划篇之基础题目
a1241692733的博客
02-25 3225
动态规划中每一个状态一定是由上一个状态推导出来的
Leetcode 刷题笔记(五) —— 链表篇之链表的基础操作和经典题目
a1241692733的博客
01-23 510
Leetcode 刷题笔记(五) —— 链表篇之链表的基础操作和经典题目，刷题路线来自代码随想录
Leetcode 刷题笔记(十九) ——回溯算法篇之组合问题
a1241692733的博客
02-19 629
本文使用回溯算法来解决通过暴力多层循环遍历，因循环的层数变化正常的暴力解无法写出的组合问题，也是一个纯暴力的搜索方法。
LeetCode 刷题笔记 with Java.zip
11-23
接着是《LeetCode 刷题笔记 with Java 51-100.pdf》，这个阶段的题目难度逐渐提升，涉及了二叉树、图、堆、队列等复杂的数据结构。例如，“Merge Intervals”（合并区间）要求我们合并时间重叠的事件区间，这需要...
LeetCode刷题笔记——63. 不同路径 II
12-21
【LeetCode刷题笔记——63. 不同路径 II】 一、题目描述： 在LeetCode的第63题中，我们被要求计算一个有障碍物的网格中从左上角到右下角的不同路径数量。网格由一个二维整数数组`obstacleGrid`表示，其中1代表障碍...
谷歌高畅Leetcode刷题笔记.pdf
08-04
谷歌高畅leetcode刷题笔记
leetcode日记（51）不同路径Ⅱ
s478527548的博客
07-25 741
琢磨了一下代码，原理是将上面的二维数组优化成了一维，记录开始位置到达每一行末尾的路径数。没有障碍物就将数目设为上一行路径数加上这一行路径数。需要注意的是遍历方向，按照上面这种思路需要先遍历列再遍历行，如果先遍历行，如果上一行末尾有障碍物那么下一行就通过不了。根据上一题改的代码如下，添加了对障碍物的判定，如果有障碍物则将数组值设为0。然后看了答案，答案说可以使用滚动数组优化，就又去搜了一下滚动数组的使用方法。和上一道题（无障碍物的最短路径）很像，但事实上比上一题多了优化方法。
【力扣练习题】C语言答案
m0_65146517的博客
07-24 611
4、判断两数大小，p小于等于q返回p，p->next递归调用函数。2、遍历判断两个链表的单个值，用尾插法将小的值代入链表。1、如果q为NULL，p为NULL；3、如果遇到大于100000的数则返回true;5、否则返回q，q->next递归调用函数。1、将所有遍历过的值全部替换为100001。2、判断如果遇到NULL则返回false。3、如果p为NULL,返回 q;2、如果q为NULL，返回p；
LeetCode 2766.重新放置石块：哈希表
<font color="Pink">Tisfy的博客</font>
07-25 858
LeetCode 2766.重新放置石块：哈希表 给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。 在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。 完成这些操作后，请你按升序返回所有 有 石块的位置。 注意： 如果一个位置至少有一个石块，我们称这个位置 有 石块。 一个位
【动态规划】力扣.213. 打家劫舍 II
sjsjs11的博客
07-25 477
同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。具体步骤和思路跟打家劫舍1的相同（主页有打家劫舍1的三种算法的详细思路），唯一区别是增加了首尾房子不能同时被偷的限制，所以可以分类讨论，然后返回出能偷到最大的金额即可。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。输入：nums = [1,2,3,1]
力扣621.任务调度器
最新发布
Pisasama的博客
07-25 325
【代码】力扣621.任务调度器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值