C++ 线段树

最新推荐文章于 2025-02-21 20:27:49 发布
最新推荐文章于 2025-02-21 20:27:49 发布
阅读量3.9k 收藏 77
点赞数 19
分类专栏： 线段树 题解 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/struct_GS/article/details/120716586
版权

目录：

线段树基本常识

线段树的的存储

线段树的基本操作

1. 建树

2. 单点查询

3. 单点修改

4. 区间查询

5. 区间修改

例题推荐：

线段树 1

线段树 2

线段树基本常识

        线段树是一种二叉搜索树（即每个节点最多有两颗子树），与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

        如下图，就是一颗 [1，10] 的线段树的分解过程：

        由图可得出一个结论，线段树的最大深度不超过 log_{2} n ，且每一颗线段树需要 4*n 的辅助空间，如果没有开到 4*n ，那就完美 RE 了！！！

线段树的的存储

        线段树采用的是堆式储存法，即编号为 k 的节点的做儿子为 k*2、右儿子为 k*2+1、父亲节点为k/2；二进制运算优化就是 k<<1，k<<1|1，k>>1。

        通常来说，每个节点会存储：区间左边界、区间右边界、答案及其有关信息。

线段树的基本操作

1. 建树

        采用递归遍历整棵树，每次将区间分为左右两个区间，对与叶子接点直接赋值，非叶子节点由左右子树合并。

inline  void build(int k,int l,int r)//k为当前节点，[l,r]为当前区间
{ 
	if(l==r)//到达叶子节点，记录节点信息
    {
        sum[k]=a[l];
        return;//记得返回
    }
	int mid=(l+r)>>1;
	build(k*2,l,mid);//左右分别建树
	build(k*2+1,mid+1,r);
	sum[k]=sum[k*2]+sum[k*2+1];//合并区间信息
	return;
}

2. 单点查询

        采用类似二分的思想，将现区间 [ l，r ] 分为左右两个区间 [ l，mid ]、[ mid+1，r ] ，判断查找的位置 x 是在左区间还是在右区间，继续递归，如到达叶子节点，则直接返回节点信息。 

inline int find(int k,int l,int r,int x)//k为当前节点位置，[l,r]为当前区间，x为目标节点
{
	if(l==r) return sum[k];//找到目标节点，返回节点信息
	int mid=(l+r)>>1;
	if(x<=mid) return find(k*2,l,mid,x);//查询位置在左子树
	else  return find(k*2+1,mid+1,r,x);//查询位置在右子树
}

3. 单点修改

        类似于单点查询，找到目标位置，直接进行修改，最后合并区间信息

inline void change(int k,int l,int r,int x)//k为当前节点位置，[l,r]为当前区间，x为目标节点
{
	if(l==r)//找到目标节点，进行修改
	{
		sum[k]+=x;//这里是区间累加
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) change(k*2,l,mid,x);//所查询位置在左子树
	else change(k*2+1,mid+1,r,x);//所查询位置在右子树
	sum[k]=sum[k*2]+sum[k*2+1];//合并区间信息
	return;
}

4. 区间查询

        目标区间 [ x，y ] ，当前区间 [ l ，r ] ，如果当前区间被目标区间包含，则直接返回区间信息，否则按照将当前区间分为左右两个区间进行查找的思想继续递归查询，最后所有返回区间的并集就是目标区间的答案。

inline int find(int k,int l,int r,int x,int y)//k为当前节点位置，[l,r]为当前区间，[x,y]为目标区间
{
	if(x<=l&&r<=y) return sum[k];//当前区间被目标区间所包含，直接返回区间信息
	int mid=(l+r)>>1;
	int res=0;//用于左右子树区间值的累加
	if(x<=mid) res+=find(k*2,l,mid,x,y);//查询左子树
	if(y>mid) res+=find(k*2+1,mid+1,r,x,y);//查询右子树
	return res;//返回值
}

5. 区间修改

        如单点查询和单点修改一样，区间修改也是区间查询的一个延续，但不同的是，若修改区间内全部的节点信息，复杂度将会非常大，你也会迎来线段树的第一个 TLE ，于是，便有大佬按耐不住了，给我们引入了 “ 懒标记 ” 这一神奇函数。

        懒标记：若遍历到带有懒标记的节点，则立刻修改当前节点的值，并将标记下放到左右子树（这一过程被称为：标记下放），但左右子树的信息不发生改变，只有去遍历左右子树的时候，才修改其信息。

        懒标记大大提高了程序的运行效率，其核心思想就是：只修改对查询有用的节点。

inline void Add(int k,int l,int r,int v)//修改区间值
{
	add[k]+=v;//懒标记也要加v
	sum[k]+=v*(r-l+1);//区间值等于原值加上区间内数的个数乘上修改值
	return;
}
inline void pushdown(int k,int l,int r)//标记下方
{
	if(!add[k]) return;//判断是否带有懒标记
	int mid=(l+r)>>1;
	Add(k*2,l,mid,add[k]);//左子树修改同时下方标记
	Add(k*2+1,mid+1,r,add[k]);//右子树修改同时下方标记
	add[k]=0;//标记清空
	return;
}
inline int find(int k,int l,int r,int x,int y)//带懒标记的区间查询
{
	if(x<=l&&r<=y) return sum[k];
	int mid=(l+r)>>1;
	int res=0;
	pushdown(k,l,r);
	if(x<=mid) res+=find(k*2,l,mid,x,y);
	if(y>mid) res+=find(k*2+1,mid+1,r,x,y);
	return res;
}
inline void change(int k,int l,int r,int x,int y,int v)//k为当前节点位置，[l,r]为当前区间，[x,y]为目标区间
{
	if(x<=l&&r<=y)//当前区间被包含于目标区间
	{
		Add(k,l,r,v);//修改区间值
		return;
	}
	pushdown(k,l,r);//标记下方
	int mid=(l+r)>>1;
	if(x<=mid) change(k*2,l,mid,x,y,v);//左子树修改
	if(y>mid) change(k*2+1,mid+1,r,x,y,v);//右子树修改
	sum[k]=sum[k*2]+sum[k*2+1];//合并区间信息
	return;
}

奉上完整代码（无注释）：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
using namespace std;
inline int read()
{
    int num=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') {if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {num=(num<<1)+(num<<3)+ch-'0';ch=getchar();}
    return num*w;
}
int n;
int a[4000001];
int sum[4000001];
int add[4000001];
inline  void build(int k,int l,int r)
{ 
	if(l==r)
    {
        sum[k]=a[l];
        return;
    }
	int mid=(l+r)>>1;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	sum[k]=sum[k*2]+sum[k*2+1];
	return;
}
inline int find_spot(int k,int l,int r,int x)
{
	if(l==r) return sum[k];
	int mid=(l+r)>>1;
	if(x<=mid) return find_spot(k*2,l,mid,x);
	else  return find_spot(k*2+1,mid+1,r,x);
} 
inline void change_spot(int k,int l,int r,int x)
{
	if(l==r) 
	{
		sum[k]+=x;
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) change_spot(k*2,l,mid,x);
	else change_spot(k*2+1,mid+1,r,x);
	sum[k]=sum[k*2]+sum[k*2+1];
	return;
}
inline void Add(int k,int l,int r,int v)
{
	add[k]+=v;
	sum[k]+=v*(r-l+1);
	return;
}
inline void pushdown(int k,int l,int r)
{
	if(!add[k]) return;
	int mid=(l+r)>>1;
	Add(k*2,l,mid,add[k]);
	Add(k*2+1,mid+1,r,add[k]);
	add[k]=0;
	return;
}
inline int find_section(int k,int l,int r,int x,int y)
{
	if(x<=l&&r<=y) return sum[k];
	int mid=(l+r)>>1;
	int res=0;
	pushdown(k,l,r);
	if(x<=mid) res+=find_section(k*2,l,mid,x,y);
	if(y>mid) res+=find_section(k*2+1,mid+1,r,x,y);
	return res;
}
inline void change_section(int k,int l,int r,int x,int y,int v)
{
	if(x<=l&&r<=y)
	{
		Add(k,l,r,v);
		return;
	}
	pushdown(k,l,r);
	int mid=(l+r)>>1;
	if(x<=mid) change_section(k*2,l,mid,x,y,v);
	if(y>mid) change_section(k*2+1,mid+1,r,x,y,v);
	sum[k]=sum[k*2]+sum[k*2+1];
	return;
}
int main()
{
	//freopen(".in","r",stdin);
	//freopen(".out","w",stdout);
	
	//一些奇奇怪怪的初始化、读入、输出、离散化…… 
	
	//fclose(stdin);
	//fclose(stdout);		
	return 0;
}

例题推荐：

P3372 【模板】线段树 1

P3373 【模板】线段树 2

线段树 1

        模板题，区间修改 + 区间查询 即可完美解决：

【代码实现】

#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
int n,q,k,a,b,w,add[4000010],s[1000010];
long long sum[4000010];
void Add(int k,int l,int r,int v)
{
	add[k]+=v;
	sum[k]+=(long long)(r-l+1)*(long long)v; 
}
void down(int k,int l,int r,int mid)
{
	if(!add[k])return;
	Add(k*2,l,mid,add[k]);
	Add(k*2+1,mid+1,r,add[k]);
	add[k]=0;
}
void change(int k,int l,int r,int x,int y,int v)
{
	if(l>=x&&r<=y)
	{
		Add(k,l,r,v);
		return;
	}
	int mid=(l+r)/2;
	down(k,l,r,mid);
	if(x<=mid)
	{
		change(k*2,l,mid,x,y,v);
	}
	if(y>mid)
	{
		change(k*2+1,mid+1,r,x,y,v);
	}
	sum[k]=sum[k*2]+sum[k*2+1];
}

long long query(int k,int l,int r,int x,int y,int v)
{
	if(l>=x&&r<=y)
	{
		return sum[k];
	}	
	int mid=(l+r)/2;
	long long res=0;
	down(k,l,r,mid);
	if(x<=mid)
	{
		res+=query(k*2,l,mid,x,y,v);
	}
	if(y>mid)
	{
		res+=query(k*2+1,mid+1,r,x,y,v);
	}
	return res;
}

void build(int k,int l,int r)
{
	if(l==r)
	{
		sum[k]=s[l];
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	sum[k]=sum[k*2]+sum[k*2+1];
}
int main()
{
	scanf("%d%d",&n,&q);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&s[i]);
	}
	build(1,1,n);
	for(int i=1;i<=q;i++)
	{
		scanf("%d",&k);
		if(k==1)
		{
			scanf("%d%d%d",&a,&b,&w);
			change(1,1,n,a,b,w);
		}
		if(k==2)
		{
			scanf("%d%d",&a,&b);
			printf("%lld\n",query(1,1,n,a,b,w));
		}
	}
	return 0;
}

线段树 2

        在 区间修改 + 区间查询的基础上，对懒标记进行亿点点的改动即可：

【代码实现】

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int n,p,m;
long long a[500001];
struct node
{
	long long sum;
	long long mul;//*
	long long pule;//+
}tree[500001];
int add(int k)
{
	tree[k].sum=tree[k*2].sum+tree[k*2+1].sum;
	tree[k].sum%=p;
}
void gs(int k,int l,int r)
{
	int k1=k*2;
	int k2=k*2+1;
	int mid=(l+r)/2;
	tree[k1].sum*=tree[k].mul;
	tree[k1].sum%=p;
	tree[k1].sum+=tree[k].pule*(mid-l+1);
	tree[k1].sum%=p;
	tree[k2].sum*=tree[k].mul;
	tree[k2].sum%=p;
	tree[k2].sum+=tree[k].pule*(r-mid);
	tree[k2].sum%=p;
	tree[k1].mul*=tree[k].mul;
	tree[k1].mul%=p;
	tree[k2].mul*=tree[k].mul;
	tree[k2].mul%=p;
	tree[k1].pule*=tree[k].mul;
	tree[k1].pule%=p;
	tree[k1].pule+=tree[k].pule;
	tree[k1].pule%=p;
	tree[k2].pule*=tree[k].mul;
	tree[k2].pule%=p;
	tree[k2].pule+=tree[k].pule;
	tree[k2].pule%=p;
	tree[k].pule=0;
	tree[k].mul=1;
	return;
}
void build(int k,int l,int r)
{
	tree[k].pule=0;
	tree[k].mul=1;
	if(l==r)
	{
		tree[k].sum=a[l];
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	add(k);
}
void change_pule(int k,int l,int r,int x,int y,long long w)
{
	if(y<l||x>r)
	{
		return;
	}
	if(x<=l&&r<=y)
	{
		tree[k].pule+=w;
		tree[k].pule%=p;
		tree[k].sum+=w*(r-l+1);
		tree[k].sum%=p;
		return;
	}
	int mid=(l+r)/2;
	gs(k,l,r);
	change_pule(k*2,l,mid,x,y,w);
	change_pule(k*2+1,mid+1,r,x,y,w);
	add(k);
}
void change_mul(int k,int l,int r,int x,int y,long long w)
{
	
	if(y<l||x>r)
	{
		return;
	}
	if(x<=l&&r<=y)
	{
		tree[k].sum*=w;
		tree[k].sum%=p;
		tree[k].mul*=w;
		tree[k].mul%=p;
		tree[k].pule*=w;
		tree[k].pule%=p;
		return;
	}
	int mid=(l+r)/2;
	gs(k,l,r);
	change_mul(k*2,l,mid,x,y,w);
	change_mul(k*2+1,mid+1,r,x,y,w);
	add(k);
}
long long find(int k,int l,int r,int x,int y)
{
	if(x>r||y<l)
	{
		return 0;
	}
	if(x<=l&&r<=y)
	{
		return tree[k].sum;
	}
	int mid=(l+r)/2;
	gs(k,l,r);
	long long r1,r2;
	r1=find(k*2,l,mid,x,y);
	r2=find(k*2+1,mid+1,r,x,y);
	return (r1+r2)%p;
}
int main()
{
	scanf("%d%d%d",&n,&m,&p);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld",&a[i]);
	}
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int k;
		scanf("%d",&k);
		if(k==1)
		{
			int t,g;
			long long c;
			scanf("%d%d%lld",&t,&g,&c);
			change_mul(1,1,n,t,g,c);
		}
		if(k==2)
		{
			int t,g;
			long long c;
			scanf("%d%d%lld",&t,&g,&c);
			change_pule(1,1,n,t,g,c);
		}
		if(k==3)
		{
			int t,g;
			scanf("%d%d",&t,&g);
			printf("%lld\n",find(1,1,n,t,g));
		}
	}
	return 0;
}

c++线段树
aoligei132的博客
07-09 290
如题，已知一个数列，你需要进行下面两种操作：第一行包含两个整数 n,mn, mn,m，分别表示该数列数字的个数和操作的总个数。第二行包含 nnn 个用空格分隔的整数，其中第 iii 个数字表示数列第 iii 项的初始值。接下来 mmm 行每行包含 333 或 444 个整数，表示一个操作，具体如下：输出包含若干行整数，即为所有操作 2 的结果。 样例输出 #1 提示 对于 30%30\%30% 的数据：n≤8n \le 8n≤8，m≤10m \le 10m≤10。 对于 70%70\%70% 的数据：n≤
c++线段树求逆序对
aoligei132的博客
07-05 185
(https://www.luogu.com.cn/problem/P1908)猫猫 TOM 和小老鼠 JERRY 最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。最近，TOM 老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中 ai>aja_i>a_jai​>aj​ 且 i...
线段树初步（C++）
11-18
讲解线段树基本应用，适合初学者下载使用！
【C++】线段树
cout0
12-08 1459
简介 线段树是一种特殊的数据结构，他适用于进行区间RMQ问题。线段树的逻辑结构是一颗二叉树，叶子节点统计的是端点信息，而其余父节点统计的是所有子结点的信息，父结点也就构成了一个个统计区间，这些区间就像是线段，线段树因此得名。 首先，线段树是一颗平衡二叉树，因此搜索效率极高。通常，线段树是一颗普通的平衡二叉树，这种二叉树实现较为复杂，如下图所示： （图片来自网络，侵删） zkw大佬在《统计的力量》PPT中介绍了一种更易于实现的线段树，这种线段树一般也被称为zkw线段树。zkw线段树是一颗满二叉树，可以直接
线段树（C++）
追梦丶
09-15 2212
线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。   开原数组4倍大的空间 区间查询：询问某段区间的某些性质（极值，求和，etc） ...
【线段树 C++】
qq_44763629的博客
01-20 1150
线段树 C++ C++实现线段树 对于一给定的数组a，若要计算「长度为n的连续元素和：a[i+1] + …+a[i+n] 」时间复杂度为O(n)；若要修改某一位上的元素值，时间复杂度为O(1)。 若创建一个新数组b记录「前n位的累加和」，则查询「给定长度的元素和：a[i+1] + …+a[i+n] = b[i+n] - b[i]」的时间复杂度为O(1);修改某一位的元素值的时间复杂度变为O(n)。 当需要频繁进行两种操作时，时间开销较大。因此我们希望有一个平均时间复杂度较低的算法/数据结构来实现。 事实上
线段树详解（C++）
m0_54615144的博客
08-11 1237
应用场景 假设有这样的问题：有n个数，m次操作，操作分为：修改某一个数或者查询一段区间的值 分析下，如果针对数组元素的修改可以是O(1)完成，求某个区间值需要O(n)才可以完成，如果m和n都很大的情况，这个复杂度就很难接受了。 我们之前学过的前缀和算法可以解决区间求和的问题，并且时间复杂度是O(1)，但如果涉及到修改操作，前缀和数组都需要重新计算，时间复杂度也是O(n) 有没有什么办法可以兼顾以上两种操作，并且可以将时间复杂度降低？ 这就是我们要学习的线段树！把修改和查询的时间复杂度都降到O(log
c++线段树例题亚特兰蒂斯
07-06
有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。 其中一些甚至包括岛屿部分地图。 但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。 您的朋友 Bill 必须知道地图的总面积。...你自告奋勇写了一个计算这个...
C++ 线段树模板（求和），100%正确性
03-01
C++ 线段树模板（求和），100%正确性，希望可以多多支持，本博客还有题解等内容，欢迎观看，给予评价，若有建议可以私信！！！
算法——线段树C/C++
2401_86771711的博客
09-03 2637
首先，我们需要定义线段树的节点结构体，通常包含区间的起始和结束位置，以及该区间的汇总信息。// 假设存储的是和。
c++ 线段树
KonjakuLAF的博客
05-09 323
关于线段树 线段数是一种区间树 可以看出：叶子即为输入的数 假设一个节点为 x ，则其左儿子为 2x 右儿子为 2x+1 操作解析 约定 变量名 意义 input[] 输入的数 t[] 线段树 其中 t[] 是个结构体，包含左边界 l ，右边界 r 和区间和 sum sum 并不是必须有的，这些维护的值需要根据题目要求增多、减少 基本操作 卡常必备 左儿子与右儿子#def...
XOR的艺术 洛谷P2574 线段树
DaoCaoRen___的博客
01-10 2028
题目描述 AKN 觉得第一题太水了，不屑于写第一题，所以他又玩起了新的游戏。在游戏中，他发现，这个游戏的伤害计算有一个规律，规律如下 拥有一个伤害串，是一个长度为nn的只含字符0和字符1的字符串。规定这个字符串的首字符是第一个字符，即下标从11开始。 给定一个范围[l,~r][l,r]，伤害为伤害串的这个范围内中字符1的个数 会修改伤害串中的数值，修改的方法是把[l,~r][l,r]中所有原来的字符0变成1，将1变成0。 AKN 想知...
线段树(C/C++)
2301_77710891的博客
04-28 422
用数组的方式表示树结构其实就是树的静态存储方式，它受限于数组的大小，需要提前确定好数组的大小，而节点链式存储是树的动态存储，其存储大小不受限，当然静态存储时以牺牲空间来换取时间的方法。如果我们有很多数据保存在一个数组中，而我们要对这个数组进行一些操作，那么使用传统的循环来控制的话，时间复杂度太大，特别是一些算法题很容易超时，这时候线段树可以帮我们解决，将复杂度降为nlog(n)，在此说明：线段树的应用通常是一些区间求和，区间修改，区间最大值、最小值等操作。进行区间修改时，采用lazy标记，传递修改信息。
c++ 数据结构之 线段树
hanzhen7541的博客
02-17 2002
线段树是一种数据结构，是一种二叉树。线段树将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。线段树对于区间求和等区间操作能够实现复杂度为O(logn)的操作，故得以广泛利用。修改一个值的操作也是O(logn)。 线段树是建立在线段基础上，每个结点都代表了一条线段[a,b]。长度为1的线段称为元线段。非元线段都有两个子结点，左结点代表的线段为[a,...
线段树【C++实现】
qq_46496417的博客
03-15 565
线段树是一种基于分治的数据结构，用来进行快速的区间查询、单点修改操作；线段树中每个结点都用于存储一段区间相关的信息（如区间和、区间最值等）；
线段树【C语言】【C++】
最新发布
The_cute_cat的博客
02-21 991
简单介绍线段树，以及实现代码。
线段树学习
shuimu12345678的专栏
06-26 1505
HH神的线段树出神入化，所以跟着HH学习线段树。 风格： maxn是题目给的最大区间，而节点数要开4倍，确切的说…… lson和rson辨别表示结点的左孩子和右孩子。 PushUp(int rt)是把当前结点的信息更新到父节点 PushDown（int rt)是把当前结点的信息更新给孩子结点。 rt表示当前子树的根（root），也就是当前所在的结点。 思想： 对于每个非叶节
线段树入门
Tizzi的博客
08-24 423
一、引入 有一类区间问题可以抽象成如下模型。 给定包含 n个数的数组 a1,a2,⋯an​。有两种操作 查询区间 [l,r] 最小的数。 修改第 ai为 x。 这里，为了解决这个问题，我们介绍一种灵活的数据结构——线段树。 我们用一棵二叉树来表示线段树，线段树中的每个结点都表示一个区间。每个非叶子结点都有左右两棵子树，分别对应区间的 “左半” 和 “右半”。为了方便起见，我们给根结点编号为 1...
C++线段树动态区间修改原理及代码实现
标题《C++ 动态区间修改线段树详细讲解+代码demo》表明本文内容将聚焦于C++编程语言中一种数据结构——线段树（Segment Tree）的高级用法，尤其是针对动态区间修改的优化方法，并提供相应的代码示例。线段树是一种...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值