BZOJ 1500 NOI 2005 维修数列 Splay

最新推荐文章于 2024-11-14 17:58:10 发布
最新推荐文章于 2024-11-14 17:58:10 发布
阅读量1.2k 收藏
点赞数
分类专栏： BZOJ 文章标签： Splay tree 平衡树 NOI2005 数据结构 维修数列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangyuze831/article/details/39098481
版权

题意：见下图


传说级别的NOI数据结构神题，像我这种弱渣花了一下午的时间才A掉，最后发现竟然是边界值的问题没处理好。。


这个题对Splay的所有操作基本是全了。

插入：新建一颗Splay Tree，然后把对应节点Splay到根的右儿子上，再把新建的树连上。

删除：把要删除的区间Splay到根的右儿子的左儿子上，递归free掉。（这里可以用数组优化，可以避免递归free节省时间）

修改，翻转：打标记，在需要的时候下传标记，和线段树差不多，翻转标记下传时，要将左右儿子的左右儿子分别交换。

求和：维护一个sum域。

求最大子列和：与线段树类似。维护一个区间从左边开始连续最大值，从右边开始连续最大值，整体的连续最大值。更新的时候注意下细节。不会的可以先去写vijos的小白逛公园，线段树的最大子列和，要比这个简单一些。详情见代码。


CODE（BZOJ5988ms）：


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 600010
#define INF 0x7f7f7f7f
using namespace std;
const char INSERT[] = "INSERT";
const char DELETE[] = "DELETE";
const char REVERSE[] = "REVERSE";
const char GET_SUM[] = "GET-SUM";
const char MAX_SUM[] = "MAX-SUM";
const char MAKE_SAME[] = "MAKE-SAME";
 
struct Complex{
    int val,size;
    bool change,reverse;
    int change_into;
    int sum;
    int l,r,all;
    Complex *son[2],*father;
     
    bool Check() {
        return father->son[1] == this;
    }
    void Combine(Complex *a,bool dir) {
        son[dir] = a;
        a->father = this;
    }
    void Reverse() {
        reverse ^= 1;
        swap(son[0],son[1]);
        swap(l,r);
    }
    void Change(int x) {
        val = x;
        sum = x * size;
        l = r = all = max(sum,val);
        change = true;
        change_into = x;
    }
}none,*nil = &none,*root = nil;
 
void Pretreatment();
inline Complex *NewComplex(int x);  
inline void Rotate(Complex *a,bool dir);
inline void Splay(Complex *a,Complex *aim);
Complex *BuildTree(int l,int r);
inline void SplaySeg(int st,int ed);    
inline void PushUp(Complex *a); 
inline void PushDown(Complex *a);
void Delete(Complex *a);
Complex *FindK(Complex *a,int k);
 
void Print(Complex *a)
{
    if(a == nil)    return ;
    PushDown(a);
    PushUp(a);
    Print(a->son[0]);
    printf("%d ",a->val);
    Print(a->son[1]);
}
 
int cnt,asks;
int pos,num;
 
int temp[MAX];
char s[20];
 
int main()
{
    cin >> cnt >> asks;
    Pretreatment();
    for(int i = 1;i <= cnt; ++i) 
        scanf("%d",&temp[i]);
    root = BuildTree(0,cnt + 1);
    root->father = nil;
    for(int i = 1;i <= asks; ++i) {
        scanf("%s",s);
        if(!strcmp(s,INSERT)) {
            scanf("%d%d",&pos,&cnt),pos++;
            for(int i = 1;i <= cnt; ++i)
                scanf("%d",&temp[i]);
            Splay(FindK(root,pos),nil);
            Splay(FindK(root,pos + 1),root);
            root->son[1]->Combine(BuildTree(1,cnt),false);
            PushUp(root->son[1]),PushUp(root);
        }
        else if(!strcmp(s,DELETE)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            Delete(root->son[1]->son[0]);
            root->son[1]->son[0] = nil;
            PushUp(root->son[1]),PushUp(root);
        }
        else if(!strcmp(s,MAKE_SAME)) {
            scanf("%d%d%d",&pos,&cnt,&num);
            SplaySeg(pos,pos + cnt - 1);
            root->son[1]->son[0]->Change(num);
            PushUp(root->son[1]),PushUp(root);           
        }
        else if(!strcmp(s,REVERSE)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            root->son[1]->son[0]->Reverse();
            PushUp(root->son[1]),PushUp(root);           
        }
        else if(!strcmp(s,GET_SUM)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            printf("%d\n",root->son[1]->son[0]->sum);
        }
        else if(!strcmp(s,MAX_SUM)) {
            int temp = root->size;
            Splay(FindK(root,1),nil);
            Splay(FindK(root,temp),root);
            printf("%d\n",root->son[1]->son[0]->all);
        }
    }
    return 0;
}
 
void Pretreatment()
{
    nil->son[0] = nil->son[1] = nil;
    nil->father = nil;
    nil->size = 0;
    nil->all = -INF;
    temp[0] = temp[cnt + 1] = -INF;
}
 
inline Complex *NewComplex(int x)
{
    Complex *re = new Complex();
    re->son[0] = re->son[1] = nil;
    re->size = 1;
    re->sum = re->l = re->r = re->all = re->val = x;
    re->change = re->reverse = false;
    return re;
}
 
inline void Rotate(Complex *a,bool dir)
{
    Complex *f = a->father;
    PushDown(f),PushDown(a);
    f->son[!dir] = a->son[dir];
    f->son[!dir]->father = f;
    a->son[dir] = f;
    a->father = f->father;
    f->father->son[f->Check()] = a;
    f->father = a;
    PushUp(f);
    if(root == f)   root = a;
}
 
inline void Splay(Complex *a,Complex *aim)
{
    while(a->father != aim) {
        if(a->father->father == aim) 
            Rotate(a,!a->Check());
        else if(!a->father->Check()) {
            if(!a->Check()) {
                Rotate(a->father,true);
                Rotate(a,true);
            }
            else {
                Rotate(a,false);
                Rotate(a,true);
            }
        }
        else {
            if(a->Check()) {
                Rotate(a->father,false);
                Rotate(a,false);
            }
            else {
                Rotate(a,true);
                Rotate(a,false);
            }
        }
        PushUp(a);
    }
}
 
Complex *BuildTree(int l,int r)
{
    if(l > r)    return nil;
    int mid = (l + r) >> 1;
    Complex *now = NewComplex(temp[mid]);
    now->Combine(BuildTree(l,mid - 1),false);
    now->Combine(BuildTree(mid + 1,r),true);
    if(l != r)
        PushUp(now);
    return now;
}
 
void Delete(Complex *a)
{
    if(a == nil)    return ;
    Delete(a->son[0]),Delete(a->son[1]);
    free(a);
}
 
inline void SplaySeg(int st,int ed)
{
    st += 1,ed += 1;
    Splay(FindK(root,st - 1),nil);
    Splay(FindK(root,ed + 1),root);
}
 
Complex *FindK(Complex *a,int k)
{
    PushDown(a);
    if(k <= a->son[0]->size)
        return FindK(a->son[0],k);
    k -= a->son[0]->size;
    if(k == 1)  return a;
    --k;
    return FindK(a->son[1],k);
}
 
inline void PushDown(Complex *a)
{
    if(a == nil)    return ;
    if(a->change) {
        if(a->son[0] != nil)
            a->son[0]->Change(a->change_into);
        if(a->son[1] != nil)
            a->son[1]->Change(a->change_into);
        a->change = false;
    }
    if(a->reverse) {
        if(a->son[0] != nil)
            a->son[0]->Reverse();
        if(a->son[1] != nil)
            a->son[1]->Reverse();
        a->reverse = false;
    }
}
 
inline void PushUp(Complex *a)
{
    if(a == nil)    return ;
    a->size = a->son[0]->size + a->son[1]->size + 1;
    a->sum = a->son[0]->sum + a->son[1]->sum + a->val;
    a->l = max(a->son[0]->l,a->son[0]->sum + a->val + max(0,a->son[1]->l));
    a->r = max(a->son[1]->r,a->son[1]->sum + a->val + max(0,a->son[0]->r));
    a->all = max(max(a->son[0]->all,a->son[1]->all),a->val+max(0,a->son[0]->r)+max(0,a->son[1]->l));
}


奉上读入优化版本，因为有的OJ卡这个题的常数（比如我们学校自己的oj）

同学帮着写的，效率十分可观，BZOJ3472ms就过了


CODE（读入优化）：


#include <cstdio>  
#include <cstring>  
#include <iostream>  
#include <algorithm> 
#include <cctype>

#define MAX 600010  
#define INF 0x7f7f7f7f  
using namespace std;  

inline int getc() {
    static const int L = 1 << 15;
    static char buf[L], *S = buf, *T = buf;
    if (S == T) {
        T = (S = buf) + fread(buf, 1, L, stdin);
        if (S == T)
            return EOF;
    }
    return *S++;
}
inline int getint() {
    int c;
    while(!isdigit(c = getc()) && c != '-');
    bool sign = c == '-';
    int tmp = sign ? 0 : c - '0';
    while(isdigit(c = getc()))
        tmp = (tmp << 1) + (tmp << 3) + c - '0';
    return sign ? -tmp : tmp;
}

struct Twochar {
    char c0, c1;
    Twochar(char _c0 = 0, char _c1 = 0):c0(_c0),c1(_c1){}
};
inline Twochar getch() {
    int c;
    while((c = getc()) != 'I' && c != 'D' && c != 'M' && c != 'R' && c != 'G');
    int c2 = getc();
    c2 = getc();
    if(c == 'I'&&c2=='S')getc(),getc(),getc();
    if(c == 'D'&&c2=='L')getc(),getc(),getc();
    if(c=='M'&&c2=='K')getc(),getc(),getc(),getc(),getc();
    if(c=='R'&&c2=='V')getc(),getc(),getc(),getc();
    if(c=='G'&&c2=='T')getc(),getc(),getc(),getc();
    if(c=='M'&&c2=='X')getc(),getc(),getc(),getc();
    return Twochar(c, c2);
} 

struct Complex{  
    int val,size;  
    bool change,reverse;  
    int change_into;  
    int sum;  
    int l,r,all;  
    Complex *son[2],*father;  
       
    bool Check() {  
        return father->son[1] == this;  
    }  
    void Combine(Complex *a,bool dir) {  
        son[dir] = a;  
        a->father = this;  
    }  
    void Reverse() {  
        reverse ^= 1;  
        swap(son[0],son[1]);  
        swap(l,r);  
    }  
    void Change(int x) {  
        val = x;  
        sum = x * size;  
        l = r = all = max(sum,val);  
        change = true;  
        change_into = x;  
    }  
}none,*nil = &none,*root = nil;  
   
void Pretreatment();  
inline Complex *NewComplex(int x);    
inline void Rotate(Complex *a,bool dir);  
inline void Splay(Complex *a,Complex *aim);  
Complex *BuildTree(int l,int r);  
inline void SplaySeg(int st,int ed);      
inline void PushUp(Complex *a);   
inline void PushDown(Complex *a);  
void Delete(Complex *a);  
Complex *FindK(Complex *a,int k);  
   
int cnt,asks;  
int pos,num;  
   
int temp[MAX];  
   
int main()  
{  
    cnt = getint();
    asks = getint();
    Pretreatment();  
    for(int i = 1;i <= cnt; ++i)   
        temp[i] = getint();
    root = BuildTree(0,cnt + 1);  
    root->father = nil; 

    Twochar s;
    for(int i = 1;i <= asks; ++i) {  
        s = getch();
        if(s.c0 == 'I' && s.c1 == 'S') {  
           pos=getint(),cnt=getint(),pos++;  
            for(int i = 1;i <= cnt; ++i)  
                temp[i]=getint();
            Splay(FindK(root,pos),nil);  
            Splay(FindK(root,pos + 1),root);  
            root->son[1]->Combine(BuildTree(1,cnt),false);  
            PushUp(root->son[1]),PushUp(root);  
        }  
        else if(s.c0 == 'D' && s.c1 == 'L') {  
            pos=getint(),cnt=getint();
            SplaySeg(pos,pos + cnt - 1);  
            Delete(root->son[1]->son[0]);  
            root->son[1]->son[0] = nil;  
            PushUp(root->son[1]),PushUp(root);  
        }  
        else if(s.c0 == 'M' && s.c1 == 'K') {  
            pos=getint(),cnt=getint(),num=getint();
            SplaySeg(pos,pos + cnt - 1);  
            root->son[1]->son[0]->Change(num);  
            PushUp(root->son[1]),PushUp(root);             
        }  
        else if(s.c0 == 'R' && s.c1 == 'V') {  
            pos=getint(),cnt=getint(); 
            SplaySeg(pos,pos + cnt - 1);  
            root->son[1]->son[0]->Reverse();  
            PushUp(root->son[1]),PushUp(root);             
        }  
        else if(s.c0 == 'G' && s.c1 == 'T') {  
            pos=getint(),cnt=getint(); 
            SplaySeg(pos,pos + cnt - 1);  
            printf("%d\n",root->son[1]->son[0]->sum);  
        }  
        else if(s.c0 == 'M' && s.c1 == 'X') {  
            int temp = root->size;  
            Splay(FindK(root,1),nil);  
            Splay(FindK(root,temp),root);  
            printf("%d\n",root->son[1]->son[0]->all);  
        }  
    }  
    return 0;  
}  
   
void Pretreatment()  
{  
    nil->son[0] = nil->son[1] = nil;  
    nil->father = nil;  
    nil->size = 0;  
    nil->all = -INF;  
    temp[0] = temp[cnt + 1] = -INF;  
}  
   
inline Complex *NewComplex(int x)  
{  
    Complex *re = new Complex();  
    re->son[0] = re->son[1] = nil;  
    re->size = 1;  
    re->sum = re->l = re->r = re->all = re->val = x;  
    re->change = re->reverse = false;  
    return re;  
}  
   
inline void Rotate(Complex *a,bool dir)  
{  
    Complex *f = a->father;  
    PushDown(f),PushDown(a);  
    f->son[!dir] = a->son[dir];  
    f->son[!dir]->father = f;  
    a->son[dir] = f;  
    a->father = f->father;  
    f->father->son[f->Check()] = a;  
    f->father = a;  
    PushUp(f);  
    if(root == f)   root = a;  
}  
   
inline void Splay(Complex *a,Complex *aim)  
{  
    while(a->father != aim) {  
        if(a->father->father == aim)   
            Rotate(a,!a->Check());  
        else if(!a->father->Check()) {  
            if(!a->Check()) {  
                Rotate(a->father,true);  
                Rotate(a,true);  
            }  
            else {  
                Rotate(a,false);  
                Rotate(a,true);  
            }  
        }  
        else {  
            if(a->Check()) {  
                Rotate(a->father,false);  
                Rotate(a,false);  
            }  
            else {  
                Rotate(a,true);  
                Rotate(a,false);  
            }  
        }  
    }
    PushUp(a);   
}  
   
Complex *BuildTree(int l,int r)  
{  
    if(l > r)    return nil;  
    int mid = (l + r) >> 1;  
    Complex *now = NewComplex(temp[mid]);  
    now->Combine(BuildTree(l,mid - 1),false);  
    now->Combine(BuildTree(mid + 1,r),true);  
    if(l != r)  
        PushUp(now);  
    return now;  
}  
   
void Delete(Complex *a)  
{  
    if(a == nil)    return ;  
    Delete(a->son[0]),Delete(a->son[1]);  
    free(a);  
}  
   
inline void SplaySeg(int st,int ed)  
{  
    st += 1,ed += 1;  
    Splay(FindK(root,st - 1),nil);  
    Splay(FindK(root,ed + 1),root);  
}  
   
Complex *FindK(Complex *a,int k)  
{  
    PushDown(a);  
    if(k <= a->son[0]->size)  
        return FindK(a->son[0],k);  
    k -= a->son[0]->size;  
    if(k == 1)  return a;  
    --k;  
    return FindK(a->son[1],k);  
}  
   
inline void PushDown(Complex *a)  
{  
    if(a == nil)    return ;  
    if(a->change) {  
        if(a->son[0] != nil)  
            a->son[0]->Change(a->change_into);  
        if(a->son[1] != nil)  
            a->son[1]->Change(a->change_into);  
        a->change = false;  
    }  
    if(a->reverse) {  
        if(a->son[0] != nil)  
            a->son[0]->Reverse();  
        if(a->son[1] != nil)  
            a->son[1]->Reverse();  
        a->reverse = false;  
    }  
}  
   
inline void PushUp(Complex *a)  
{  
    if(a == nil)    return ;  
    a->size = a->son[0]->size + a->son[1]->size + 1;  
    a->sum = a->son[0]->sum + a->son[1]->sum + a->val;  
    a->l = max(a->son[0]->l,a->son[0]->sum + a->val + max(0,a->son[1]->l));  
    a->r = max(a->son[1]->r,a->son[1]->sum + a->val + max(0,a->son[0]->r));  
    a->all = max(max(a->son[0]->all,a->son[1]->all),a->val+max(0,a->son[0]->r)+max(0,a->son[1]->l));  
}



16bit戦争
关注
专栏目录
bzoj 1500 NOI2005 维修数列 [Splay]
C'est la vie.
08-02 492
维修数列Time Limit: 10 Sec Memory Limit: 64 MB Submit: 11839 Solved: 3724Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 376
Splay
BZOJ 1500 NOI2005 维修数列 Splay
世界
09-18 1861
我尽力了。。。从之前的递归版Splay变成非递归，然后各种删除冗余的操作，除了蛋疼的读入优化基本已经精简到底了，连传参都省了-0- 刚交上去是10956MS，差4MS就是BZOJ倒数第一，改完了是9244MS，快了一秒。。。单点测还是死活过不去，等加上读入优化再说吧 题目大意：维护一个序列，支持六种操作： 1.在某个数后面插入一些数字 2.删除从某个数开始的一些数字 3.把从某个数开始的一
[BZOJ1500]NOI2005 维修数列|splay
Tag_king的专栏
04-18 1920
这题号称是noi出过最变态的数据结构题，，感觉还差不多嘛。。一开始我一直在纠结splay上的节点一点要有一个key值的啊，要是以这个数在序列中的位置作为key值的话又要插入又要删除肯定弄不了。。然后想了很久突然顿悟。。貌似我给一个初始顺序以后是不用访问key的&&找第k位的数只要写一个findkth就行了嘛。。（当时太弱） 然后我就一口气写了下来。。 对每个节点维护size，sum，maxsu
BZOJ1500 NOI2005 维修数列 平衡树
a18700013354的博客
02-26 114
题意：给定一个数列，要求维护：1、在p之后加入tot个数 2、删除p之后tot个数 3、将p之后tot个数修改为c 4、翻转p之后tot个数 5、输出p之后tot个数的和 6、输出整个数列的最大子段和。 题解：平衡树很经典的题目了……主要说一下4和6操作，4的话因为翻转操作是可以分治的，所以可以用翻转标记；6我们维护一个节点所维护的区间的的最大子段和ms、从左开始的最大子段和...
【BZOJ】1500: [NOI2005]维修数列-splay
远行客
12-05 156
splay模板
NOI2005 维护数列
Holylight_Knight
10-10 655
NOI2005 维护数列tags :【Splay】,【BZOJ1500】,【洛谷2042】在线评测地址：洛谷，大视野题目描述1500: [NOI2005]维修数列Time Limit: 10 Sec Memory Limit: 64 MBDescriptionInput输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，
BZOJ 题目整理
喵~
08-31 2342
现在要写一些题目。 现在已经做了：157题
BZOJ 1500 [NOI2005]维修数列 Splay
I'm Growing
05-17 464
Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。 插入的数字总数不超过4 000
splay伸展树 指针型 平衡树基本操作 序列维护 详细讲解+总结
anantheparty的博客
12-21 3526
转载请保留本博客源地址：http://blog.csdn.net/u011327397/article/details/53783700 本来是要去学lct，然后看到要用splay我又不会，就开始看splay了，然后发现splay艹起来特别爽，但是序列操作网上没看到有详讲的，理解的时候很多奇怪的问题（无限RE）再加上指针调试复杂度高，花了很多时间，就觉得来写一个讲解吧。
数据结构------队列（Java语言描述）
最新发布
2402_82356599的博客
11-14 160
队列是一种数据结构，它遵循先进先出的原则。就像排队买东西一样，先到的人先得到服务，先进入队列的数据元素先被取出。例如，在一个银行排队系统中，顾客按照到达的先后顺序排队等待办理业务。第一个进入队列（排队）的顾客会第一个被服务并离开队列。
【数据结构】实验二 单链表的基本操作
drt_0506的博客
11-14 218
1）根据输入的一系列整数，以0标志结束，用头插法建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。掌握链表基本操作的算法实现，以及对相应算法的性能分析。掌握线性表的链式存储结构的表示和实现方法。
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 926
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
weixin_42267411的博客
11-14 862
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
数据结构-查找以及效率分析
dametime_的博客
11-11 272
将被查概率高的放到靠前位置,可以提高查找成功的效率,但对于查找失败的情况需要从头看到尾,因为无序排列,根据实际情况选择不同的方式,经常查找成功可以考虑上图方式。折半查找的查找效率,绿色节点为查找成功,紫色为查找失败,一共11个结点,每一层结点的数量*查到该层结点需要的步数的综合/11就是成功的ASL,失败同理。因为右子树的节点数一定比左子树多1个或等于左子树的结点,所以当两个数折半查找,画出查找判断树,2结点在右子树。所以要想算出他们的查找效率,我们需要画出来对应的查找判定树(根据折半查找的思想画图)
优先级队列-PriorityQueue
qq_39203337的博客
11-14 292
无界队列，数据存储于内部数组中，数据采用堆(默认小顶锥)的组织形式。
C语言第十一周课——函数的调用
qq_58156721的博客
11-14 150
通过调用函数来实现二分法。通过调用函数来实现冒泡法。
数据结构-二叉树
wwwwwgery的博客
11-14 168
二叉树有左右儿子之分完美二叉树（满二叉树）除了最下面的没有儿子其他结点都有两个儿子，叶节点比较齐的，完全二叉树不是满二叉数允许缺失最后的结点满二叉树可以达到2^k-1边的总数=节点数-1。
Java中的排序算法：探索与比较
Java小吕布的博客
11-11 946
Java中的排序算法种类繁多，每种算法都有其独特的原理和性能特点。在选择排序算法时，我们需要根据具体的应用场景和数据特性来做出合适的选择。通过深入理解和比较这些排序算法，我们可以更好地掌握Java中的数据处理和分析技巧。
【数据结构】AVL树
2302_80026357的博客
11-11 337
本文主要介绍了数据结构中的AVL树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值