树链剖分解析

最新推荐文章于 2024-10-01 23:10:03 发布
最新推荐文章于 2024-10-01 23:10:03 发布
阅读量126 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoyun198769/article/details/114950988
版权
树链剖分是一种优化树形结构查询的技术，它将树分解为重链和轻链，使得从任意节点到根节点的路径上最多经过log2(n)条轻链。本文介绍了树链剖分的基本概念，如重儿子、轻儿子、重链和轻链，并展示了如何进行预处理。通过两个dfs过程，确定节点的父亲、重儿子、链顶等信息。此外，还提供了C++代码实现树链剖分求最近公共祖先（LCA），以及如何结合线段树解决涉及树上边权值的操作问题。
摘要由CSDN通过智能技术生成

前置知识
线段树 andand 树上基本操作

定义
几个在树链剖分很重要的概念。

重儿子
对于一个父节点，含有节点数最多的儿子称为重儿子。但重儿子只有一个，若满足条件的儿子有多个，则指定其中任意一个儿子为重儿子。

轻儿子
对于一个父节点，除了重儿子以为，其余的都称为轻儿子。

重边
由父节点与重儿子构成的边。

轻边
由父节点与轻儿子构成的边。

重链
由重边构成的链。

轻链
由轻边构成的链。

链顶
重链中深度最小的边为该重链的链顶。

上述几个概念具体如下图：

在这里插入图片描述
其中，黄色点为重儿子，蓝色点为轻儿子（ 11 除外）。黄色边为重边，蓝色边为轻边。通常，一个单独的点也看为一条重链，那么重链有 55 条：

{1,2,6,7}{1,2,6,7} ，（ 11 为链顶）
{5}{5} ，（ 55 为链顶）
{3}{3} ，（ 33 为链顶）
{4,8}{4,8} ，（ 44 为链顶）
{9}{9} ，（ 99 为链顶）
对于任意一棵树有如下性质：从任意一点到根节点的简单路径上，共有不超过 log2(n)log2(n) 条轻链，有不超过 log2(n)log2(n) 条轻链。

预处理
预处理需要使用到两个 dfsdfs 。

dfs1dfs1 需要处理：

fa[i]fa[i] ： ii 节点的父亲。
son[i]son[i] ： ii 节点的重儿子。
sz[i]sz[i] ：以 ii 为根节点的子树的大小，可以进一步处理 son[i]son[i] 。
dep[i]dep[i] ： ii 节点的深度。
dfs2dfs2 需要处理：

dfn[i]dfn[i] ： ii 节点的时间戳，但优先遍历重儿子。显然，在一条重链中，时间戳为一段连续的数字。
tp[i]tp[i] ： ii 节点的链顶。
C++代码
void dfs1(int now, int father) {
fa[now] = father;//初始化父节点
sz[now] = 1;//子树大小包括自己
dep[now] = dep[father] + 1;//初始化深度
int SIZ = v[now].size();
int maxn = 0;//记录最大的子树大小
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(next == father)
continue;
dfs1(next, now);//遍历这棵树
sz[now] += sz[next];
if(maxn < sz[next]) {//更新子节点
maxn = sz[next];
son[now] = next;
}
}
}
void dfs2(int now, int Top) {
tp[now] = Top;//初始化链顶
if(son[now])
dfs2(son[now], Top);//优先遍历重儿子
int SIZ = v[now].size();
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(next == fa[now] || next == son[now])
continue;
dfs2(next, next);//继续遍历这棵树
}
}
树链剖分求LCA
测验链接。

在线查询一棵树上任意两点的 LCALCA 。

分两种情况向上爬即可（需要保证 dep[tp[x]]<=dep[tp[y]]dep[tp[x]]<=dep[tp[y]]）：

tp[x]!=tp[y]tp[x]!=tp[y] ，即不在一条重链上。需要 xx 向上爬出这条重链，向上继续寻找能与 yy 汇合的重链点。x=fa[tp[x]]x=fa[tp[x]]。
tp[x]!=tp[y]tp[x]!=tp[y] ，即在一条重链上，那么深度小的就位最近公共祖先。
正确性显然，以为两条重链不会交于同一个点。

C++代码
#include
#include
using namespace std;
const int MAXN = 5e5 + 5;
vector v[MAXN];//vector存图
int fa[MAXN], son[MAXN], tp[MAXN], sz[MAXN], dep[MAXN];
int n, m, s;
void dfs1(int now, int father) {//初始化如上
fa[now] = father;
sz[now] = 1;
dep[now] = dep[father] + 1;
int SIZ = v[now].size();
int maxn = 0;
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(next == father)
continue;
dfs1(next, now);
sz[now] += sz[next];
if(maxn < sz[next]) {
maxn = sz[next];
son[now] = next;
}
}
}
void dfs2(int now, int Top) {//初始化如上
tp[now] = Top;
if(son[now])
dfs2(son[now], Top);
int SIZ = v[now].size();
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(next == fa[now] || next == son[now])
continue;
dfs2(next, next);
}
}
int Get_LCA(int x, int y) {
while(tp[x] != tp[y]) {
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
x = fa[tp[x]];
}
if(x == y)
return x;
if(dep[x] < dep[y])
return x;
return y;
}
int main() {
int A, B;
scanf("%d %d %d", &n, &m, &s);
for(int i = 1; i < n; i++) {
scanf("%d %d", &A, &B);
v[A].push_back(B);
v[B].push_back(A);
}
dfs1(s, 0);
dfs2(s, s);
for(int i = 1; i <= m; i++) {
scanf("%d %d", &A, &B);
printf("%d\n", Get_LCA(A, B));
}
return 0;
}
例题
树链剖分通常结合着一些数据结构来进行操作，以为重链的 dfndfn 为连续的序列。

题目链接。

题目大意
对于一棵树，有 55 中操作，根据要求完成操作。

C i w 将输入的第 ii 条边权值改为 ww 。
N u v 将 u,vu,v 节点之间的边权都变为相反数。
SUM u v 询问 u,vu,v 节点之间边权和。
MAX u v 询问 u,vu,v 节点之间边权最大值。
MIN u v 询问 u,vu,v 节点之间边权最小值。
思路
先考虑第二个操作。

设 lcalca 为 u,vu,v 的最近公共祖先，那么可以将操作二分解为从 uu 到 lcalca 的路径取反，和将从 vv 到 lcalca 的路径取反。

那么按照上述 LCALCA 往上爬的过程刚好就可以遍历完这条路径一次。

按照点的 dfndfn 建造一颗线段树，来维护点的信息。

这里点的信息是指：这个点与它的父节点的连边的信息。

线段树需要维护的信息有：最大值，最小值，区间和。

具体的操作二代码如下：

void Negate(int pos, int l, int r) {
if(l <= L(pos) && R(pos) <= r) {
A(pos) = -A(pos);
I(pos) = -I(pos);
swap(A(pos), I(pos));//最大值取反，最小值取反，最大值边最小值
S(pos) = -S(pos);//区间和取反
M(pos) ^= 1;//取反两次后就相当于不取反。
return;
}
Push_Down(pos);//传递懒标记
if(l <= R(LC(pos)))
Negate(LC(pos), l, r);
if(r >= L(RC(pos)))
Negate(RC(pos), l, r);
Push_Up(pos);//修改后更新点的信息
}
void Negatepast(int x, int y) {
while(tp[x] != tp[y]) {//不同重链向上爬
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
Negate(1, dfn[tp[x]], dfn[x]);//同一条重链dfn是连续的，线段树维护
x = fa[tp[x]];//向上爬
}
if(x == y)
return;
if(dep[x] < dep[y])
swap(x, y);
Negate(1, dfn[son[y]], dfn[x]);//注意是son[y]，y与其父节点的连边并不需要修改
}
查询操作与其类似，就不一一列举了。

对于修改权值，使用深度较大的子节点，直接在线段树上该就好了。

C++代码
#include
#include
#include
#include
#include
using namespace std;
#define INF 0x3f3f3f3f
const int MAXN = 2e5 + 5;
struct Segment_Tree {//线段树
int Left_Section, Right_Section;
int Max_Data, Min_Data, Sum_Data, Lazy_Mark;
#define LC(x) (x << 1)
#define RC(x) (x << 1 | 1)
#define L(x) Tree[x].Left_Section//左区间
#define R(x) Tree[x].Right_Section//右区间
#define I(x) Tree[x].Min_Data//区间最小值
#define A(x) Tree[x].Max_Data//区间最大值
#define S(x) Tree[x].Sum_Data//区间和
#define M(x) Tree[x].Lazy_Mark//懒惰标记（延迟标记）
};
Segment_Tree Tree[MAXN << 2];
vector v[MAXN];//vector存图
int fa[MAXN], son[MAXN], dep[MAXN], siz[MAXN];
int tp[MAXN], dfn[MAXN];
int s[MAXN], t[MAXN], w[MAXN];
int n, q;
int tim;
void Push_Up(int pos) {//更新节点信息
A(pos) = max(A(LC(pos)), A(RC(pos)));
I(pos) = min(I(LC(pos)), I(RC(pos)));
S(pos) = S(LC(pos)) + S(RC(pos));
}
void Push_Down(int pos) {//传递懒标记
if(M(pos)) {
I(LC(pos)) = -I(LC(pos));
A(LC(pos)) = -A(LC(pos));
swap(I(LC(pos)), A(LC(pos)));
S(LC(pos)) = -S(LC(pos));
M(LC(pos)) ^= 1;
I(RC(pos)) = -I(RC(pos));
A(RC(pos)) = -A(RC(pos));
swap(I(RC(pos)), A(RC(pos)));
S(RC(pos)) = -S(RC(pos));
M(RC(pos)) ^= 1;
M(pos) = 0;
}
}
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
http://www…
void Build(int pos, int l, int r) {//初始化建树
L(pos) = l;
R(pos) = r;
if(l == r)
return;
int mid = (l + r) >> 1;
Build(LC(pos), l, mid);
Build(RC(pos), mid + 1, r);
}
void Negate(int pos, int l, int r) {//取反操作
if(l <= L(pos) && R(pos) <= r) {
I(pos) = -I(pos);
A(pos) = -A(pos);
swap(I(pos), A(pos));
S(pos) = -S(pos);
M(pos) ^= 1;
return;
}
Push_Down(pos);
if(l <= R(LC(pos)))
Negate(LC(pos), l, r);
if(r >= L(RC(pos)))
Negate(RC(pos), l, r);
Push_Up(pos);
}
void Negatepast(int x, int y) {
while(tp[x] != tp[y]) {
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
Negate(1, dfn[tp[x]], dfn[x]);
x = fa[tp[x]];
}
if(x == y)
return;
if(dep[x] < dep[y])
swap(x, y);
Negate(1, dfn[son[y]], dfn[x]);
}
void Change(int pos, int x, int c) {//单点修改
if(L(pos) == R(pos)) {
I(pos) = c;
A(pos) = c;
S(pos) = c;
return;
}
Push_Down(pos);
if(x <= R(LC(pos)))
Change(LC(pos), x, c);
else
Change(RC(pos), x, c);
Push_Up(pos);
}
int Query_Sum(int pos, int l, int r) {//查询最大值操作，与修改类似，都已同样方向爬
if(l <= L(pos) && R(pos) <= r)
return S(pos);
Push_Down(pos);
int res = 0;
if(l <= R(LC(pos)))
res += Query_Sum(LC(pos), l, r);
if(r >= L(RC(pos)))
res += Query_Sum(RC(pos), l, r);
return res;
}
int Sumpast(int x, int y) {
int res = 0;
while(tp[x] != tp[y]) {
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
res += Query_Sum(1, dfn[tp[x]], dfn[x]);
x = fa[tp[x]];
}
if(x == y)
return res;
if(dep[x] < dep[y])
swap(x, y);
res += Query_Sum(1, dfn[son[y]], dfn[x]);
return res;
}
int Query_Min(int pos, int l, int r) {//查询最小值
if(l <= L(pos) && R(pos) <= r)
return I(pos);
Push_Down(pos);
int res = INF;
if(l <= R(LC(pos)))
res = min(res, Query_Min(LC(pos), l, r));
if(r >= L(RC(pos)))
res = min(res, Query_Min(RC(pos), l, r));
return res;
}
int Minpast(int x, int y) {
int res = INF;
while(tp[x] != tp[y]) {
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
res = min(res, Query_Min(1, dfn[tp[x]], dfn[x]));
x = fa[tp[x]];
}
if(x == y)
return res;
if(dep[x] < dep[y])
swap(x, y);
res = min(res, Query_Min(1, dfn[son[y]], dfn[x]));
return res;
}
int Query_Max(int pos, int l, int r) {//查询最大值
if(l <= L(pos) && R(pos) <= r)
return A(pos);
Push_Down(pos);
int res = -INF;
if(l <= R(LC(pos)))
res = max(res, Query_Max(LC(pos), l, r));
if(r >= L(RC(pos)))
res = max(res, Query_Max(RC(pos), l, r));
return res;
}
int Maxpast(int x, int y) {
int res = -INF;
while(tp[x] != tp[y]) {
if(dep[tp[x]] < dep[tp[y]])
swap(x, y);
res = max(res, Query_Max(1, dfn[tp[x]], dfn[x]));
x = fa[tp[x]];
}
if(x == y)
return res;
if(dep[x] < dep[y])
swap(x, y);
res = max(res, Query_Max(1, dfn[son[y]], dfn[x]));
return res;
}
void dfs1(int now, int father) {//初始化
dep[now] = dep[father] + 1;
siz[now] = 1;
fa[now] = father;
int SIZ = v[now].size();
int maxn = 0;
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(next == fa[now])
continue;
dfs1(next, now);
siz[now] += siz[next];
if(maxn < siz[next]) {
maxn = siz[next];
son[now] = next;
}
}
}
void dfs2(int now, int Top) {//初始化
tp[now] = Top;
dfn[now] = ++tim;
if(son[now])
dfs2(son[now], Top);
int SIZ = v[now].size();
for(int i = 0; i < SIZ; i++) {
int next = v[now][i];
if(son[now] == next || fa[now] == next)
continue;
dfs2(next, next);
}
}
int main() {
scanf("%d", &n);
for(int i = 1; i < n; i++) {
scanf("%d %d %d", &s[i], &t[i], &w[i]);
s[i]++;
t[i]++;
v[s[i]].push_back(t[i]);
v[t[i]].push_back(s[i]);
}
dfs1(1, 0);
dfs2(1, 1);
Build(1, 1, n);
for(int i = 1; i < n; i++) {
if(dep[s[i]] < dep[t[i]])//深度小的一定就是子节点
swap(s[i], t[i]);
Change(1, dfn[s[i]], w[i]);//初始化线段树
}
scanf("%d", &q);
string opt;
int a, b;
while(q–) {
cin >> opt;
scanf("%d %d", &a, &b);
a++;
b++;
if(opt[0] == ‘N’)
Negatepast(a, b);
else if(opt[0] == ‘C’)
Change(1, dfn[s[a - 1]], b - 1);
else if(opt[0] == ‘S’)
printf("%d\n", Sumpast(a, b));
else if(opt[1] == ‘A’)
printf("%d\n", Maxpast(a, b));
else
printf("%d\n", Minpast(a, b));
}
return 0;
}

zhaoyun198769
关注
树链剖分(初学)
weixin_43823476的博客
09-19 173
首先看一下树链剖分是什么东西： 当我们要同时解决以下两个问题时： 1.求树上两点简单路径上的最大最小值(和） 2.修改树上两点简单路径上的边权(点权) 如果只用单独考虑，那么第一个就是树上差分，第二个是倍增，可是如果同时要有两个操作，那么时间复杂度就会大幅度退化，所以现在要用一个新的方法：树链剖分 它将一棵树剖成了几条链来组成，且每个点最多只会存在一条链上，且只出现一次。那么怎么进行剖分...
树链剖分
我歌月徘徊，我舞影零乱
05-16 242
时间复杂度： 预处理O（n + NlogN） ， 修改和查询O（logN） 树链剖分原理： 第一遍 dfs ， 求得 所有节点的 深度 dep[ ] ， 记录每个节点的父亲节点 fa[ ] , 记录每个节点所代表的子树的大小【包括节点本身】 第二遍 dfs , 记录 每个节点的 重链 ， 记下当前节点 x 所在的链 的 链头top[x] , 每个节点在dfs序中的pos[x] , pos...
树链剖分总结
ZhuRanCheng的博客
05-22 646
树链剖分总结
[算法] 树链剖分解析
weixin_45032957的博客
04-25 69
C++代码 void dfs1(int now, int father) { fa[now] = father;//初始化父节点 sz[now] = 1;//子树大小包括自己 dep[now] = dep[father] + 1;//初始化深度 int SIZ = v[now].size(); int maxn = 0;//记录最大的子树大小 for(int i = 0; i < SIZ; i++) { int next = v[now][i]; if(next == father) continue
树链剖分瞎入门
Venus的博客
01-09 443
本文旨在让读者背代码 前言 在做题时，我们可能会遇到这样一类问题： 给定一棵 nnn 个结点的树和 mmm 次操作，操作有两种，一种是给定两个结点，让连接两个结点的路径上的所有点权值加上一个值，另一种是查询路径上所有点的权值和。n≤1e5n\le 1e5n≤1e5，m≤2e5m\le 2e5m≤2e5。 如果是最后统一输出结点权值，用树上差分+DFS\text{DFS}DFS 就能轻松水过，而...
P2680 运输计划（树上差分，树链剖分求lca，二分答案）
仙都一普通市民的blog
10-30 140
P2680 运输计划
HDU 5293 Tree chain problem（树形DP+树链剖分）
Neutralzz的博客
07-06 397
题意：一颗n节点树上有m条链，每条链有权重，求一个链的集合使权重和最大且两两不相交。 解析：令dp[i]为以i为根的子树的最大权重和。 如果i不在链上，则有dp[i] = sigma(dp[k]) k为i的子节点 如果i在某一条链(u,v,w)上，那么dp[i] = w + sigma(dp[k]) k为链上所有节点的子节点。对于该值，我们可以统计统计链上节点的所有子节点dp的和 - 链上节
HDU 3804 Query on a tree (树链剖分+离线处理)
咸鱼有梦想
03-04 236
Query on a treeTime Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1303    Accepted Submission(s): 334Problem Description  There are some queries o...
浅谈重链剖分
麻衣学姐的博客
03-29 354
树链剖分 1. 概念（chě dàn）： 一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链。 2.定义（源于OI-Wiki）： 重子节点（重儿子）： 表示其子节点中子树最大的子结点。如果有多个子树最大的子结点，取其一。如果没有子节点，就无重子节点。 轻子节点（轻儿子）： 除重子节点外的所有节点。 重边： 从某个结点到重子节点的边。 轻边： 从某个结点到轻子节点的边。 重链： 若干条首尾衔接的重.
树链剖分(轻重链剖分)
qq_49593247的博客
08-12 790
lca,即为最近公共祖先.解决该问题,有两种算法,一种是倍增算法,还有一种就是树链剖分,顾名思义,树链剖分就是将树剖分成很多根单独的链,通过链与链之间的转换,来解决lca问题. 要理解树链剖分(轻重链剖分),需要理解几个前置定义,首先是何为重链,重链是指 ...
树链剖分讲解及总结(重链剖分+长链剖分)
weixin_34080571的博客
09-06 2137
　　树链剖分是解决树上问题的一种常见数据结构，对于树上路径修改及路径信息查询等问题有着较优的复杂度。树链剖分分为两种：重链剖分和长链剖分，因为长链剖分不常见，应用也不广泛，所以通常说的树链剖分指的是重链剖分。在这里讲解并总结一下树链剖分的实现、优秀性质及应用。 重链剖分 先来介绍几个重链剖分的专业名词： 重儿子：每个点的子树中，子树大小(即节点数)最大的子节点 轻儿子：除重儿子外的其...
（ 数据结构专题 ）【 树链剖分】
石旭先森的博客
02-11 173
（ 数据结构专题 ）【 树链剖分】 推荐视频：https://www.bilibili.com/video/av62060264?from=search&seid=11398715168050880992 对于操作3，4， 我们可以用dfs序来做，这样我们发现每一个节点的子树节点全部是连续的。比如B节点的子树BDGHI在序列中是连续的，区间范围是 L = B点的时间戳， R...
C~排序算法
weixin_60461563的博客
09-27 1089
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 123
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构-4.2.串的定义和基本操作
最新发布
ADCvbV的博客
10-01 212
1.单/双引号不是字符串里的内容，他只是一个边界符，用来表示字符串的头和尾；2.空串也是字符串的子串，空串长度为0；3.字符的编号是从1开始，不是0；4.空格也是字符；
排序算法之归并排序
qq_64039411的博客
10-01 228
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
18年408数据结构
weixin_62182040的博客
09-28 857
如图所示：因为只存上三角部分的元素（包含对角线元素），经分析可知第一层存12个元素，第二层存11个元素，第三层存10个元素，第四层存9个元素，第五层存8个元素，接着第6层只存m6,6，一共是12+11+10+9+8+1=51.A.1出队并输出，2出队并输出，345存入栈中，5出栈并输出，6出队并输出，4出栈并输出，3出栈并输出，A正确。B.1出队入栈，2出队并输出，3出队并输出，4出队并输出，5出队并输出，6出队并输出,1出栈并输出。此时储存在数组中的序列是：6,9,7,1,8,4,5，排除D。
动态树数据结构：Link-Cut-Tree与树链剖分解析
"动态树课件 - 包含Link-Cut-Tree(LCT)和树链剖分等数据结构在动态树问题中的应用" 在动态树的问题中，Link-Cut-Tree（LCT）是一种强大的数据结构，由著名算法专家Tarjan提出。LCT专门用于处理动态树类问题，但需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值