【高级数据结构】线段树

已于 2024-06-10 23:28:50 修改
阅读量552 收藏
点赞数
文章标签： 数据结构 算法 c++ 学习
于 2023-07-27 20:34:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73896521/article/details/131968060
版权

目录

树状数组1（单点修改，区间查询）

树状数组2（区间修改，单点查询）

线段树1（区间修改，区间查询）

代码源线段树1（查询最小值出现次数）

 代码源线段树2（最大字段和）

动态开点

树状数组1（单点修改，区间查询）

题目链接：  https://www.luogu.com.cn/problem/P3374

代码：

// Problem: P3374 【模板】树状数组 1
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3374
// Memory Limit: 512 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 5e5+5;

int n,q;
int a[N];

struct node{
	ll t,val,sz,l,r;
}seg[N*4];


void update(int id){
	seg[id].val=seg[id*2].val+seg[id*2+1].val;
}

void settag(int id,ll t){
	seg[id].t=seg[id].t+t;
	seg[id].val=seg[id].val+seg[id].sz*t;
}

void pushdown(int id){
	if(seg[id].t!=0){  
		settag(id*2,seg[id].t);
		settag(id*2+1,seg[id].t);
		seg[id].t=0;
	}
}

void build(int id,int l,int r){
	seg[id].sz=r-l+1;
	if(l==r){
		seg[id].val={a[l]};
	}
	else{
		int mid=(l+r)/2;
		build(id*2,l,mid);
		build(id*2+1,mid+1,r);
		update(id);
	}
}

void change(int id,int l,int r,int pos,ll val){
	if(l==r){
		seg[id].val=seg[id].val+val;
		return;
	}
	int mid=(l+r)/2;
	if(pos<=mid){
		change(id*2,l,mid,pos,val);
	}
	else if(pos>mid){
		change(id*2+1,mid+1,r,pos,val);
	}
	update(id);
}

ll query(int id,int l,int r,int ql,int qr){
	if(ql==l&&qr==r){
		return seg[id].val;
	}
	int mid=(l+r)/2;
	pushdown(id);
	if(qr<=mid){
		return query(id*2,l,mid,ql,qr);
	}
	else if(ql>mid){
		return query(id*2+1,mid+1,r,ql,qr);
	}
	else{
		return query(id*2,l,mid,ql,mid)+query(id*2+1,mid+1,r,mid+1,qr);
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>q;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,1,n);
	for(int i=0;i<q;i++){
		int ty;
		cin>>ty;
		if(ty==1){
			int x,d;
			cin>>x>>d;
			change(1,1,n,x,d);
		}
		else{
			int l,r;
			cin>>l>>r;
			cout<<query(1,1,n,l,r)<<"\n";
		}
	}

	
	return 0;	

}

树状数组2（区间修改，单点查询）

 题目链接：  https://www.luogu.com.cn/problem/P3368

代码：

// Problem: P3372 【模板】线段树 1
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3372
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 5e5+5;

int n,q;
int a[N];

struct node{
	ll t,val,sz,l,r;
}seg[N*4];


void update(int id){
	seg[id].val=seg[id*2].val+seg[id*2+1].val;
}

void settag(int id,ll t){
	seg[id].t=seg[id].t+t;
	seg[id].val=seg[id].val+seg[id].sz*t;
}

void pushdown(int id){
	if(seg[id].t!=0){  
		settag(id*2,seg[id].t);
		settag(id*2+1,seg[id].t);
		seg[id].t=0;
	}
}

void build(int id,int l,int r){
	seg[id].sz=r-l+1;
	if(l==r){
		seg[id].val={a[l]};
	}
	else{
		int mid=(l+r)/2;
		build(id*2,l,mid);
		build(id*2+1,mid+1,r);
		update(id);
	}
}

void modify(int id,int l,int r,int ql,int qr,ll t){
	if(l==ql&&r==qr){
		settag(id,t);
		return;
	}
	int mid=(l+r)/2;
	pushdown(id);
	if(qr<=mid){
		modify(id*2,l,mid,ql,qr,t);
	}
	else if(ql>mid){
		modify(id*2+1,mid+1,r,ql,qr,t);
	}
	else{
		modify(id*2,l,mid,ql,mid,t);
		modify(id*2+1,mid+1,r,mid+1,qr,t);
	}
	update(id);
}

ll query(int id,int l,int r,int pos){
	if(r==l){
		return seg[id].val;
	}
	int mid=(l+r)/2;
	pushdown(id);
	if(pos<=mid){
		return query(id*2,l,mid,pos);
	}
	else if(pos>mid){
		return query(id*2+1,mid+1,r,pos);
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>q;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,1,n);
	for(int i=0;i<q;i++){
		int ty;
		cin>>ty;
		if(ty==1){
			int l,r,d;
			cin>>l>>r>>d;
			modify(1,1,n,l,r,d);
		}
		else{
			int x;
			cin>>x;
			cout<<query(1,1,n,x)<<"\n";
		}
	}

	
	return 0;	

}

线段树1（区间修改，区间查询）

题目链接：  https://www.luogu.com.cn/problem/P3372

代码：

// Problem: P3372 【模板】线段树 1
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3372
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 2e5+5;

int n,q;
int a[N];

struct node{
	ll t,val,sz;
}seg[N*4];


void update(int id){
	seg[id].val=seg[id*2].val+seg[id*2+1].val;
}

void settag(int id,ll t){
	seg[id].t=seg[id].t+t;
	seg[id].val=seg[id].val+seg[id].sz*t;
}

void pushdown(int id){
	if(seg[id].t!=0){  
		settag(id*2,seg[id].t);
		settag(id*2+1,seg[id].t);
		seg[id].t=0;
	}
}

void build(int id,int l,int r){
	seg[id].sz=r-l+1;
	if(l==r){
		seg[id].val={a[l]};
	}
	else{
		int mid=(l+r)/2;
		build(id*2,l,mid);
		build(id*2+1,mid+1,r);
		update(id);
	}
}

void modify(int id,int l,int r,int ql,int qr,ll t){
	if(l==ql&&r==qr){
		settag(id,t);
		return;
	}
	int mid=(l+r)/2;
	pushdown(id);
	if(qr<=mid){
		modify(id*2,l,mid,ql,qr,t);
	}
	else if(ql>mid){
		modify(id*2+1,mid+1,r,ql,qr,t);
	}
	else{
		modify(id*2,l,mid,ql,mid,t);
		modify(id*2+1,mid+1,r,mid+1,qr,t);
	}
	update(id);
}

ll query(int id,int l,int r,int ql,int qr){
	if(l==ql&&r==qr){
		return seg[id].val;
	}
	int mid=(l+r)/2;
	pushdown(id);
	if(qr<=mid){
		return query(id*2,l,mid,ql,qr);
	}
	else if(ql>mid){
		return query(id*2+1,mid+1,r,ql,qr);
	}
	else{
		return query(id*2,l,mid,ql,mid)+query(id*2+1,mid+1,r,mid+1,qr);
	}
}

int main(){
	cin>>n>>q;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,1,n);
	for(int i=0;i<q;i++){
		int ty;
		cin>>ty;
		if(ty==1){
			int l,r,d;
			cin>>l>>r>>d;
			modify(1,1,n,l,r,d);
		}
		else{
			int l,r;
			cin>>l>>r;
			cout<<query(1,1,n,l,r)<<"\n";
		}
	}

	
	return 0;	

}

代码源线段树1（查询最小值出现次数）

题目链接：  http://oj.daimayuan.top/course/15/problem/654

代码：

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 2e5+5;
const int inf = 0x3f3f3f3f;

int n,q;
int a[N];

struct info{
	
};

info operator +(const info &l,const info &r){
	info a;
	a.minv=min(l.minv,r.minv);
	if(l.minv==r.minv){
		a.mincnt=l.mincnt+r.mincnt;
	}
	else if(l.minv<r.minv){
		a.mincnt=l.mincnt;
	}
	else{
		a.mincnt=r.mincnt;
	}
	return a;
}

struct node{
	info val;
}seg[N*4];

void update(int id){
	seg[id].val=seg[id*2].val+seg[id*2+1].val;
}

void build(int id,int l,int r){
	if(l==r){
		seg[id].val={a[l],1};
	}
	else{
		int mid=(l+r)/2;
		build(id*2,l,mid);
		build(id*2+1,mid+1,r);
		update(id);
	}
}

void change(int id,int l,int r,int pos,int val){
	if(l==r){
		seg[id].val={val,1};
		//a[pos]=val;
	}
	else{
		int mid=(l+r)/2;
		if(pos<=mid){
			change(id*2,l,mid,pos,val);
		}
		else{
			change(id*2+1,mid+1,r,pos,val);
		}
		update(id);
	}
}

info query(int id,int l,int r,int ql,int qr){
	if(l==ql&&r==qr){
		return seg[id].val;
	}
	int mid=(l+r)/2;
	if(qr<=mid){
		return query(id*2,l,mid,ql,qr);
	}
	else if(ql>mid){
		return query(id*2+1,mid+1,r,ql,qr);
	}
	else{
		return query(id*2,l,mid,ql,mid)+query(id*2+1,mid+1,r,mid+1,qr);
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	cin>>n>>q;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,1,n);
	for(int i=0;i<q;i++){
		int ty;
		cin>>ty;
		if(ty==1){
			int x,d;
			cin>>x>>d;
			change(1,1,n,x,d);
		}
		else{
			int l,r;
			cin>>l>>r;
			auto ans=query(1,1,n,l,r);
			cout<<ans.minv<<' '<<ans.mincnt<<"\n";
		}
	}
	
	
	
	return 0;	

}

 代码源线段树2（最大字段和）

题目链接： 

目录

树状数组1（单点修改，区间查询）

树状数组2（区间修改，单点查询）

线段树1（区间修改，区间查询）

代码源线段树1（查询最小值出现次数）

 代码源线段树2（最大字段和）

代码：

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 2e5+5;
const int inf = 0x3f3f3f3f;

int n,q;
int a[N];

struct info{
	ll mss,mpre,msuf,s;
	info(){}
	info(int a):mss(a),mpre(a),msuf(a),s(a){}
};

info operator +(const info &l,const info &r){
	info a;
	a.mss=max({l.mss,r.mss,l.msuf+r.mpre});
	a.mpre=max(l.mpre,l.s+r.mpre);
	a.msuf=max(r.msuf,r.s+l.msuf);
	a.s=l.s+r.s;
	return a;
}

struct node{
	info val;
}seg[N*4];

void update(int id){
	seg[id].val=seg[id*2].val+seg[id*2+1].val;
}

void build(int id,int l,int r){
	if(l==r){
		seg[id].val=info(a[l]);
	}
	else{
		int mid=(l+r)/2;
		build(id*2,l,mid);
		build(id*2+1,mid+1,r);
		update(id);
	}
}

void change(int id,int l,int r,int pos,int val){
	if(l==r){
		seg[id].val=info(val);
		//a[pos]=val;
	}
	else{
		int mid=(l+r)/2;
		if(pos<=mid){
			change(id*2,l,mid,pos,val);
		}
		else{
			change(id*2+1,mid+1,r,pos,val);
		}
		update(id);
	}
}

info query(int id,int l,int r,int ql,int qr){
	if(l==ql&&r==qr){
		return seg[id].val;
	}
	int mid=(l+r)/2;
	if(qr<=mid){
		return query(id*2,l,mid,ql,qr);
	}
	else if(ql>mid){
		return query(id*2+1,mid+1,r,ql,qr);
	}
	else{
		return query(id*2,l,mid,ql,mid)+query(id*2+1,mid+1,r,mid+1,qr);
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	cin>>n>>q;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,1,n);
	for(int i=0;i<q;i++){
		int ty;
		cin>>ty;
		if(ty==1){
			int x,d;
			cin>>x>>d;
			change(1,1,n,x,d);
		}
		else{
			int l,r;
			cin>>l>>r;
			auto ans=query(1,1,n,l,r);
			cout<<ans.mss<<"\n";
		}
	}
	
	
	
	return 0;	

}

动态开点

https://www.luogu.com.cn/problem/P2781

#include<cstdio>//动态开点线段树是一类特殊的线段树，与普通的线段树不同的是，每一个节点的左右儿子不是该点编号的两倍和两倍加一，而是现加出来的
#include<iostream>//https://blog.csdn.net/u012972031/article/details/88751811 https://www.cnblogs.com/szbszb/p/11243728.html
#include<cstring>

#define int long long

using namespace std;
const int N=1e7+10;
struct node {
	int ls,rs,lazy;//左儿子地址，右儿子地址，延迟标记
	long long sum;//区间和
} tr[N*4];
int root=0,cnt=0;//根据insert代码(11行),root从1开始
void init() {
	memset(tr,0,sizeof(tr));
	root=0,cnt=0;
}
void insert(int &root,int l,int r,int ll,int rr,int x) { //建树&&区间修改 root区间范围[l,r],修改范围[ll,rr]，修改增量x root是人为规定的编号，涉及修改，传引用 
	if(!root)root=++cnt;//root还没开，开点
	int len=min(r,rr)-max(l,ll)+1;//b为修改区间在当前区间的长度 例如真子集[1,N],修改[10,20],b=20-10+1=11 或者交集[50,100],修改[30,70],b=70-50+1 =21
	if(len<0)	return;//或者空集[50,100]修改[10,20] b=20-50+1 =-29 <0
	tr[root].sum+=len*x;
	if(l>=ll&&r<=rr) { //真子集
		tr[root].lazy+=x;
		return;
	}
	int mid=l+r>>1;
	if(ll<=mid)insert(tr[root].ls,l,mid,ll,rr,x);
	if(rr>mid)insert(tr[root].rs,mid+1,r,ll,rr,x);
}
int query(int root,int l,int r,int ll,int rr) {//区间查询,在范围为[l,r]的root中查询[ll,rr]的区间和
	if(l>=ll&&r<=rr)return tr[root].sum;//真子集
	int mid=l+r>>1;
	if(tr[root].lazy) {//下放延迟标记
		if(!tr[root].ls)	tr[root].ls=++cnt;
		tr[tr[root].ls].lazy+=tr[root].lazy;
		tr[tr[root].ls].sum+=tr[root].lazy*(mid-l+1);
		if(!tr[root].rs)	tr[root].rs=++cnt;
		tr[tr[root].rs].lazy+=tr[root].lazy;
		tr[tr[root].rs].sum+=tr[root].lazy*(r-mid);
		tr[root].lazy=0;
	}
	long long ans=0;
	if(ll<=mid)	ans+=query(tr[root].ls,l,mid,ll,rr);
	if(rr>mid)	ans+=query(tr[root].rs,mid+1,r,ll,rr);
	return ans;
}
signed main() {
	ios::sync_with_stdio(false);
	int n,m;
	cin>>n>>m;
	// for(int i=1; i<=n; i++) {
		// int temp;
		// cin>>temp;
		// insert(root,1,n,i,i,temp);
	// }
	for(int i=1; i<=m; i++) {
		int ta,tb,tc,td;
		cin>>ta>>tb>>tc;
		if(ta==1) {
			cin>>td;
			insert(root,1,n,tb,tc,td);
		} else if(ta==2) {
			cout<<query(root,1,n,tb,tc)<<endl;
		}
	}
	return 0;
}

萌新好菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode 高级数据结构 线段树
Robin_812656252的博客
09-02 153
基本概念 一种平衡二叉搜索树（满二叉树）。他将一个线段区间划分为一些单元区间，对于线段树中的每一个非叶子节点[a,b]，他的左儿子表示的区间为[a, (a+b)/2]，右儿子表示的区间为[(a+b)/2 + 1, b]. ...
【c++提高1】数据结构之线段树详解
小学生蒟蒻
09-09 1785
线段树的思想是将一个区间[1, n]划分成两个区间： [1, n/2]和[n/2+1, n]，接下来继续划分： [1, n/4], [n/4+1,n/2]和[n/2+1, n/2+n/4-1], [n/2+n/4,n] …示例：n = 81.pushup函数2.pushdown3.build4.modify5.query1.线段树的儿子存储2.线段树的节点信息存储 定义一个结构体，里面存储改节点信息和当前这个节点所管辖的区间的左右端点。1.建树函数build 递归建树。 怎样判断当前节点是叶子节点呢？2.查
高级数据结构 线段树
zhanghanqmx的博客
09-08 90
线段树 #include<stdio.h> #pragma warning (disabled:4996) #include<malloc.h> //链表实现 typedef struct Node { int Left,Right; struct Node *LChild,*RChild; long sum; }SegNode,*SegTree; //结构数组 typedef struct Node { int Left,Right,Mid; }SegNode; //线段树
高级数据结构线段树和树状数组的应用
zhou_145的博客
04-28 86
麻麻子，最近debug了很久，才理解这个思路，还是很实用的，原理上是简单的递归，但是和前缀树的更新不同的是，在维护线段树的时候，时间复杂度为logn，而前缀树是n，但前缀树在查询是是O（1），线段树为logn，线段树适用于经常改变数组范围的情形。
高级数据结构之线段树
Sy_LeeChan的博客
06-05 251
高级数据结构之线段树 1.前缀和 ​ 给定一个数组arr，数组可能非常大。在程序运行过程中，你可能要做好几次query和update操作： query(arr, L, R) 表示计算数组arr中，从下标L到下标R之间的所有数字的和。 update(arr, i, val) 表示要把arr[i]中的数字改成val。 怎样尽可能快地完成一系列query和update的操作？ ​ 如果是前缀和，则只是优化了query的时间复杂度为 O（1），而update的操作仍然是O（n），一位更新了某个值，区间的pres
高级数据结构(线段树)
weixin_43808717的博客
03-01 675
线段树概念 线段树类似于区间树，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。线段树是建立在线段的基础上，每个结点都代表了一条线段[a,b],通熟一点就是一个节点代表一个区间，如果左右端点值...
高级数据结构：线段树
xylitolz的博客
04-17 396
文章目录为什么要使用线段树？什么是线段树（SegmentTree）？创建线段树线段树的查询线段树中的更新操作More线段树相关问题Reference 为什么要使用线段树？ 对于有一类问题，我们关心的是线段（或者区间） 最经典的线段树问题：区间染色 有一面墙，长度为nnn，每次选择一段墙进行染色，mmm次操作后，可以看见多少种颜色？mmm次操作后，可以在区间[i,j][i,j][i,j]内看见多少种颜色？ 使用数组实现 染色操作（更新区间） O(n)O(n)O(n) 查询操作（查询区
C++ 线段树 高级数据结构
weixin_44208324的博客
03-30 194
线段树是一种平衡二叉搜索树(完全二叉树)，它将一个线段区间划分成一些单元区间。对于线段树中的每一个非叶子节点[a,b]，他的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]，最后的叶子节点数目为N，与数组下标对应。线段树的一般包括建立、查询、插入、更新等操作，建立规模为N的时间复杂度是O(NlogN)，其他操作时间复杂度为O(logN)。 平衡二叉搜索树(完全...
高级数据结构：线段树入门（c++实现 + 详解）
ylh的博客
01-27 4233
线段树是一种高级数据结构，与树状数组一样，被用来处理区间查询，修改问题，并且线段树的最大优点是对动态数据的处理十分高效。关于树状数组，可以看我这篇博文的介绍： 高级数据结构：树状数组详解来看看线段树能处理的问题：线段树是具有以下形态的二叉树，其中树上的每个节点都是一个线段区间 。看图可以发现线段树的几个特征：这颗二叉树是采用分治法来划分区间，并且构建子树的，左右子树各一半。这颗二叉树的每个节点都是一个线段区间，非叶子节点的线段区间是一段不相等的区间，叶子节点的线段区间的只包含一个元素。这颗二叉树是一颗完全二
高级数据结构——线段树
Martisum的博客
08-16 323
听作者讲骚话 今天是很沉重的一天，进来CCF官宣取消OI，也不知道是不是真的。 OIer们不要放弃梦想！大家一定要勇往直前！ 这线段树会很难…至少我是这么想的…不过我也是经过百般实验才敢写这个博客！ 线段树我要你何用？ 假定我给你一个定区间，让你以最快的速度做这样的操作：修改其中的一个子区间，查询另一个子区间的值，而且重复这些操作。你会说：for循环。没错，这复杂度是O(N)线段树可以说是区间神器...
线段树高级数据结构实现
05-26
### 线段树高级数据结构实现：点更新 #### 一、线段树简介 线段树是一种高效的数据结构，常用于处理区间查询或区间更新的问题。它将一个线性序列分割成多个部分，每个节点代表一个区间的统计信息（如最大值、...
高级数据结构（刘汝佳
12-08
总而言之，高级数据结构的研究涉及多个层面，从基本的二叉搜索树到更复杂的AVL树和伸展树，再到专门用于区间查询和更新的线段树和树状数组，以及RMQ与LCA这类高效查询算法，都是构建高效算法和解决复杂问题的关键...
高级数据结构c++
08-26
在“高级数据结构c++”这个主题中，我们将会探讨一些高级的数据结构及其C++实现，包括线段树、Splay树、LCT（Link-Cut Tree）、后缀数组和后缀自动机以及树链剖分。这些数据结构和算法在解决复杂问题时具有强大的...
MIT 6.851 高级数据结构讲义
02-01
### MIT 6.851 高级数据结构讲义知识点概述 #### 一、时间数据结构 **1.1 概述** 时间数据结构主要关注如何高效地处理随时间变化的数据。这类数据结构通常涉及对历史版本的访问以及如何在不破坏原有数据的情况下...
数据结构之并查集
我要学编程的博客
08-21 1175
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
数据结构-时间、空间复杂度-详解
最新发布
2401_86587256的博客
08-23 1008
数据结构-时间、空间复杂度-详解
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 894
完全二叉堆：批量建堆
Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
2301_80689220的博客
08-21 223
【代码】Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值