线 段 树

最新推荐文章于 2024-07-29 13:48:22 发布
最新推荐文章于 2024-07-29 13:48:22 发布
阅读量36 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65170489/article/details/126436342
版权

定义

线段树是以一段区间为节点的树。

设线段树的一个非叶子节点 k k k ， k k k 的儿子节点为 k < < 1 , k < < 1 ∣ 1 k<<1 ,k<<1|1 k<<1,k<<1∣1 。

若节点 k k k 表示的是区间 l l l 至 r r r ， 则节点 k < < 1 , k < < 1 ∣ 1 k<<1 ,k<<1|1 k<<1,k<<1∣1 分别表示的是区间 l l l 至 m i d mid mid 和 m i d + 1 mid+1 mid+1 至 r r r 。

m i d mid mid 为 ( l + r ) > > 1 (l+r)>>1 (l+r)>>1 。

叶子节点表示的是某一个点的值。

接下来以求动态区间的某一段的和为例。

建树

void build(ll k,ll l,ll r)
{
	if(l==r)//叶子节点
	{
		sum[k]=a[l];
		return;
	}
	else
	{
		int mid=(l+r)/2;//先求出儿子节点的的值，然后该区间的和为两个儿子节点的和
		build(k<<1,l,mid);
		build(k<<1|1,mid+1,r);
		sum[k]=sum[k<<1]+sum[k<<1|1];
	}
}

区间查询，单点修改

ll query(ll k,ll l,ll r,ll x,ll y)
{
	if(l>=x&&r<=y)
	{
		return sum[k];//节点k在查询的区间x至y内
	}
	ll mid=(l+r)/2;
	ll res=0;
	if(x<=mid)res+=query(k<<1,l,mid,x,y);//区间x至y与区间l至mid有交集
	if(y>mid)res+=query(k<<1|1,mid+1,r,x,y);//区间x至y与区间mid+1至r有交集
	return res;
}
void update(ll k,ll l,ll r,ll x,ll y)
{
	if(r<x||l>x)return;
	if(l==r&&l==x)
	{
		sum[x]=y;
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) update(k>>1,l,mid,x,y);//同理
	else if(x>mid) update(k>>1|1,mid+1,r,x,y);
	sum[k]=sum[k>>1]+sum[k>>1|1;
	return;
}

区间修改，区间查询（只含加减）

这里引入懒标记-- l a z y — t a g lazy\text{---}tag lazy—tag。

每一次修改先在包含节点 k k k 时，先打上标记，表示该区间加上某一个数值。

如果想要查询某一段区间的值时将懒标记下传至儿子节点。

每一次递归时都要下传懒标记。

inline void push_down(ll k,ll l,ll r,ll mid)
{
	//懒标记下传
	lazy_tag[k<<1]=lazy_tag[k<<1]+lazy_tag[k];
	sum[k<<1]=sum[k<<1]+lazy_tag[k]*(mid-l+1);
	lazy_tag[k<<1|1]=lazy_tag[k<<1|1]+lazy_tag[k];
	sum[k<<1|1]=sum[k<<1|1]+lazy_tag[k]*(r-(mid+1)+1);


	lazy_tag[k]=0;//懒标记变为0
}
void add(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)//完全包含
	{
		lazy_tag[k]+=ADD;//加入懒标记
		sum[k]+=(ADD*(r-l+1));//对节点k的值进行修改
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);//下传懒标记
		if(x<=mid)add(k<<1,l,mid,x,y,ADD);
		if(y>mid)add(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];//重新计算节点k的值
	}
}
ll query(ll k,ll l,ll r,ll x,ll y)
{
	if(l>=x&&r<=y)//完全包含则直接输出节点的值
	{
		return sum[k];
	}
	ll mid=(l+r)/2;
	ll res=0;
	push_down(k,l,r,mid);//下传懒标记
	if(x<=mid)res+=query(k<<1,l,mid,x,y);
	if(y>mid)res+=query(k<<1|1,mid+1,r,x,y);
	return res;
}

区间修改，区间查询（含乘法操作）

前提：求的是区间和对一个数字去模后的值。

加入两个懒标记 l a z y t a g 1 lazytag1 lazytag1 , l a z y t a g 2 lazytag2 lazytag2 。

l a z y t a g 2 lazytag2 lazytag2 的初始值为 1 1 1 。

l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] 表示对初始节点（标记下传后的节点 k k k ） 乘上 l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] 。

l a z y t a g 1 [ k ] lazytag1[k] lazytag1[k] 表示对初始节点（标记下传后的节点 k k k ） 乘上 l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] 后加上 l a z y t a g 1 [ k ] lazytag1[k] lazytag1[k] 。

标记下传时，儿子节点的值先乘上 l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] ，然后加上 l a z y t a g 1 [ k ] lazytag1[k] lazytag1[k] 。

儿子节点的 l a z y t a g 2 lazytag2 lazytag2 乘上 l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] 。

儿子节点的 l a z y t a g 1 lazytag1 lazytag1 乘上 l a z y t a g 2 [ k ] lazytag2[k] lazytag2[k] ，然后加上 l a z y t a g 1 [ k ] lazytag1[k] lazytag1[k] 。

注意，先乘后加！！！

inline void push_down(ll k,ll l,ll r,ll mid)
{
	sum[k<<1]=(sum[k<<1]*lazy_tag_cheng[k]+lazy_tag_jia[k]*(mid-l+1))%mod;
	sum[k<<1|1]=(sum[k<<1|1]*lazy_tag_cheng[k]+lazy_tag_jia[k]*(r-mid))%mod;
	lazy_tag_cheng[k<<1]=(lazy_tag_cheng[k<<1]*lazy_tag_cheng[k])%mod;
	lazy_tag_cheng[k<<1|1]=(lazy_tag_cheng[k<<1|1]*lazy_tag_cheng[k])%mod;
	lazy_tag_jia[k<<1]=(lazy_tag_jia[k<<1]*lazy_tag_cheng[k]+lazy_tag_jia[k])%mod;
	lazy_tag_jia[k<<1|1]=(lazy_tag_jia[k<<1|1]*lazy_tag_cheng[k]+lazy_tag_jia[k])%mod;
	lazy_tag_jia[k]=0;
	lazy_tag_cheng[k]=1;
}
void add_cheng(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)
	{
		sum[k]*=ADD;
		sum[k]%=mod;
		lazy_tag_cheng[k]=(lazy_tag_cheng[k]*ADD)%mod;
		lazy_tag_jia[k]=(lazy_tag_jia[k]*ADD)%mod;
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);
		if(x<=mid)add_cheng(k<<1,l,mid,x,y,ADD);
		if(y>mid)add_cheng(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];sum[k]%=mod;
	}
}
void add_jia(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)
	{
		lazy_tag_jia[k]=(lazy_tag_jia[k]+ADD)%mod;
		sum[k]+=(ADD*(r-l+1));
		sum[k]%=mod;
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);
		if(x<=mid)add_jia(k<<1,l,mid,x,y,ADD);
		if(y>mid)add_jia(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];
		sum[k]%=mod;
	}
}
ll query(ll k,ll l,ll r,ll x,ll y)
{
	if(l>=x&&r<=y)
	{
		return sum[k];
	}
	ll mid=(l+r)/2;
	ll res=0;
	push_down(k,l,r,mid);
	if(x<=mid)res+=query(k<<1,l,mid,x,y);
	if(y>mid)res+=query(k<<1|1,mid+1,r,x,y);
	return res%mod;
}

例题

P3372 【模板】线段树 1

#include<bits/stdc++.h>
using namespace std;
#define ll long long
unsigned ll n,m;
unsigned ll a[1000001];
unsigned ll sum[4000001];
unsigned ll lazy_tag[4000001];
void build(ll k,ll l,ll r)
{
	lazy_tag[k]=0;
	if(l==r)
	{
		sum[k]=a[l];
		return;
	}
	else
	{
		int mid=(l+r)/2;
		build(k<<1,l,mid);
		build(k<<1|1,mid+1,r);
		sum[k]=sum[k<<1]+sum[k<<1|1];
	}
}
inline void push_down(ll k,ll l,ll r,ll mid)
{
	lazy_tag[k<<1]=lazy_tag[k<<1]+lazy_tag[k];
	sum[k<<1]=sum[k<<1]+lazy_tag[k]*(mid-l+1);
	lazy_tag[k<<1|1]=lazy_tag[k<<1|1]+lazy_tag[k];
	sum[k<<1|1]=sum[k<<1|1]+lazy_tag[k]*(r-(mid+1)+1);
	lazy_tag[k]=0;
}
void add(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)
	{
		lazy_tag[k]+=ADD;
		sum[k]+=(ADD*(r-l+1));
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);
		if(x<=mid)add(k<<1,l,mid,x,y,ADD);
		if(y>mid)add(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];
	}
}
ll query(ll k,ll l,ll r,ll x,ll y)
{
	if(l>=x&&r<=y)
	{
		return sum[k];
	}
	ll mid=(l+r)/2;
	ll res=0;
	push_down(k,l,r,mid);
	if(x<=mid)res+=query(k<<1,l,mid,x,y);
	if(y>mid)res+=query(k<<1|1,mid+1,r,x,y);
	return res;
}
signed main()
{
	scanf("%lld%lld",&n,&m);
	for(ll i=1; i<=n; i++)
		scanf("%lld",&a[i]);
	build(1,1,n);
	for(ll i=1; i<=m; i++)
	{
		ll op,x,y;
		scanf("%lld%lld%lld",&op,&x,&y);
		if(op==2)
		{
			printf("%lld\n",query(1,1,n,x,y));
		}
		else
		{
			ll k;
			scanf("%lld",&k);
			add(1,1,n,x,y,k);
		}
	}
}

P3373 【模板】线段树 2

#include<bits/stdc++.h>
using namespace std;
#define ll long long
unsigned ll n,m;
unsigned ll a[1000001];
unsigned ll sum[4000001];
unsigned ll lazy_tag_cheng[4000001];
unsigned ll lazy_tag_jia[4000001],mod;
void build(ll k,ll l,ll r)
{
	lazy_tag_jia[k]=0;
	lazy_tag_cheng[k]=1;
	if(l==r)
	{
		sum[k]=a[l];
		sum[k]%=mod;
		return;
	}
	else
	{
		int mid=(l+r)/2;
		build(k<<1,l,mid);
		build(k<<1|1,mid+1,r);
		sum[k]=sum[k<<1]+sum[k<<1|1];
		sum[k]%=mod;
	}
}
inline void push_down(ll k,ll l,ll r,ll mid)
{
	sum[k<<1]=(sum[k<<1]*lazy_tag_cheng[k]+lazy_tag_jia[k]*(mid-l+1))%mod;
	sum[k<<1|1]=(sum[k<<1|1]*lazy_tag_cheng[k]+lazy_tag_jia[k]*(r-mid))%mod;
	lazy_tag_cheng[k<<1]=(lazy_tag_cheng[k<<1]*lazy_tag_cheng[k])%mod;
	lazy_tag_cheng[k<<1|1]=(lazy_tag_cheng[k<<1|1]*lazy_tag_cheng[k])%mod;
	lazy_tag_jia[k<<1]=(lazy_tag_jia[k<<1]*lazy_tag_cheng[k]+lazy_tag_jia[k])%mod;
	lazy_tag_jia[k<<1|1]=(lazy_tag_jia[k<<1|1]*lazy_tag_cheng[k]+lazy_tag_jia[k])%mod;
	lazy_tag_jia[k]=0;
	lazy_tag_cheng[k]=1;
}
void add_cheng(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)
	{
		sum[k]*=ADD;
		sum[k]%=mod;
		lazy_tag_cheng[k]=(lazy_tag_cheng[k]*ADD)%mod;
		lazy_tag_jia[k]=(lazy_tag_jia[k]*ADD)%mod;
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);
		if(x<=mid)add_cheng(k<<1,l,mid,x,y,ADD);
		if(y>mid)add_cheng(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];sum[k]%=mod;
	}
}
void add_jia(ll k,ll l,ll r,ll x,ll y,ll ADD)
{
	if(l>=x&&r<=y)
	{
		lazy_tag_jia[k]=(lazy_tag_jia[k]+ADD)%mod;
		sum[k]+=(ADD*(r-l+1));
		sum[k]%=mod;
		return;
	}
	else
	{
		ll mid=(l+r)>>1;
		push_down(k,l,r,mid);
		if(x<=mid)add_jia(k<<1,l,mid,x,y,ADD);
		if(y>mid)add_jia(k<<1|1,mid+1,r,x,y,ADD);
		sum[k]=sum[k<<1]+sum[k<<1|1];
		sum[k]%=mod;
	}
}
ll query(ll k,ll l,ll r,ll x,ll y)
{
	if(l>=x&&r<=y)
	{
		return sum[k];
	}
	ll mid=(l+r)/2;
	ll res=0;
	push_down(k,l,r,mid);
	if(x<=mid)res+=query(k<<1,l,mid,x,y);
	if(y>mid)res+=query(k<<1|1,mid+1,r,x,y);
	return res%mod;
}
signed main()
{
	scanf("%lld%lld%lld",&n,&m,&mod);
	for(ll i=1; i<=n; i++)
		scanf("%lld",&a[i]);
	build(1,1,n);
	for(ll i=1; i<=m; i++)
	{
		ll op,x,y;
		scanf("%lld%lld%lld",&op,&x,&y);
		if(op==3)
		{
			printf("%lld\n",query(1,1,n,x,y));
		}
		else
		if(op==1)
		{
			ll k;
			scanf("%lld",&k);
			add_cheng(1,1,n,x,y,k);
		}
		else
		if(op==2)
		{
			ll k;scanf("%lld",&k);
			add_jia(1,1,n,x,y,k);
		}
	}
}
dadidididi_kxj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线段求交
06-26
在提供的压缩包中，"红黑树"文件可能包含了用Delphi实现的红黑树数据结构代码，而"多线段求交"文件则可能是平面扫描算法的实现，包括了线段求交的逻辑和示例。通过结合这两个文件，我们可以构建一个完整的解决方案，...
轮廓线问题代码
05-19
通过阅读和理解这段代码，你可以更深入地了解如何用编程方法解决轮廓线问题，并可能为类似笔试题目的解答提供参考。 总结来说，城市轮廓线问题是一个涉及计算机图形学、数据结构和算法的综合性问题。通过使用优先...
扫描线（线段树）
Cauchy的博客
05-18 1795
文章目录扫描线扫描线求重叠矩形面积思路算法流程性质经典例题247. 亚特兰蒂斯 扫描线 线段树的一大应用是扫描线。 扫描线一个很经典的例题：在坐标轴上有若干个矩形，问他们覆盖的面积总和。 扫描线求重叠矩形面积 思路 使用一条垂直于X轴的直线，从左到右来扫描这个图形，明显，只有在碰到矩形的左边界或者右边界的时候，这个线段所扫描到的情况才会改变。 所以把所有矩形的入边，出边按 X 值排序。然后根据 X 值从小到大去处理。 用线段树来维护扫描到的情况，即每条线段映射到 Y 轴上进行区间维护。 算法流程
python+sklearn训练决策树分类模型（绘制学习曲线和验证曲线）
weixin_45081640的博客
06-21 3392
本文所用文件的链接 链接：https://pan.baidu.com/s/1RWNVHuXMQleOrEi5vig_bQ 提取码：p57s 关于决策树的初级应用，可以看我之前的文章： https://blog.csdn.net/weixin_45081640/article/details/118056630 决策树分类 决策树分类模型会找到与样本特征匹配的叶子节点然后以投票的方式进行分类. 在car.txt样本文件中统计小汽车的常见特征信息及小汽车的分类, 使用这些数据可以预测小汽车的等级. 案例: c
线段树练习题集
UncleJokerly
04-28 2259
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树 从入门到进阶（超清晰，简单易懂）
繁凡さん的博客
02-12 7万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 14万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
线段树详解
ling_wang的博客
08-12 7007
一.基本概念 1.线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 （严格来说：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点...
线段树，扫描线详解（非常详细）
不二君
07-28 4626
目录 一：综述 二：原理 (1)线段树的点修改： (2)线段树的区间查询： (3)线段树的区间修改： (4)线段树的存储结构： 三：递归实现 四：非递归原理 点修改： 点修改下的区间查询： 区间修改下的区间查询： 区间修改： 五：非递归实现 六：线段树解题模型 （1）：字符串哈希 （2）：最长连续零 （3）：计数排序 （4）总结： 七：扫描线 扫描线求重叠矩...
Linux设备树的概念
朝气蓬勃
01-19 6409
DTS 文件的主要功能就是按照图所示的结构来描述板子上的设备信息， DTS 文件描述设备信息是有相应的语法规则要求的，稍后我们会详细的讲解 DTS 语法规则。根节点下也有compatible属性，用来选择哪一个“machine desc”：一个内核可以支持machine A，也支持machine B，内核启动后会根据根节点的compatible属性找到对应的machine desc结构体，执行其中的初始化函数。一个单板启动时，u-boot先运行，它的作用是启动内核。但是在设备树里，它可以用来描述一段空间。
open3d八叉树：Octree
微小冷的学习笔记
10-02 3004
oc树是一种空间栅格化方法，其思路来自于二分法。以一维空间举例，就是对一条线段不断地二分，得到一系列的子线段，如果子线段中包含的元素大于2，那么就继续分割，直到所有子线段中至多只有一个元素为止。
python 递归树
kaituozhizzz的博客
05-01 2954
递归可以用来描述分形。分形常用来描述自然界中许多不规范的、真实对象的数字图形。 递归的图形还能说明递归是如何工作的。以递归绘制图树为例，绘制树枝的过程如下：首先绘制一条直线，然后左转，绘图（递归分支），右转，绘制（递归分支），最后返回原来的直线。 (31条消息) python Turtle Graphics海龟绘图工具_kaituozhizzz的博客-CSDN博客 前面有写到python中海龟绘图的使用 这里我们用海龟绘图制作一个递归树 上代码： from turtle import *.
决策树二元分类
03-22
决策树是一种广泛应用于数据分析和机器学习的算法，尤其在分类问题中表现出色。它通过构建一棵树状模型来实现对数据的分割，最终达到预测目标变量的目的。在本例的"决策树二元分类"中，我们将探讨如何利用决策树解决...
python使用turtle库绘制树
09-20
2. `drawLine(draw)`：这个函数根据参数`draw`的值来决定是否绘制一条线。如果`draw`为真，则turtle下笔并向前移动40个单位；如果为假，turtle提起笔，不绘制任何线条。 3. `drawDigit(d)`：这个函数根据输入的数字...
mintreek.rar_最小树
09-24
对于初学者来说，通过阅读和理解这段代码，可以深入理解最小树算法的工作原理，并学习如何在实际问题中应用。同时，由于这个算法对学校和工程实践都有帮助，说明它可以解决实际网络优化问题，比如设计最经济的电缆...
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3238
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
算法 —— 暴力枚举
fen_0108的博客
07-25 3834
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
2024.7.24 作业
qq_64434282的博客
07-24 2580
【代码】2024.7.24 作业。
嵌入式初学-C语言-七
最新发布
MaBaB的博客
07-29 525
分支结构 分支结构：又被称之为选择结构 概念 选择结构：根据条件成立与否，选择相应的操作。
扫描线与线段树在解决连续区间问题中的应用
线段树的定义是根据每个矩形纵向边的横坐标纵向地对平面进行2*n次切割、根据矩形横向边的纵坐标横向地对矩形进行2*n次切割（n为矩形个数），切割后得到的矩形的被切割后的小段边就是超元线段。现在我们仅考虑未被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值