Splay各种操作模板大赏

最新推荐文章于 2024-03-28 10:46:50 发布
最新推荐文章于 2024-03-28 10:46:50 发布
阅读量301 收藏 1
点赞数 1
分类专栏： 数据结构相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43973966/article/details/85859902
版权

  • Splay

          \ \ \ \ \ \ \ \,        依然的，只记录模板，不讲原理，关于Splay出门左拐百度。

  • 结构

struct Splay{
	#define lson son[0][rt]
	#define rson son[1][rt]
	int root,cnt;
	int son[2][N],sum[N],val[N],size[N],fa[N];
	int lazy[N];
}
  1. r o o t \tt root root ：根；
  2. c n t \tt cnt cnt ：下标大小；
  3. s o n [ 0 / 1 ] [ ] \tt son[0/1][] son[0/1][] ：左右儿子；
  4. s u m [ ] \tt sum[] sum[] ：子树大小；
  5. v a l [ ] \tt val[] val[] ：节点权值；
  6. s i z e [ ] \tt size[] size[] ：节点大小；
  7. f a [ ] \tt fa[] fa[] ：节点父亲；
  8. l a z y [ ] \tt lazy[] lazy[] ：下传标记。

  • 基本操作

  • 标记上传 ( p u s h u p pushup pushup)
void pushup(int rt){
	if(!rt)return;
	sum[rt]=sum[lson]+sum[rson]+size[rt];
}
  • 标记下传 ( p u s h d o w n pushdown pushdown)，根据情况会不一样
void pushdown(int rt){
  	if(!lazy[rt])return;
  	lazy[lson]^=1;lazy[rson]^=1;
  	lazy[rt]=0;
  	swap(lson,rson);
  }
  • 左旋+右旋 ( r o t a t e rotate rotate)
 void rotate(int x){
  	int y=fa[x];int z=fa[y];
  	int k=son[1][y]==x;
  	son[son[1][z]==y][z]=x;
  	fa[x]=z;
  	son[k][y]=son[k^1][x];
  	fa[son[k^1][x]]=y;
  	son[k^1][x]=y;
  	fa[y]=x;
	pushup(y);pushup(x);
}
  • 将 x x x旋转到 g o a l goal goal下 ( s p l a y splay splay)
void splay(int x,int goal){
  	while(fa[x]!=goal){
  		int y=fa[x];int z=fa[y];
  		if(z!=goal)
  		(son[1][z]==y)^(son[1][y]==x)?rotate(x):rotate(y);
  		rotate(x);
    }
    if(goal==0)root=x;
  }

  • 修改

  • 新建节点 ( n e w n o d e newnode newnode)

int newnode(int f,int v){
    int rt=++cnt;
    size[rt]=1;sum[rt]=1;val[rt]=v;
    fa[rt]=f;lson=rson=0;lazy[rt]=0;
    return rt;
}
  • 清空节点 ( c l e a n clean clean)
void clean(int rt){
    lson=rson=0;fa[rt]=0;
    val[rt]=0;sum[rt]=size[rt]=0;
}
  • 建立 ( B u i l d Build Build)
void Build(int &rt,int L,int R,int f){
  	if(L>R)return;
  	int mid=(L+R)>>1;
  	rt=newnode(f,a[mid]);
  	Build(lson,L,mid-1,rt);
  	Build(rson,mid+1,R,rt);
  	pushup(rt);
}
  • 插入( I n s e r t Insert Insert)
void Insert(int v){
    if(!root){root=newnode(0,v);return;}
    int now=root,rt=0;
    pushdown(now);
    while(1){
      if(val[now]==v){
  			++size[now];
        pushup(now);pushup(rt);
        splay(now,0);
        break;
      }
      rt=now;
      val[rt]<v?now=rson:now=lson;
    	pushdown(now);
      if(!now){
        now=newnode(rt,v);
  	    val[rt]<v?rson=now:lson=now;
        pushup(rt);splay(now,0);
        break;
      }
   }
}
  • 删除节点( d e l e t e _ p o s delete\_pos delete_pos)
void delete_pos(int rt){
    splay(rt,0);
    if(size[rt]>1){--size[rt];return;}
    int now;
    if(!lson||!rson){
      now=rson+lson;pushdown(now);
      if(!now){clean(rt);root=0;return;}
      clean(rt);root=now;fa[now]=0;
      pushup(now);return;
    }
    now=pre_pos(rt);
    pushdown(now);
    splay(now,rt);
    fa[now]=0;son[1][now]=rson;fa[rson]=now;
    root=now;clean(rt);
    pushup(rson);pushup(now);	
}
  • 删除( D e l e t e Delete Delete)
void Delete(int v){
    v=QueryRank_pos(v);
    pushdown(v);
    delete_pos(v);
}
  • 删除第k( D e l e t e _ Q u e r y R a n k Delete\_QueryRank Delete_QueryRank)
void Delete_QueryRank(int v){
    v=Rank_pos(v);
    pushdown(v);
    delete_pos(v);
}
  • 区间修改（翻转）( r e v s e revse revse)
void revse(int a,int b){
	a=find(a);
  	b=find(b+2);
  	splay(a,0);splay(b,a);
  	lazy[son[0][son[1][root]]]^=1;
}

  • 询问

  • 查找某个值的节点编号( Q u e r y R a n k _ p o s QueryRank\_pos QueryRank_pos)
int QueryRank_pos(int x){
    int rt=root;
    while(1){
    	pushdown(rt);
    	if(val[rt]==x){splay(rt,0);return rt;} 
    	if(val[rt]<x)rt=rson;
    	else if(val[rt]>x)rt=lson;
    }	
}
  • 查找某个排名的节点编号( R a n k _ p o s Rank\_pos Rank_pos)
  int Rank_pos(int x){
    int rt=root;
    while(1){
    	pushdown(rt);
    	if(sum[lson]>=x){rt=lson;continue;}
    	x-=sum[lson];
      	if(size[rt]>=x){splay(rt,0);return val[rt];}
      	x-=size[rt];
      	rt=rson;
    }	
  }
  • 查找排名第k的值( Q u e r y R a n k QueryRank QueryRank)
int QueryRank(int x){
    int rt=root;
    while(1){
    	pushdown(rt);
    	if(sum[lson]>=x){rt=lson;continue;}
    	x-=sum[lson];
    	if(size[rt]>=x){splay(rt,0);return val[rt];}
    	x-=size[rt];
    	rt=rson;
  }
}
  • 查找某个值的排名( R a n k Rank Rank)
int Rank(int num){
    int rt=root,ans=0;
    while(1){
    	pushdown(rt);
    	if(val[rt]==num){ans=ans+sum[lson]+1;splay(rt,0);return ans;}
    	if(val[rt]<num)ans+=sum[lson]+size[rt],rt=rson;
     	else if(val[rt]>num)rt=lson;
  	}
}
  • 集合内前驱的节点编号( p r e _ p o s pre\_pos pre_pos)
int pre_pos(int x){
    splay(x,0);int rt;
    pushdown(x);
    if(!(rt=son[0][x]))return val[x];
    while(rson)pushdown(rt),rt=rson;
    return rt;	
}
  • 集合内后继的节点编号( n e x _ p o s nex\_pos nex_pos)
int nex_pos(int x){
    splay(x,0);int rt;
    pushdown(x);
    if(!(rt=son[1][x]))return val[x];
    while(lson)pushdown(rt),rt=lson;
    return rt;	
}
  • 集合内前驱的值( p r e pre pre)
int pre(int x){
	splay(x,0);int rt;
    pushdown(x);
    if(!(rt=son[0][x]))return val[x];
    while(rson)pushdown(rt),rt=rson;
    return val[rt];
}
  • 集合内后继的值( n e x nex nex)
int nex(int x){
    splay(x,0);int rt;
    pushdown(x);
    if(!(rt=son[1][x]))return val[x];
    while(lson)pushdown(rt),rt=lson;
    return val[rt];
}
  • 前驱( N u m p r e Numpre Numpre)
int Numpre(int x){
    Insert(x);
    int y=x;x=QueryRank_pos(x);
    int ls=pre(x);
    Delete(y);
    return ls;
}
  • 后继( N u m n e x Numnex Numnex)
int Numnex(int x){
    Insert(x);
    int y=x;x=QueryRank_pos(x);
    int ls=nex(x);
    Delete(y);
    return ls;
}
  • 查找某个值的节点编号( f i n d find find)，不改变结构
int find(int k){
  	int rt=root;
  	while(1){
  		pushdown(rt);
  		if(sum[lson]>=k)rt=lson;
  		else if(sum[lson]+1==k)return rt;
  		else k-=sum[lson]+1,rt=rson;
    }
 }

  • 完整模板

const int N=1e5+10;
int a[N],n,m;
struct Splay{
	#define lson son[0][rt]
	#define rson son[1][rt]
	int root,cnt;
	int son[2][N],sum[N],val[N],size[N],fa[N];
  	bool lazy[N];
	void pushdown(int rt){
  		if(!lazy[rt])return;
  		lazy[lson]^=1;lazy[rson]^=1;
  		lazy[rt]=0;
  		swap(lson,rson);
  	}
	void pushup(int rt){
	  	if(!rt)return;
	  	sum[rt]=sum[lson]+sum[rson]+size[rt];
	}
  	void rotate(int x){
	  	int y=fa[x];int z=fa[y];
	  	int k=son[1][y]==x;
	  	son[son[1][z]==y][z]=x;
	  	fa[x]=z;
	  	son[k][y]=son[k^1][x];
	  	fa[son[k^1][x]]=y;
	  	son[k^1][x]=y;
	  	fa[y]=x;
	  	pushup(y);pushup(x);
	}
  	void splay(int x,int goal){
	  	while(fa[x]!=goal){
	  		int y=fa[x];int z=fa[y];
	  		if(z!=goal)
	  		(son[1][z]==y)^(son[1][y]==x)?rotate(x):rotate(y);
	  		rotate(x);
	    }
	    if(goal==0)root=x;
  	}
  	int newnode(int f,int v){
	    int rt=++cnt;
	    size[rt]=1;sum[rt]=1;val[rt]=v;
	    fa[rt]=f;lson=rson=0;lazy[rt]=0;
	    return rt;
		}
		void clean(int rt){
	    lson=rson=0;fa[rt]=0;
	    val[rt]=0;sum[rt]=size[rt]=0;
  	}
	void Build(int &rt,int L,int R,int f){
	  	if(L>R)return;
	  	int mid=(L+R)>>1;
	  	rt=newnode(f,a[mid]);
	  	Build(lson,L,mid-1,rt);
	  	Build(rson,mid+1,R,rt);
	  	pushup(rt);
	}
  	void Insert(int v){
    	if(!root){root=newnode(0,v);return;}
    	int now=root,rt=0;
    	pushdown(now);
   		while(1){
      		if(val[now]==v){
	  			++size[now];
	        	pushup(now);pushup(rt);
	        	splay(now,0);
	        	break;
	      	}
	      	rt=now;
	      	val[rt]<v?now=rson:now=lson;
	    	pushdown(now);
	      	if(!now){
	        	now=newnode(rt,v);
	  	    	val[rt]<v?rson=now:lson=now;
	        	pushup(rt);splay(now,0);
	        	break;
	      	}
   	 	}
  	}
  	int QueryRank_pos(int x){
    	int rt=root;
    	while(1){
    		pushdown(rt);
      		if(val[rt]==x){splay(rt,0);return rt;} 
      		if(val[rt]<x)rt=rson;
      		else if(val[rt]>x)rt=lson;
    	}	
  }
  int Rank_pos(int x){
    int rt=root;
    while(1){
    	pushdown(rt);
      if(sum[lson]>=x){rt=lson;continue;}
      x-=sum[lson];
      if(size[rt]>=x){splay(rt,0);return val[rt];}
      x-=size[rt];
      rt=rson;
    }	
  }
  	int QueryRank(int x){
    	int rt=root;
    	while(1){
    		pushdown(rt);
     		if(sum[lson]>=x){rt=lson;continue;}
     		x-=sum[lson];
      		if(size[rt]>=x){splay(rt,0);return val[rt];}
      		x-=size[rt];
      		rt=rson;
    	}
  	}
  	int Rank(int num){
    	int rt=root,ans=0;
    	while(1){
    		pushdown(rt);
      		if(val[rt]==num){ans=ans+sum[lson]+1;splay(rt,0);return ans;}
     		if(val[rt]<num)ans+=sum[lson]+size[rt],rt=rson;
      		else if(val[rt]>num)rt=lson;
    	}
  	}
  	int pre_pos(int x){
    	splay(x,0);int rt;
    	pushdown(x);
    	if(!(rt=son[0][x]))return val[x];
    	while(rson)pushdown(rt),rt=rson;
    	return rt;	
  	}
  	int nex_pos(int x){
    	splay(x,0);int rt;
    	pushdown(x);
    	if(!(rt=son[1][x]))return val[x];
    	while(lson)pushdown(rt),rt=lson;
    	return rt;	
  	}
  	int pre(int x){
    	splay(x,0);int rt;
    	pushdown(x);
    	if(!(rt=son[0][x]))return val[x];
    	while(rson)pushdown(rt),rt=rson;
    	return val[rt];
  	}
  	int nex(int x){
    	splay(x,0);int rt;
    	pushdown(x);
    	if(!(rt=son[1][x]))return val[x];
    	while(lson)pushdown(rt),rt=lson;
    	return val[rt];
  	}
  	void delete_pos(int rt){
    	splay(rt,0);
    	if(size[rt]>1){--size[rt];return;}
    	int now;
    	if(!lson||!rson){
      		now=rson+lson;pushdown(now);
      		if(!now){clean(rt);root=0;return;}
      		clean(rt);root=now;fa[now]=0;
      		pushup(now);return;
    	}
    	now=pre_pos(rt);
    	pushdown(now);
    	splay(now,rt);
    	fa[now]=0;son[1][now]=rson;fa[rson]=now;
    	root=now;clean(rt);
    	pushup(rson);pushup(now);	
  	}
  	void Delete(int v){
    	v=QueryRank_pos(v);
    	pushdown(v);
    	delete_pos(v);
  	}
  	void Delete_QueryRank(int v){
    	v=Rank_pos(v);
    	pushdown(v);
    	delete_pos(v);
  	}
  	int Numpre(int x){
    	Insert(x);
    	int y=x;x=QueryRank_pos(x);
    	int ls=pre(x);
    	Delete(y);
    	return ls;
  	}
  	int Numnex(int x){
    	Insert(x);
    	int y=x;x=QueryRank_pos(x);
    	int ls=nex(x);
    	Delete(y);
    	return ls;
  	}
  	int find(int k){
  		int rt=root;
  		while(1){
  			pushdown(rt);
  			if(sum[lson]>=k)rt=lson;
  			else if(sum[lson]+1==k)return rt;
  			else k-=sum[lson]+1,rt=rson;
    	}
  	}
	void revse(int a,int b){
		a=find(a);
  		b=find(b+2);
  		splay(a,0);splay(b,a);
  		lazy[son[0][son[1][root]]]^=1;
	}
}Spl;

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<set>
using namespace std;
const int inf=0x7fffffff;
const double eps=1e-10;
const double pi=acos(-1.0);
//char buf[1<<15],*S=buf,*T=buf;
//char getch(){return S==T&&(T=(S=buf)+fread(buf,1,1<<15,stdin),S==T)?0:*S++;}
inline int read(){
	int x=0,f=1;char ch;ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-') f=0;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch&15);ch=getchar();}
	if(f)return x;else return -x;
}
const int N=1e5+10;
int a[N],n,m;
struct Splay{
	
}Spl;
int main()
{
  	int n=read();
  	while(n--){
    	int opt=read(),x=read();
    	if(opt==1){Spl.Insert(x);continue;}
    	if(opt==2){Spl.Delete(x);continue;}
    	if(opt==3){printf("%d\n",Spl.Rank(x));continue;}
    	if(opt==4){printf("%d\n",Spl.QueryRank(x));continue;}
    	if(opt==5){printf("%d\n",Spl.Numpre(x));continue;}
    	if(opt==6){printf("%d\n",Spl.Numnex(x));continue;}
  	}
  	return 0;
}

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<set>
using namespace std;
const int inf=0x7fffffff;
const double eps=1e-10;
const double pi=acos(-1.0);
//char buf[1<<15],*S=buf,*T=buf;
//char getch(){return S==T&&(T=(S=buf)+fread(buf,1,1<<15,stdin),S==T)?0:*S++;}
inline int read(){
	int x=0,f=1;char ch;ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-') f=0;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch&15);ch=getchar();}
	if(f)return x;else return -x;
}
const int N=1e5+10;
int a[N],n,m;
struct Splay{
	
}Spl;
void write(int rt){
  	Spl.pushdown(rt);
  	if(Spl.lson)write(Spl.lson);
  	if(Spl.val[rt]>1&&Spl.val[rt]<n+2)
  	printf("%d ",Spl.val[rt]-1);
  	if(Spl.rson)write(Spl.rson); 
}
int main()
{
	n=read();m=read();
 	for(int i=1;i<=n+2;i++)a[i]=i;
 	Spl.Build(Spl.root,1,n+2,0);
 	while(m--){
    	int l=read(),r=read();
  		Spl.revse(l,r);
  	}
  	write(Spl.root);
  	printf("\n");
	return 0;
}
周道-Althen
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【模板】Splay
lsy_41的博客
03-10 253
Splay
Splay伸展树结构体模板
01-06
Splay结构体的模板，含有各种旋转、插入、翻转等操作，注释清晰
[学习笔记] 伸展树splay详解+全套模板+例题[Luogu P3369 【模板】普通平衡树]
01-10 1224
这比较死板了，纯粹就是代码对应原理
P3369 【模板】普通平衡树（splay 算法）
最新发布
zhi6fui的博客
03-28 708
比如：x右旋，x的右儿子为y,这时原本的x的右儿子就要当y的左儿子。第一行为 n，表示操作的个数,下面 n 行每行有两个数 opt 和 x，opt 表示操作的序号（1≤opt≤6）我们找到它的前驱和后继，再进行把删除的点移到其后继的左儿子上，再进行删除操作。我们自己构造平衡二叉树，左儿子节点小于父节点，右儿子的全部节点大于父节点。而且x为y的左儿子，x的任意一个儿子一定小于其x的父节点。当直线型时，先旋转它的父节点，在旋转它自己本身。在遍历它的左儿子的右儿子。右旋时：x的右儿子当作y的左儿子。
Splay树【模板】
hwy0622的博客
04-15 95
Splay树
splay模板（功能最全）
huzujun的博客
08-03 3720
回想起来splay大概是高中时的噩梦吧，手敲splay的确挑战太大了，不过到了acm时期，其实应该是不用惧怕splay的，把板子准备好就问题不大。 poj3580 虽然不是最简单的题，但是可以作为板子题 https://vjudge.net/problem/POJ-3580 题目大意： 要求实现一种数据结构，支持对一个数字序列的 6 种操作： ADD x y val：第 x...
splay 模板
09-05
splay经典代码,hdu1890,经典入门题,可作为模板
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
Splay说明论文
01-31
讲解Splay的经典论文 -------- Randomized Splay Trees: Theoretical and Experimental Results Susanne Albers Marek Karpinski
splayer源码
05-15
Tomasen-splayer-acb19a1c6d4d.zipTomasen-splayer-acb19a1c6d4d.zipTomasen-splayer-acb19a1c6d4d.zipTomasen-splayer-
SPLAY① 入门
lcy19260817的博客
05-08 320
splay详解引入splay的构建基础操作建树getrotatesplayinsertkthdeletefindpresuc注意事项splay应用 引入 splay是一种BST，可以维护静态区间k小 也可以当作区间树，维护区间信息（ 求和，最大子段和，翻转区间，等等） 时间一般O(nlogn)（均摊），splay操作满足其稳定性 但是常数巨大，接近100，慎用 splay的构建 一个完整的spla...
图解splay / splay模板 / p3369
m0_54646258的博客
07-05 299
splay 解决了平衡树中的很多问题， 用图的方式将 splay 算法展示出来
关于splay的删除操作
qq_41510496的博客
02-27 691
splay的删除操作我是手动模拟模拟了之后才理解的。操作代码：lson=getmax(ls);（ls为要删除数的左二子，rs为右儿子，lson为ls的最大儿子）swap(lson,ls),fa[lson]=0,splay(ls),rc[ls]=rs,fa[rs]=ls,update(ls);//这段就是把lson移到了root，这时root的右儿子就是要删除数，因为lson是小于要删除数的最大数。...
splay总结
Greninja的博客
06-13 547
伸展树（Splay Tree）总结
Splay Tree的删除操作
靖空间
05-31 3428
Splay Tree的插入操作，搜索操作，和删除操作都实现了，那么就可以使用来解题了。 指针的删除操作的处理还是那么难的，很多坎需要避开. 同一个坎还是坑了我好多次，就是指针传递的问题，什么时候需要修改指针本身的值，就必须返回指针或者传递指针的指针，或者传递指针的的实参。 这里的删除操作就是需要改变传递到函数的指针本身的，所以我这里使用了返回指针操作。 还有删除树的问题，之前的代码没做删除
【平衡二叉树】宠物收养所
void* ptr = &OI;
04-19 844
Description 最近，阿Q开了一间宠物收养所。收养所提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。每个领养者都希望领养到自己满意的宠物，阿Q根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养所的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养所总是会有两种情况发生：被
splay树/区间树实用模板（查删、数排名、排名数、前驱后继、区间翻转）/转载：线段树套Splay树
平凡人Kalzn的博客
08-29 407
模板链接 splay树比较全面的一个板子，并进行压缩优化代码，比较实用。 后期再更新一个文艺平衡树就差不多了？？？ 下面是模板代码： #include <iostream> #include <cstring> #include <string> #include <vector> #include <algorithm> #includ...
Splay操作总结
_zidaoziyan的博客
08-26 2280
Splay中有一些常用的操作和一些很容易犯的bug先来记录一下容易写错的地方 新建结点(或者连续一段)或者删除结点(或者连续一段)的时候需要pushup(ch[root][1]),pushup(root) 申请一个新的结点的时候注意更新与这个点所有相关的变量,比如是维护最小值,不仅要更新val[now],还要更新minv[now] 如果有区间加的时候,你需要查询Splay上某个点的值,你不能直接输出
Splay时间复杂度
09-13
Splay树是一种自平衡二叉搜索树，其时间复杂度取决于具体的操作。以下是Splay树常见操作的时间复杂度： 1. 插入（Insertion）：在平均情况下，Splay树的插入操作的时间复杂度为O(log n)，其中n是树中节点的数量。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值