P1801 黑匣子 题解

最新推荐文章于 2023-10-10 05:53:11 发布
最新推荐文章于 2023-10-10 05:53:11 发布
阅读量299 收藏
点赞数 1
分类专栏： 题解 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lv_jia_qi/article/details/130672526
版权

题目传送门

这道题算法是二叉平衡树，要想做此题，我们要先了解一下二叉平衡树

要想了解二叉平衡树，我们要从二叉排序树说起：

二叉排序树

二叉排序树又称二叉搜索树、二叉查找树 BST

性质如下：

  1. 空树为二叉排序树
  2. 若二叉排序树的左子树不为空，则左子树上所有节点的权值都小于根节点的权值
  3. 若二叉排序树的右子树不为空，则右子树上所有节点的权值都大于根节点的权值
  4. 二叉排序树的左右子树均为二叉排序树

退化：如果建树的元素均为有序，退化成链式的结构。

二叉排序树单次查找复杂度O(logn)，退化成链式的结构时为O(n)

为了防止二叉排序树退化，我们创造了一种数据结构——二叉平衡树

二叉平衡树有如下几种方式：

  • 替罪羊树
  • Treap树
  • Splay树
  • AVL树
  • 红黑树
  • SBT树

这里我们讲解Treap树

Treap树

Tree + Heap 。满足二叉排序树与二叉堆的两种性质。

树堆（Treap）

核心思想：用优先级来维护二叉树的平衡性。

应用：维护序列，元素的定位。修改、删除穿插在查询中。

  • 寻找名次
  • 确定<x的最大值
  • 确定>x的最小值

Treap树的操作基于 "键值"+"优先级"。

优先级：赋予节点一个随机的优先级。

键值：二叉排序树 优先级：二叉堆

对于任意的一组节点：fa父节点，ls左孩子节点,rs右孩子节,满足特性：

  1. 键值满足二叉排序树特征：ls.val<fa.val<rs.val
  2. 优先级满足二叉堆特征：fa.pri>max(ls.pri,rs.pri)

重要性质：若每个节点的键值、优先级提前确定好，那么构成的BST的形态唯一，与插入顺序无关。

Treap单次操作复杂度为O(logn)，n次为O(nlogn)

旋转法维护平衡树

平衡树旋转

左旋：

  1. 将k作为根节点
  2. 将x作为k的左孩子
  3. 将k的的左孩子称为x的右孩子

右旋：

  1. 将k作为新的根节点
  2. 将x作为k的右孩子
  3. 将原来k的右孩子作为x的左孩子

代码实现：

struct node{
	int val;//键值
	int pri;//优先级
	int size;//节点信息 
	int ls,rs;//左、右孩子 
}t[N];

void rotate(int &x,int d){//d=0右旋 d=1左旋 
	int k;
	if(d==0){//右旋操作 
	//将x围绕左孩子k，右旋至k的右孩子节点位置
	// k的右子树成为x的左子树 
		k=t[x].ls;
		t[x].ls=t[k].rs;
		t[k].rs=x;
	}else{//左旋操作 
	//将x围绕右孩子k,左旋至k的左孩子节点位置
	//k的左孩子称为x的右孩子
		k=t[x].rs;
		t[x].rs=t[k].ls; 
	 	t[k].ls=x;
	}
	//更新 
	
}

插入节点

  1. 从根节点u开始遍历，若u为空，则创建新的节点存储元素值x.并给新节点附加随机数作为优先级
  2. 若x大于等于u的值，则在u的右子树上递归插入。回溯时做旋转调整。若u的优先级小于其右子节点的优先级，则u左旋。
  3. 若x小于u的值，则在u的左子树上递归插入。回溯时，做旋转调整。若u的优先级小于他的左子结点的优先级，则右旋。
int newNode(int x)
{
	cnt ++;
	t[cnt].size = 1;
	t[cnt].ls = t[cnt].rs = 0;
	t[cnt].val = x;
	t[cnt].pri = rand();
	return cnt;
}
void insert(int &u,int x){
	if(u==0){
		u=newNode(x);//创建新节点，并存储x至新节点中
		//并返回新节点的下标
		return; 
	}
	t[u].size++;
	
	//若x大于等于u的键值，则递归插入右子树 
	if(x>=t[u].val) insert(t[u].rs,x);
	else insert(t[u].ls,x);
	
	//回溯时，需要旋转调整
	if(t[u].ls!=0 && t[u].pri<t[ t[u].ls ].pri) rotate(u,0);
	if(t[u].rs!=0 && t[u].pri<t[ t[u].rs ].pri) rotate(u,1);
	//更新调整后的节点信息 
	update(u);
}

删除节点

  1. 找到此节点
  2. 若此节点是叶节点，直接删除
  3. 若此节点只有一个子树，将子树上移
  4. 若此节点有两个子树，向下旋转,偏向优先级更高的
void del(int &u,int x){
	t[u].size--;
	if(t[u].key==x){//找到键值为x的节点
		//当前节点为叶子结点
		if(!t[u].ls && !t[u].rs){u=0;return;}
		//只有一棵子树，将子树上移
		if(!t[u].ls || !t[u].rs){u=t[u].ls+t[u].rs;return;}
		//向下旋转,偏向优先级更高的
		if(t[t[u].ls].pri>t[t[u].rs].pri){//左子节点优先级大于右子节点的优先级
			//右旋,在u的右子树中递归删除
			rotate(u,0);
			del(t[u].rs,x);
			return ;
		}else{//左子结点优先级小于右子节点的优先级
		    //左旋，继续在u的左子树中递归删除
			rotate(u,1);
			del(t[u].ls,x);
			return ;
		}
	}
	//若val小于u的值，则在u的左子树中递归删除
	if(x<t[u].key) del(t[u].ls,x);
	else del(t[u].rs,x);//若val大于等于p的值，则在p的右子树中递归删除
	update(u);
}

然后是查询x数的排名，查询排名为x的数，查询x的前驱，查询x的后继，详细操作见注释

int Rank(int u,int x){//查找x的排名
	if(u==0) return 0;//是根直接输出
	if(x>t[u].key) return t[t[u].ls].size+1+Rank(t[u].rs,x);//若比根大，则排名为左子树结点个数+根节点+右子树排名
	return Rank(t[u].ls,x);//若比根小，则为左子树排名
}
int kth(int u,int k){查询排名为x的数
	if(k==t[t[u].ls].size+1) return t[u].key;//若现排名正确（左子树结点个数+根节点），则输出
	else if(k>t[t[u].ls].size+1) return kth(t[u].rs,k-t[t[u].ls].size-1);//若现排名大，则继续递归右子树，还需要减少的排名为k-左子树结点个数-根节点
	else return kth(t[u].ls,k);//若现排名小，则递归左子树
}
int precursor(int u,int x){//前驱
	if(u==0) return 0;//是根直接输出
	if(t[u].key>=x) return precursor(t[u].ls,x);//如果值大，找左子树
	int tmp=precursor(t[u].rs,x);//递归右子树
	if(tmp==0) return t[u].key;//如果是根直接输出
	return tmp;//不是返回tmp
}
int successor(int u,int x){//后继
	if(u==0) return 0;//是根直接输出
	if(t[u].key<=x) return successor(t[u].rs,x);//如果值小，找右子树
	int tmp=successor(t[u].ls,x);//递归左子树
	if(tmp==0) return t[u].key;//如果是根直接输出
	return tmp;//不是返回tmp
}

最后是模板

#include <bits/stdc++.h>
using namespace std;
const int M=1e5+5;
struct node{
	int ls,rs;//左、右孩子
	int key,pri;//键值、优先级
	int size;//当前节点为根的子树的节点数
}t[M];
int cnt=0;//t[cnt] 最新的节点
void newNode(int x){//初始化新节点
	t[++cnt].key=x;//处理键值
	t[cnt].size=1;//初始化子树个数
	t[cnt].pri=rand();//生成随机的优先级
}

void update(int u){//更新以u为根的子树的size
	t[u].size=t[t[u].ls].size+t[t[u].rs].size+1;
}

void rotate(int &o,int d){//旋转，d=0右旋，d=1左旋
	int k;
	if(d==1){
	//左旋，把o围绕右儿子k向左旋转至k的左孩子处，原k的左孩子成为o的右孩子
		k=t[o].rs;//获取o的右儿子信息，存入k
		t[o].rs=t[k].ls;//将k的左孩子接入成为o的右孩子
		t[k].ls=o;//o成为k的左孩子
	}else{
	//右旋，将o围绕左儿子k,右旋至k的右孩子位置,原k的右子树成为o的左孩子
		k=t[o].ls;//获取o的左儿子信息，存入k
		t[o].ls=t[k].rs;//将k的右孩子接入成为o的左孩子
		t[k].rs=o;//o成为k的右孩子
	}
	t[k].size=t[o].size;//更新当前孩子节点k的结点数信息
	update(o);//更新当前根节点o的节点数信息
	o=k;//新的根是k
}

void insert(int &u,int x){
	if(u==0){newNode(x);u=cnt;return;}//递归到了一个空叶子，新建节点
	t[u].size++;
	if(x>=t[u].key) insert(t[u].rs,x);//递归右子树找空叶子,直到插入
	else insert(t[u].ls,x);//递归左子树找空叶子，直到插入
	//回溯时做旋转调整，若u的优先级小于其左子节点的优先级，则u右旋
	if(t[u].ls!=0 && t[u].pri<t[t[u].ls].pri) rotate(u,0);//右旋
	//回溯时做旋转调整，若u的优先级小于其右子结点的优先级，则u左旋
	if(t[u].rs!=0 && t[u].pri<t[t[u].rs].pri) rotate(u,1);//左旋
	update(u);
}

void del(int &u,int x){
	t[u].size--;
	if(t[u].key==x){//找到键值为x的节点
		//当前节点为叶子结点
		if(!t[u].ls && !t[u].rs){u=0;return;}
		//只有一棵子树，将子树上移
		if(!t[u].ls || !t[u].rs){u=t[u].ls+t[u].rs;return;}
		//向下旋转,偏向优先级更高的
		if(t[t[u].ls].pri>t[t[u].rs].pri){//左子节点优先级大于右子节点的优先级
			//右旋,在u的右子树中递归删除
			rotate(u,0);
			del(t[u].rs,x);
			return ;
		}else{//左子结点优先级小于右子节点的优先级
		    //左旋，继续在u的左子树中递归删除
			rotate(u,1);
			del(t[u].ls,x);
			return ;
		}
	}
	//若val小于u的值，则在u的左子树中递归删除
	if(x<t[u].key) del(t[u].ls,x);
	else del(t[u].rs,x);//若val大于等于p的值，则在p的右子树中递归删除
	update(u);
}

int Rank(int u,int x){//查找x的排名
	if(u==0) return 0;
	if(x>t[u].key) return t[t[u].ls].size+1+Rank(t[u].rs,x);
	return Rank(t[u].ls,x);
}

int kth(int u,int k){
	if(k==t[t[u].ls].size+1) return t[u].key;
	else if(k>t[t[u].ls].size+1) return kth(t[u].rs,k-t[t[u].ls].size-1);
	else return kth(t[u].ls,k);
}

int precursor(int u,int x){
	if(u==0) return 0;
	if(t[u].key>=x) return precursor(t[u].ls,x);
	int tmp=precursor(t[u].rs,x);
	if(tmp==0) return t[u].key;
	return tmp;
}

int successor(int u,int x){
	if(u==0) return 0;
	if(t[u].key<=x) return successor(t[u].rs,x);
	int tmp=successor(t[u].ls,x);
	if(tmp==0) return t[u].key;
	return tmp;
}

int main(){
	srand(time(NULL));
	return 0;
}

黑匣子

这道题稍微分析，可知要运用二叉平衡树的插入与查找x的排名操作

先读入Add和Get，将Get从小到大排序

按顺序插入Add，每到Get时输出第k大即可

代码如下：

#include<bits/stdc++.h>
using namespace std;
struct node{
	int val;
	int pri;
	int size;
	int ls,rs;
}t[200005];
int cnt,k;
int a[200005],b[200005];
int newNode(int x)
{
	cnt ++;
	t[cnt].size = 1;
	t[cnt].ls = t[cnt].rs = 0;
	t[cnt].val = x;
	t[cnt].pri = rand();
	return cnt;
}
void update(int u)
{
	t[u].size = t[t[u].ls].size + t[t[u].rs].size + 1; 
}

void rotate(int &x, int d)
{
	int k;
	if(d == 0)
	{
		k = t[x].ls;
		t[x].ls = t[k].rs;
		t[k].rs = x;
	}
	else
	{
		k = t[x].rs;
		t[x].rs = t[k].ls; 
	 	t[k].ls = x;
	}
	t[k].size = t[x].size;
	update(x);
	x = k;
}

void insert(int &u, int x)
{
	if(u == 0)
	{
		u = newNode(x);
		return;
	}
	t[u].size ++;
	if(x >= t[u].val)
	{
		insert(t[u].rs, x);
	}
	else
	{
		insert(t[u].ls, x);
	}
	if(t[u].ls != 0 && t[u].pri < t[t[u].ls].pri)
	{
		rotate(u, 0);
	}
	if(t[u].rs != 0 && t[u].pri < t[t[u].rs].pri)
	{
		rotate(u, 1);
	}
	update(u);
}
void del(int &u,int x){
	t[u].size --;
	if(t[u].val == x)
	{
		if(!t[u].ls && !t[u].rs){u = 0; return;}
		if(!t[u].ls || !t[u].rs){u = t[u].ls + t[u].rs; return;}
		if(t[t[u].ls].pri > t[t[u].rs].pri)
		{
			rotate(u, 0);
			del(t[u].rs, x);
			return ;
		}else
		{
			rotate(u, 1);
			del(t[u].ls, x);
			return;
		}
	}
	if(x < t[u].val) del(t[u].ls, x);
	else del(t[u].rs, x);
	update(u);
}
int Rank(int u, int x)
{
	if(u == 0) return 0;
	if(x > t[u].val) return t[t[u].ls].size + 1 + Rank(t[u].rs, x);
	return Rank(t[u].ls, x);
}
int kth(int u, int k)
{
	if(k == t[t[u].ls].size + 1) return t[u].val;
	else if(k > t[t[u].ls].size + 1) return kth(t[u].rs, k - t[t[u].ls].size - 1);
	else return kth(t[u].ls, k);
}
int precursor(int u, int x)
{
	if(u == 0) return 0;
	if(t[u].val >= x) return precursor(t[u].ls, x);
	int tmp = precursor(t[u].rs, x);
	if(tmp == 0) return t[u].val;
	return tmp;
}

int successor(int u, int x)
{
	if(u == 0) return 0;
	if(t[u].val <= x) return successor(t[u].rs, x);
	int tmp = successor(t[u].ls, x);
	if(tmp == 0) return t[u].val;
	return tmp;
}

int main()
{
	srand(time(NULL));
	int n,m,root=0;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=m;i++) cin>>b[i];
	sort(b+1,b+m+1);
	for(int i=1;i<=m;i++)
	{
		for(int j=b[i-1]+1;j<=b[i];j++) insert(root,a[j]);
		cout<<kth(root,++k)<<"\n";
	}
	return 0;
}

P1801 黑匣子
m0_73035684的博客
10-26 107
看了看，发现这个题可以用对顶堆做，一个是大根堆，一个小根堆，但是不知道是这个题的细节比较多的原因还是我写法的问题，调了好久，一个小时，才过，明天要再想一下，这也是少有的洛谷把题目难度评低了的题，感觉难度在于第一个大根堆的大小是要变的，这个要是想清楚了应该就很简单了。
洛谷 P10337 [UESTCPC 2024] 操作序列 题解
xzz_0611 的博客
04-07 1148
洛谷 P10337 [UESTCPC 2024] 操作序列 题解
P1801 黑匣子（对顶堆）
weixin_33937913的博客
03-17 180
https://www.luogu.org/problem/show?pid=1801#sub 用对顶堆来做： 上次输出第s小的数，在大根堆里储存s数（这个状态需要维护），在小根堆里存剩下的数，下一次输出时输出小根堆的顶，即是需要输出的值，s++ #include<iostream> #include<cstdio> #include<cst...
洛谷P1801 黑匣子
dilei7762的博客
01-02 191
题目描述 Black Box是一种原始的数据库。它可以储存一个整数数组，还有一个特别的变量i。最开始的时候Black Box是空的．而i等于0。这个Black Box要处理一串命令。 命令只有两种： ADD(x)：把x元素放进BlackBox; GET：i加1，然后输出BlackBox中第i小的数。 记住：第i小的数，就是Blac...
洛谷P1724题解（请不要抄袭！）
06-17
洛谷P1427题解，若要复制or下载，请与我联系，如要改编，也请联系，若发现未经我同意的复制、下载、改编，直接举报。
洛谷入门p1150 peter的烟题解
06-08
洛谷入门p1150 peter的烟题解
P1553 数字反转 题解
10-02
以下题解仅供学习参考使用
P1335 NOI2013 小 Q 的修炼AC题解
03-23
你不AC我吃
P1801 黑匣子(对顶堆)
Ghostttttttiii的博客
04-07 286
P1801黑匣子https://www.luogu.com.cn/problem/P1801 #include <iostream> #include <cstdio> #include <string> #include <algorithm> #include <vector> #include <queue> #include <stack> #include <cstring> #include &.
luogu P1801 黑匣子
zhu_yin233的博客
12-23 525
原题链接: 黑匣子 - 洛谷https://www.luogu.com.cn/problem/P1801 题目描述 Black Box 是一种原始的数据库。它可以储存一个整数数组，还有一个特别的变量i。最开始的时候 Black Box 是空的．而i=0。这个 Black Box 要处理一串命令。 命令只有两种： ADD(x)：把x元素放进 Black Box; GET：i加1，然后输出 Black Box 中第i 小的数。 记住：第i小的数，就是 B...
【洛谷】P1801 黑匣子
数学、算法爱好者的博客
10-10 261
可以维护两个堆，一个大顶堆一个小顶堆，这两个堆存插入的值，并且要维护小顶堆的数都大于等于大顶堆的数，这样查询的时候直接查大顶堆的堆顶即可。Black Box是一种原始的数据库。它可以储存一个整数数组，还有一个特别的变量。输出Black Box根据命令串所得出的输出串，一个数字一行。这个Black Box要处理一串命令。最开始的时候Black Box是空的．而。我们来演示一下一个有。
[P1801]黑匣子
今天的北宅依旧没有回家
03-17 266
原题链接思路来自题解使用两个堆来维护 大根堆 记录当前 前s个最小的数多出来的数 扔到小根堆里 等需要输出的时候 把小根堆的顶 输出 然后删掉 放进大根堆里#include<iostream> #include<cstdio> #include<cstring> #include<string> #include<cmath> #include<algorithm> #includ
【洛谷P1801】黑匣子【堆】
stoorz
05-30 324
题目大意 ： 题目链接：https://www.luogu.org/problemnew/show/P1801 两种操作： ADD(x)ADD(x)ADD(x)：加入xxx元素 GETGETGET：第iii次GETGETGET操作输出第iii小的元素 思路： 有点像对顶堆啊。 每次维护一个大根堆，保证只保存最小的sss个数字。其中sss表示现在进行了sss次GETGETGET操作。 然后维护...
P1801-黑匣子_NOI导刊2010提高【堆】
weixin_30443731的博客
05-10 119
正题 题目链接： https://www.luogu.org/problemnew/show/P1801 大意 有两种操作， 1.将一个数放入黑匣子中 2.++i之后查询第i小的数（初始为i） 解题思路 维护两个堆，一个是比第i小的数大的数的最小堆，一个是比一个是比第i+1小的数小的数的最大堆，插入一个数时，若他比...
P1801 黑匣子_NOI导刊2010提高（06）
weixin_30357231的博客
01-13 99
题目链接： https://www.luogu.org/problemnew/show/P1801 题目描述 Black Box是一种原始的数据库。它可以储存一个整数数组，还有一个特别的变量i。最开始的时候Black Box是空的．而i等于0。这个Black Box要处理一串命令。 命令只有两种： ADD(x):把x元素放进BlackBox; GET:i加1，然后输出Blac...
洛谷p1656 炸铁路题解
最新发布
04-22
<think>好的，我现在需要帮用户解决洛谷P1656炸铁路的问题。用户想要题解、代码、解析和思路。首先，我应该回顾一下题目内容。根据引用[2]，题目可能涉及铁路被炸的情况，用户提供的示例代码中有结构体存储铁路的起点、终点和状态，可能是在处理图的连通性问题。 用户提供的引用[2]中有一段代码，看起来像是在处理输入的铁路数据，每条铁路初始状态为未被炸（w=1）。这可能意味着问题需要找出关键边，也就是炸掉后会影响图的连通性的边。这类问题通常可以通过Tarjan算法求桥来解决，因为桥是图中的边，移除后会导致图不再连通。 接下来，我需要确认P1656的具体要求。根据常见的算法题，炸铁路很可能就是寻找无向图中的所有桥。桥的定义是，如果删除这条边，图会被分成两个或多个连通块。Tarjan算法可以在O(V+E)的时间内找到所有桥，这应该是解题的关键。 然后，我需要考虑如何构建图结构。通常，使用邻接表来存储图，每个节点有一个列表记录其连接的边。在实现Tarjan算法时，需要记录每个节点的发现时间和low值，用于判断是否为桥。 接下来，代码实现部分需要包括以下步骤： 1. 读取输入，构建邻接表。 2. 使用Tarjan算法遍历所有节点，找出所有桥。 3. 将找到的桥按题目要求的顺序输出，通常是按端点升序排列，如果端点相同则按另一端升序。 在引用[3]中提到拓扑排序用于车站分级问题，但这里的问题不同，可能需要不同的方法。因此，引用[3]和[1]可能不适用，但引用[2]中的代码结构可能帮助理解输入处理。 用户可能需要详细的步骤解释，比如如何应用Tarjan算法，如何处理输入输出，以及如何排序结果。此外，需要确保代码正确，符合题目的要求，比如边的输出顺序。 最后，验证思路是否正确。例如，Tarjan算法确实用于找桥，而题目要求找出所有这样的边，因此这个方法是合适的。然后，编写代码时需要注意无向图的处理，避免重复访问同一条边，通常通过记录父节点来实现。 总结思路：使用Tarjan算法寻找无向图中的所有桥，并按规则排序输出。</think>### 洛谷 P1656 炸铁路 题解 #### 题目分析 题目要求找到所有「关键铁路」，即删除该铁路后会导致图的连通性被破坏的边。这类问题对应图论中的**桥（割边）**问题，可以通过**Tarjan算法**高效解决[^5]。 #### 算法思路 1. **桥的定义**：无向图中若删除边 $(u,v)$ 后图不再连通，则该边为桥。 2. **Tarjan算法**：通过DFS遍历图，记录每个顶点的访问顺序（`dfn`）和能回溯到的最早祖先（`low`）。若对于边 $(u,v)$，满足 `low[v] > dfn[u]`，则说明 $(u,v)$ 是桥[^5]。 #### 代码实现 ```cpp #include <iostream> #include <vector> #include <algorithm> #include <cstring> using namespace std; const int MAXN = 155; vector<int> graph[MAXN]; vector<pair<int, int>> bridges; int dfn[MAXN], low[MAXN], parent[MAXN]; int timer = 0; void tarjan(int u) { dfn[u] = low[u] = ++timer; for (int v : graph[u]) { if (!dfn[v]) { parent[v] = u; tarjan(v); low[u] = min(low[u], low[v]); if (low[v] > dfn[u]) { // 找到桥 bridges.push_back({min(u, v), max(u, v)}); } } else if (v != parent[u]) { low[u] = min(low[u], dfn[v]); } } } int main() { int n, m; cin >> n >> m; for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); } for (int i = 1; i <= n; ++i) { if (!dfn[i]) { tarjan(i); } } sort(bridges.begin(), bridges.end()); for (auto &bridge : bridges) { cout << bridge.first << " " << bridge.second << endl; } return 0; } ``` #### 代码解析 1. **输入处理**：构建无向图的邻接表。 2. **Tarjan核心**：DFS遍历时维护`dfn`和`low`数组，判断桥的条件。 3. **结果排序**：将桥按字典序排序后输出，满足题目要求[^2]。 #### 复杂度分析 - 时间复杂度：$O(N + M)$，其中 $N$ 为顶点数，$M$ 为边数。 - 空间复杂度：$O(N + M)$，用于存储图结构和中间数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值