LCA+线段树 NOIP2016 天天爱跑步

最新推荐文章于 2022-07-21 14:08:51 发布
最新推荐文章于 2022-07-21 14:08:51 发布
阅读量88 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/sdfzxh/p/7259964.html
本文介绍了一款名为《天天爱跑步》的养成类游戏。游戏中玩家需完成打卡任务，通过最短路径抵达终点。文章提供了游戏地图结构和玩家路径算法，并讨论了如何计算各个观察点的可见玩家数量。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

天天爱跑步

题目描述

小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。

这个游戏的地图可以看作一一棵包含 nnn个结点和 n−1n-1n−1条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从111到nnn的连续正整数。

现在有mmm个玩家,第iii个玩家的起点为 SiS_iS​i​​,终点为 TiT_iT​i​​ 。每天打卡任务开始时,所有玩家在第000秒同时从自己的起点出发, 以每秒跑一条边的速度, 不间断地沿着最短路径向着自己的终点跑去, 跑到终点后该玩家就算完成了打卡任务。 (由于地图是一棵树, 所以每个人的路径是唯一的)

小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。 在结点jjj的观察员会选择在第WjW_jW​j​​秒观察玩家, 一个玩家能被这个观察员观察到当且仅当该玩家在第WjW_jW​j​​秒也理到达了结点 jjj 。 小C想知道每个观察员会观察到多少人?

注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一 段时间后再被观察员观察到。 即对于把结点jjj作为终点的玩家: 若他在第WjW_jW​j​​秒重到达终点,则在结点jjj的观察员不能观察到该玩家;若他正好在第WjW_jW​j​​秒到达终点,则在结点jjj的观察员可以观察到这个玩家。

输入输出格式

输入格式：

第一行有两个整数nnn和mmm 。其中nnn代表树的结点数量, 同时也是观察员的数量, mmm代表玩家的数量。

接下来 n−1n- 1n−1行每行两个整数uuu和 vvv,表示结点 uuu到结点 vvv有一条边。

接下来一行 nnn个整数,其中第jjj个整数为WjW_jW​j​​ , 表示结点jjj出现观察员的时间。

接下来 mmm行,每行两个整数SiS_iS​i​​,和TiT_iT​i​​,表示一个玩家的起点和终点。

对于所有的数据,保证1≤Si,Ti≤n,0≤Wj≤n1\leq S_i,T_i\leq n, 0\leq W_j\leq n1≤S​i​​,T​i​​≤n,0≤W​j​​≤n 。

输出格式：

输出1行 nnn个整数,第jjj个整数表示结点jjj的观察员可以观察到多少人。

输入输出样例

输入样例#1： 
6 3
2 3
1 2 
1 4 
4 5 
4 6 
0 2 5 1 2 3 
1 5 
1 3 
2 6
输出样例#1： 
2 0 0 1 1 1
输入样例#2： 
5 3 
1 2 
2 3 
2 4 
1 5 
0 1 0 3 0 
3 1 
1 4
5 5
输出样例#2： 
1 2 1 0 1

说明

【样例1说明】

对于1号点，Wi=0W_i=0W​i​​=0，故只有起点为1号点的玩家才会被观察到，所以玩家1和玩家2被观察到，共有2人被观察到。

对于2号点，没有玩家在第2秒时在此结点，共0人被观察到。

对于3号点，没有玩家在第5秒时在此结点，共0人被观察到。

对于4号点，玩家1被观察到，共1人被观察到。

对于5号点，玩家1被观察到，共1人被观察到。

对于6号点，玩家3被观察到，共1人被观察到。

【子任务】

每个测试点的数据规模及特点如下表所示。 提示: 数据范围的个位上的数字可以帮助判断是哪一种数据类型。

【提示】

如果你的程序需要用到较大的栈空问 (这通常意味着需要较深层数的递归), 请务必仔细阅读选手日录下的文本当rumung:/stact.p″, 以了解在最终评测时栈空问的限制与在当前工作环境下调整栈空问限制的方法。

在最终评测时，调用栈占用的空间大小不会有单独的限制，但在我们的工作

环境中默认会有 8 MB 的限制。 这可能会引起函数调用层数较多时， 程序发生

栈溢出崩溃。

我们可以使用一些方法修改调用栈的大小限制。 例如， 在终端中输入下列命

令 ulimit -s 1048576

此命令的意义是，将调用栈的大小限制修改为 1 GB。

例如，在选手目录建立如下 sample.cpp 或 sample.pas

将上述源代码编译为可执行文件 sample 后，可以在终端中运行如下命令运

行该程序

./sample

如果在没有使用命令“ ulimit -s 1048576”的情况下运行该程序， sample

会因为栈溢出而崩溃； 如果使用了上述命令后运行该程序，该程序则不会崩溃。

特别地， 当你打开多个终端时， 它们并不会共享该命令， 你需要分别对它们

运行该命令。

请注意， 调用栈占用的空间会计入总空间占用中， 和程序其他部分占用的内

存共同受到内存限制。

 

此题我在csdn上写过了，还是比较详细，贴链接

这里宰贴一份别人的tarjan求LCA的代码。

 1 #include <iostream>
 2 #include <cstdlib>
 3 #include <cstring>
 4 #include <cstdio>
 5 #include <cmath>
 6 #include <algorithm>
 7 #include <ctime>
 8 #include <vector>
 9 #include <queue>
10 #include <map>
11 #include <set>
12 #include <string>
13 using namespace std;
14 typedef long long LL;
15 const int MAXN = 300011;
16 const int MAXM = 600011; 
17 int n,m,ecnt,first[MAXN],next[MAXM],to[MAXM],f[MAXN][20],deep[MAXN],ans[MAXN],val[MAXN],tong[MAXN],MAXD,w[MAXN],num[1000011];
18 int head[MAXN],tt[MAXM],nn[MAXM],father[MAXN],vis[MAXN];
19 vector<int>ljh[MAXN],ljh2[MAXN],ljh3[MAXN];
20 struct node{ int s,t,lca,len;}a[MAXN];
21 inline int getint(){
22     int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
23     if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
24 }
25 inline void link(int x,int y){ next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y; }
26 inline void LINK(int x,int y){ nn[++ecnt]=head[x]; head[x]=ecnt; tt[ecnt]=y; }
27 inline int find(int x){ if(father[x]!=x) father[x]=find(father[x]); return father[x]; }
28 inline void init(int x,int fa){ 
29     father[x]=x; vis[x]=1;
30     for(int i=head[x];i;i=nn[i]) {
31         int v=tt[i];
32         if(x==a[v].s&&vis[a[v].t]) a[v].lca=find(a[v].t);
33         if(x==a[v].t&&vis[a[v].s]) a[v].lca=find(a[v].s);
34     }
35     for(int i=first[x];i;i=next[i]) {
36         int v=to[i]; if(v==fa) continue; 
37         deep[v]=deep[x]+1; init(v,x); father[v]=x;
38         f[v][0]=x; 
39     }    
40 }
41  
42 inline int lca(int x,int y){
43     if(deep[x]<deep[y]) swap(x,y); int t=0; while((1<<t)<=deep[x]) t++; t--;
44     for(int i=t;i>=0;i--) if(deep[x]-(1<<i)>=deep[y]) x=f[x][i]; if(x==y) return y;
45     for(int i=t;i>=0;i--) if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i]; return f[x][0];
46 }
47  
48 inline void dfs(int x,int fa){
49     int now=w[x]+deep[x],cun; if(now<=MAXD) cun=tong[now];
50     for(int i=first[x];i;i=next[i]) {
51         int v=to[i]; if(v==fa) continue;
52         dfs(v,x);
53     }
54     tong[deep[x]]+=val[x]; if(now<=MAXD) ans[x]=tong[now]-cun;
55     for(int i=0,ss=ljh[x].size();i<ss;i++) tong[deep[ljh[x][i]]]--;
56 }
57  
58 inline void DFS(int x,int fa){
59     int now=deep[x]-w[x],cun; now+=300000; cun=num[now];
60     for(int i=first[x];i;i=next[i]) {
61         int v=to[i]; if(v==fa) continue;
62         DFS(v,x);
63     }
64     for(int i=0,ss=ljh2[x].size();i<ss;i++) num[300000+ljh2[x][i]]++;
65     ans[x]+=num[now]-cun;
66     for(int i=0,ss=ljh3[x].size();i<ss;i++) num[300000+ljh3[x][i]]--;
67 }
68  
69 inline void work(){  
70     n=getint(); m=getint(); int x,y; for(int i=1;i<n;i++) { x=getint(); y=getint(); link(x,y); link(y,x); }
71     for(int i=1;i<=n;i++) w[i]=getint(); ecnt=0;
72     for(int i=1;i<=m;i++) { a[i].s=getint(),a[i].t=getint(),val[a[i].s]++; LINK(a[i].s,i); LINK(a[i].t,i);}
73     deep[1]=1; init(1,0); for(int i=1;i<=n;i++) MAXD=max(MAXD,deep[i]);
74     for(int j=1;j<=19;j++) for(int i=1;i<=n;i++) f[i][j]=f[f[i][j-1]][j-1]; 
75     for(int i=1;i<=m;i++) {
76         a[i].len=deep[a[i].s]+deep[a[i].t]-deep[a[i].lca]*2;
77         ljh[a[i].lca].push_back(a[i].s);
78     }
79     dfs(1,0); 
80     for(int i=1;i<=m;i++) {
81         ljh2[a[i].t].push_back(deep[a[i].t]-a[i].len);
82         ljh3[a[i].lca].push_back(deep[a[i].t]-a[i].len);
83     }
84     DFS(1,0);
85     for(int i=1;i<=m;i++) if(deep[a[i].s]-deep[a[i].lca]==w[a[i].lca]) ans[a[i].lca]--;
86     for(int i=1;i<=n;i++) { printf("%d",ans[i]); if(i<n) printf(" "); }
87 }
88  
89 int main()
90 {
91     work();
92     return 0;
93 }

 

 

 

 

转载于:https://www.cnblogs.com/sdfzxh/p/7259964.html

[天天爱跑步]
qq_68042904的博客
05-01 672
天天爱跑步 题目描述 小c同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线,完成打卡任务。 这个游戏的地图可以看作一一棵包含nn个结点和n−1n−1条边的树，每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从11到nn的连续正整数。 现在有mm个玩家，第ii个玩家的起点为sisi，终点为titi。每天打卡任务开始时，所有玩家在第00秒同时从自己的起点出发，以每秒跑一条边的...
[NOIP2016] 天天爱跑步 （LCA+线段树（动态开点）+差分+dfs序）
TWorstO_DK的博客
08-15 3263
[NOIP2016] 天天爱跑步 （LCA+线段树（动态开点）+差分+dfs序）做完这题,好哈皮，一下子填了好多坑（坑太多= =），说实话这道题我觉得真的很有水平，如果我考的话应该会默默敲暴力 （暴露蒟蒻本性）。。。话不多说来看题吧。 不得不说，出题人很良心嘛，数据范围给的这么清楚（人家只不过知道你想不出正解罢了）= = 如果按照每个player的路径算观察者肯定是不行的（不信你试
P1600 天天爱跑步
a free man
02-10 550
题目描述 小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。 这个游戏的地图可以看作一一棵包含 个结点和 条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从到的连续正整数。 现在有个玩家,第个玩家的起点为 ,终点为  。每天打卡任务开始时,所有玩家在第秒同时
洛谷P1600 天天爱跑步
蒟蒻的博客
03-13 819
题目描述小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。这个游戏的地图可以看作一一棵包含 nn 个结点和 n-1n−1 条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从11 到nn 的连续正整数。现在有mm 个玩家,第ii 个玩家的起点为 S_iSi​ ,终点为 T_iTi​...
天天爱跑步
weixin_30635053的博客
05-14 147
题目传送门 借鉴的大佬的博客这儿 个人认为我的解释更详细一些 先来看部分分 $1.$25分 （当然是大暴力了!） \(2.\)一条链 首先，要考虑到它有左往右和从右往左两种情况 这里只讨论从左往右的情况，从右往左类似。 若第\(i\)条路径对\(u\)点有贡献，当且仅当\(dep[u]=dep[si]+w[u]\)（深度也就等于编号） 移项得\(dep[u]-w[u]=dep[si]\)，可以发...
P1600 [NOIP2016 提高组] 天天爱跑步
You_are_hanson的博客
07-21 1720
P1600 [NOIP2016 提高组] 天天爱跑步
NOIP2016Day1T2-天天爱跑步
Mi-Queen
09-10 442
2、天天爱跑步 时间限制: 2 Sec  内存限制: 512 MB 题目描述 小C同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。   《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线，完成打卡任务。   这个游戏的地图可以看作一棵包含n个结点和n−1条边的树，每条边连接两个结点，且任意两个结点存在一条路径互相可达。树上结点编号为从1到n的连续正整数。   现...
[FROM LUOGU]P1600 【NOIP2016DAY1T2】天天爱跑步
Park Corsa's 优快云 Blog
08-08 347
P1600 天天爱跑步 题面 小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。 这个游戏的地图可以看作一一棵包含 n个结点和 n-1条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从1到n的连续正整数。 现在有m个玩家,第ii个玩家的起点为 S_i ,终点为 T_i。 每天打卡...
[题解]bzoj4719 NOIP2016天天爱跑步
Saramanda的博客
08-15 899
Description小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。?天天爱跑步?是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。这个游戏的地图可以看作一一棵包含 N个结点和N-1 条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从1到N的连续正整数。现在有个玩家,第个玩家的起点为Si ,终点为Ti 。每天打卡任务开始时,所有玩家在第0
LCA 天天爱跑步
蒟蒻QTY
08-14 467
问题 G: 天天爱跑步 时间限制: 2 Sec 内存限制: 512 MB 提交: 24 解决: 20 [提交][状态][讨论版] 题目描述 小C同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线，完成打卡任务。这个游戏的地图可以看作一棵包含n个结点和n-1条边的树，每条边连接两个结点，且任意两个结点存在一条路径互相可达。
洛谷P1600 天天爱跑步
ehdhg13455的博客
06-22 221
树上的题有点意思啊 这题我最开始的想法是 固定一个观测点i，能观测到的一定是起点距离 i 为 w[ i ] 的点的子集合。问题是这个集合只有一部分的点会经过 i 点，就很烦。。。 于是得换个思路，不放固定一个跑步的人 x 观察他对哪些观察者 i 产生了贡献。 于是我们得到了公式， 对于上升阶段的点来说，不妨设 s 为起点 d[x]+w[x] = d[s]( d为表示深度的数组 )...
luogu P1600 天天爱跑步
weixin_30762087的博客
11-07 168
传送门 1A此题暴祭 (下面记点\(x\)深度为\(de_x\),某个时间点记为\(w_x\)) 首先,每条路径是可以拆成往上和往下两条路径的 对于往上的路径,假设有个人往上跑,\(w_y\)在点\(y\),那么如果能对点\(x\)的观察员产生贡献,当且仅当\(w_x+de_x=w_y+de_y\) 对于往下的路径,假设有个人往下跑,\(w_y\)在点\(y\),那么如果能对点\(x\)的观察员产...
Luogu P1600 [NOIp提高组2016]天天爱跑步
VSEJGFB的博客
09-19 766
题目描述 传送门我觉得好难好难啊，看题解我都看不懂（我觉得实现起来有点麻烦）。 总结一下： 首先也许可以想出S=1和T=1的数据的做法，然后想到把S->T路径拆成S->LCA和LCA->T. 然后要想到一个点i可观测到的人一定满足: S->LCA路径: depth[i]+w[i]=depth[S]depth[i]+w[i]=depth[S] LCA->T路径: distance(S
洛谷P1600 天天爱跑步（NOIp2016）（BZOJ4719）
forezxl的博客
10-20 1423
LCA
详细解说Splay树和Treap数和LCA和线段树和RMO
最新发布
05-10
<think>好的，我现在需要详细解释Splay树、Treap树、LCA、线段树和RMO这几个数据结构与算法，并且按照用户的要求用C++代码示例。首先，我需要逐个整理每个概念的基本原理、实现方法和应用场景，然后给出相应的代码片段。同时，还要确保在最后提出相关的问题。 首先，Splay树。它是一种自平衡二叉搜索树，通过splay操作将最近访问的节点移动到根，利用局部性原理提高效率。实现时需要旋转操作，包括zig、zag等。应用场景包括缓存和频繁访问相同数据的场景。我需要写一个Splay树的节点结构，以及splay和插入函数的代码示例。 接下来是Treap树，结合了二叉搜索树和堆的特性。每个节点有优先级，通过旋转维持堆性质。插入时先按BST插入，再按优先级旋转。代码示例应包括节点结构、旋转和插入操作。然后是LCA（最近公共祖先），常见算法有倍增法。预处理每个节点的2^k级祖先，通过二分查找找到LCA。需要实现预处理和查询的函数，代码结构可能包括计算深度、跳转祖先等步骤。 线段树用于区间查询和更新，构建树结构，每个节点代表一个区间。实现时需要建树、查询和更新函数。例如，区间求和的线段树，代码中包括节点结构、递归建树、查询和更新操作。RMO可能是区域管理办公室的缩写，但在数据结构和算法中不常见。可能需要用户确认具体指的是什么。这里假设是范围最小查询（RMQ），所以解释RMQ的稀疏表实现方法，预处理二维数组存储区间最小值，查询时找到区间长度对应的k值，比较两个区间的最小值。 在代码部分，需要注意语法正确性，比如结构体定义、函数参数、递归调用等。例如，Splay树的splay函数需要处理左旋、右旋等情况，而Treap的插入需要维护堆性质，可能涉及左右旋转。最后，相关问题需要围绕这些数据结构的特点、实现细节、应用场景以及相关算法展开。例如，询问Splay树的优势、Treap的优先级作用、LCA的应用、线段树的延迟标记等。</think>以下是C++相关数据结构和算法的详细解释及代码实现： 1. **Splay树（伸展树）** 自平衡二叉搜索树，通过"splay"操作将最近访问的节点移动到根位置 ```cpp struct SplayNode { int key; SplayNode *left, *right, *parent; SplayNode(int k) : key(k), left(nullptr), right(nullptr), parent(nullptr) {} }; void splay(SplayNode* x) { while (x->parent) { if (!x->parent->parent) { // Zig step if (x->parent->left == x) rotateRight(x->parent); else rotateLeft(x->parent); } else if ((x->parent->left == x) && (x->parent->parent->left == x->parent)) { // Zig-zig right rotateRight(x->parent->parent); rotateRight(x->parent); } else if ((x->parent->right == x) && (x->parent->parent->right == x->parent)) { // Zig-zig left rotateLeft(x->parent->parent); rotateLeft(x->parent); } else { // Zig-zag if (x->parent->left == x) { rotateRight(x->parent); rotateLeft(x->parent); } else { rotateLeft(x->parent); rotateRight(x->parent); } } } } ``` 2. **Treap（树堆）** 结合二叉搜索树和堆特性的概率平衡树 ```cpp struct TreapNode { int key, priority; TreapNode *left, *right; TreapNode(int k) : key(k), priority(rand()), left(nullptr), right(nullptr) {} }; TreapNode* rotateRight(TreapNode* y) { TreapNode* x = y->left; y->left = x->right; x->right = y; return x; } TreapNode* insert(TreapNode* root, int key) { if (!root) return new TreapNode(key); if (key < root->key) { root->left = insert(root->left, key); if (root->left->priority > root->priority) root = rotateRight(root); } else { root->right = insert(root->right, key); if (root->right->priority > root->priority) root = rotateLeft(root); } return root; } ``` 3. **LCA（最近公共祖先）** 使用倍增法实现的LCA算法 ```cpp const int MAX = 1000, LOG = 10; int depth[MAX], parent[MAX][LOG]; void preprocess(vector<int> tree[], int u, int p) { parent[u][0] = p; depth[u] = depth[p] + 1; for (int i = 1; i < LOG; ++i) parent[u][i] = parent[parent[u][i-1]][i-1]; for (int v : tree[u]) if (v != p) preprocess(tree, v, u); } int lca(int u, int v) { if (depth[u] < depth[v]) swap(u, v); // 提升较深的节点 for (int i = LOG-1; i >= 0; --i) if (depth[u] - (1<<i) >= depth[v]) u = parent[u][i]; if (u == v) return u; // 同时提升两个节点 for (int i = LOG-1; i >= 0; --i) if (parent[u][i] != parent[v][i]) { u = parent[u][i]; v = parent[v][i]; } return parent[u][0]; } ``` 4. **线段树** 区间查询数据结构示例（区间求和） ```cpp const int MAXN = 1e5; int arr[MAXN], tree[4*MAXN]; void build(int node, int start, int end) { if (start == end) { tree[node] = arr[start]; } else { int mid = (start + end) / 2; build(2*node, start, mid); build(2*node+1, mid+1, end); tree[node] = tree[2*node] + tree[2*node+1]; } } int query(int node, int start, int end, int l, int r) { if (r < start || end < l) return 0; if (l <= start && end <= r) return tree[node]; int mid = (start + end) / 2; return query(2*node, start, mid, l, r) + query(2*node+1, mid+1, end, l, r); } void update(int node, int start, int end, int idx, int val) { if (start == end) { arr[idx] = val; tree[node] = val; } else { int mid = (start + end) / 2; if (start <= idx && idx <= mid) update(2*node, start, mid, idx, val); else update(2*node+1, mid+1, end, idx, val); tree[node] = tree[2*node] + tree[2*node+1]; } } ``` 5. **RMO（Range Minimum Query）** 范围最小查询的稀疏表实现 ```cpp const int MAXN = 1e5, LOG = 17; int st[MAXN][LOG], log_table[MAXN]; void buildRMQ(int arr[], int n) { log_table[1] = 0; for (int i = 2; i <= n; ++i) log_table[i] = log_table[i/2] + 1; for (int i = 0; i < n; ++i) st[i][0] = arr[i]; for (int j = 1; j <= LOG; ++j) for (int i = 0; i + (1 << j) <= n; ++i) st[i][j] = min(st[i][j-1], st[i + (1 << (j-1))][j-1]); } int queryRMQ(int l, int r) { int k = log_table[r - l + 1]; return min(st[l][k], st[r - (1 << k) + 1][k]); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值