[bzoj3153] sone1 AC纪念

最新推荐文章于 2019-09-18 20:51:31 发布
最新推荐文章于 2019-09-18 20:51:31 发布
阅读量1.4k 收藏
点赞数 3
分类专栏： 题解 LCT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy20130630/article/details/77127043
版权
题解 同时被 2 个专栏收录
186 篇文章 0 订阅
订阅专栏
LCT
2 篇文章 0 订阅
订阅专栏

bzoj3153 sone1

历时两天A掉此题，特作纪念。

代码
#include <bits/stdc++.h>

typedef long long LL;

#define FOR(i, a, b) for (int i = (a), i##_END_ = (b); i <= i##_END_; i++)
#define DNF(i, a, b) for (int i = (a), i##_END_ = (b); i >= i##_END_; i--)

template <typename Tp> void in(Tp &x) {
    char ch = getchar(), f = 1; x = 0;
    while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
    if (ch == '-') f = -1, ch = getchar();
    while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
    x *= f;
}

template <typename Tp> bool chkmax(Tp &x, Tp y) {return x > y ? 0 : (x=y,1);}
template <typename Tp> bool chkmin(Tp &x, Tp y) {return x < y ? 0 : (x=y,1);}
template <typename Tp> Tp Max(Tp x, Tp y) {return x > y ? x : y;}
template <typename Tp> Tp Min(Tp x, Tp y) {return x < y ? x : y;}

const int MAXN = 200010;

struct Tag {
    int k, b;

    Tag(int k = 1, int b = 0): k(k), b(b) {} 

    Tag run(const Tag &another) const {
        return Tag(k * another.k, b * another.k + another.b);
    }
};

struct Data {
    int minx, maxx, sum, sz;

    Data(int sz = 0, int minx = 0x3f3f3f3f, int maxx = -0x3f3f3f3f, int sum = 0)
        :minx(minx), maxx(maxx), sum(sum), sz(sz) {}

    Data run(const Tag &another) const {
        if (minx > maxx) return *this;

        Data ret;
        ret.sum = sum * another.k + sz * another.b;
        ret.sz = sz;

        if (another.k < 0) {
            ret.minx = another.k * maxx + another.b;
            ret.maxx = another.k * minx + another.b;
        }

        else {
            ret.maxx = another.k * maxx + another.b;
            ret.minx = another.k * minx + another.b;
        }

        return ret;
    }

    Data run(const Data &another) const {
        Data ret;
        if (minx > maxx) return another;
        if (another.minx > another.minx) return *this;
        ret.sz = sz + another.sz;
        ret.sum = sum + another.sum;
        ret.minx = Min(minx, another.minx);
        ret.maxx = Max(maxx, another.maxx);
        return ret;
    }
};

struct Node {
    bool inner;
    bool is_rev;
    Node *ch[4], *fa;
    Tag tag_chain, tag_sub;
    Data data_chain, data_sub, data_all, my;

    void pushdown();
    void update();

    void add();
    void del();

    void push();
    void pushO();
    void pushI();

    void splayO();
    void splayI();
    void rotate(int);
    void access(bool=false);

    bool is_top_out();
    bool is_top_inn();

    void makerot();

    void push_rev();
    void push_tag_chain(Tag);
    void push_tag_sub(Tag);
} *to[MAXN];

int n, m, rt;
int input[MAXN][2], w[MAXN];

int debug(Node *x)
{
    FOR(i, 1, n) if (x == to[i]) return i;
    return 0;
}

void Node::pushO()
{
    assert(!inner);
    if (!is_top_out()) fa -> pushO();
    pushdown();
}

void Node::pushI()
{
    //if (!inner) return;
    assert(inner);
    if (!is_top_inn()) fa -> pushI();
    pushdown();
}

void initialize()
{
    FOR(i, 1, n) {
        to[i] = new Node;
        to[i] -> ch[0] = to[i] -> ch[1] =
            to[i] -> ch[2] = to[i] -> ch[3] = NULL;
        to[i] -> fa = NULL;
        to[i] -> inner = false;
        to[i] -> is_rev = false;
        to[i] -> tag_chain = to[i] -> tag_sub = Tag();
        to[i] -> data_chain = to[i] -> data_sub = Data();
        to[i] -> my = Data(1, w[i], w[i], w[i]);
        to[i] -> data_all =
            to[i] -> my.run(to[i] -> data_chain).run(to[i] -> data_sub);
    }
}

void Node::push()
{
    if (fa) fa -> push(); pushdown();
}

bool Node::is_top_out()
{
    return !fa || fa -> ch[0] != this && fa -> ch[1] != this;
}

bool Node::is_top_inn()
{
    //printf("%d %d\n", inner, fa);
    //printf("%d\n", fa != NULL);
    return !fa -> inner;
}

void Node::add()
{
    Node *tmp = fa;
    while (tmp -> ch[3] != NULL && (tmp -> inner || tmp == fa)) {
        tmp -> pushdown();
        tmp = tmp -> ch[3];
    }

    if (tmp != fa) assert(!tmp -> inner);

    if (tmp == fa) tmp -> ch[3] = this;
    else {
        tmp -> fa -> ch[3] = new Node;

        Node *&x = tmp -> fa -> ch[3];
        x -> inner = true;
        x -> is_rev = false;
        x -> fa = tmp -> fa;
        x -> ch[0] = x -> ch[1] = NULL;
        x -> ch[2] = tmp; x -> ch[3] = this;

        tmp -> fa = fa = x;

        Node *tep = x;
        while (tep -> inner) {
            tep -> update(); tep = tep -> fa;
        }

        x -> splayI();
    }
}

void Node::del()
{
    int t = fa -> ch[2] == this ? 2 : 3;

    if (fa -> ch[t] != this) {
        assert(fa -> ch[t] == this);
    }

    if (fa -> inner) {
//      Node *tt = fa;
        fa -> pushI();

        Node *bro = fa -> ch[t ^ 1];
        bro -> fa = fa -> fa;
        int tt = bro -> fa -> ch[2] == fa ? 2 : 3;

        assert(bro -> fa -> ch[tt] == fa);

        bro -> fa -> ch[tt] = bro;
        Node *tep = bro -> fa;
        while (tep -> inner) {
            tep -> update(); tep = tep -> fa;
        }
        if (bro -> fa -> inner)
            bro -> fa -> splayI();
        delete fa;
    }

    else {
        fa -> pushdown();
        fa -> ch[t] = NULL;
    }
}

//不负责update，只负责pushdown
void Node::access(bool is)
{
    push();

    splayO(); pushdown();
    if (ch[1] != NULL) ch[1] -> add();

    ch[1] = NULL; update();

    Node *x = this;

    while (x -> fa != NULL) {
        Node *tmp = x -> fa;
        while (tmp -> inner) tmp = tmp -> fa;

        if (!is) x -> del();
        else is = false;

        //while (tmp -> inner) tmp = tmp -> fa;

        tmp -> splayO(); tmp -> pushdown();
        if (tmp -> ch[1] != NULL) tmp -> ch[1] -> add();

        x -> fa = tmp;
        tmp -> ch[1] = x; tmp -> update();

        x = tmp;
    }
}

void Node::rotate(int dir)
{
    Node *pa = fa; fa = pa -> fa;

    if (fa != NULL) {
        int t = (fa -> ch[0] == pa ? 0 :
                 (fa -> ch[1] == pa ? 1 : (fa -> ch[2] == pa ? 2 : 3)));
        fa -> ch[t] = this;
    }

    pa -> ch[dir] = ch[dir ^ 1];
    if (ch[dir ^ 1] != NULL) ch[dir ^ 1] -> fa = pa;
    ch[dir ^ 1] = pa; pa -> fa = this;

    pa -> update(); update();
}

void Node::splayO()
{
    assert(!inner);
    pushO();
    while (!is_top_out()) {
        int t1 = fa -> ch[0] == this ? 0 : 1;
        if (!fa -> is_top_out()) {
            int t2 = fa -> fa -> ch[0] == fa ? 0 : 1;
            if (t1 == t2) fa -> rotate(t1), rotate(t1);
            else rotate(t1), rotate(t2);
        }
        else rotate(t1);
    }
}

void Node::splayI()
{
    assert(inner);
    pushI();
    while (!is_top_inn()) {
        int t1 = fa -> ch[2] == this ? 2 : 3;
        if (!fa -> is_top_inn()) {
            int t2 = fa -> fa -> ch[2] == fa ? 2 : 3;
            if (t1 == t2) fa -> rotate(t1), rotate(t1);
            else rotate(t1), rotate(t2);
        }
        else rotate(t1);
    }
}

void Node::push_rev()
{
    is_rev ^= 1;
    std::swap(ch[0], ch[1]);
}

void Node::push_tag_chain(Tag x)
{
    tag_chain = tag_chain.run(x);

    my = my.run(x);
    data_chain = data_chain.run(x);
    data_all = my.run(data_sub).run(data_chain);
}

void Node::push_tag_sub(Tag x)
{
    tag_sub = tag_sub.run(x);
    //tag_chain = tag_chain.run(x);

    //my = my.run(x);
    data_sub = data_sub.run(x);
    //data_chain = data_chain.run(x);
    data_all = my.run(data_sub).run(data_chain);
}

void Node::update()
{
    data_sub = Data();
    if (ch[0] != NULL) data_sub = data_sub.run(ch[0] -> data_sub);
    if (ch[1] != NULL) data_sub = data_sub.run(ch[1] -> data_sub);
    if (ch[2] != NULL) data_sub = data_sub.run(ch[2] -> data_all);
    if (ch[3] != NULL) data_sub = data_sub.run(ch[3] -> data_all);

    data_chain = Data();
    if (ch[0] != NULL)
        data_chain = data_chain.run(ch[0] -> data_chain).run(ch[0] -> my);
    if (ch[1] != NULL)
        data_chain = data_chain.run(ch[1] -> data_chain).run(ch[1] -> my);

    data_all = my.run(data_sub).run(data_chain);
}

void Node::pushdown()
{
    if (is_rev) {
        if (ch[0] != NULL) ch[0] -> push_rev();
        if (ch[1] != NULL) ch[1] -> push_rev();
        is_rev = false;
    }

    {
        Tag &tag = tag_chain;

        if (tag.k != 1 || tag.b != 0) {
            if (ch[0] != NULL) ch[0] -> push_tag_chain(tag);
            if (ch[1] != NULL) ch[1] -> push_tag_chain(tag);
            tag = Tag(1, 0);
        }
    }

    {
        Tag &tag = tag_sub;

        if (tag.k != 1 || tag.b != 0) {
            if (ch[0] != NULL) ch[0] -> push_tag_sub(tag);
            if (ch[1] != NULL) ch[1] -> push_tag_sub(tag);

            if (ch[2] != NULL) {
                ch[2] -> push_tag_chain(tag);
                ch[2] -> push_tag_sub(tag);
            }
            if (ch[3] != NULL) {
                ch[3] -> push_tag_chain(tag);
                ch[3] -> push_tag_sub(tag);
            }

            tag = Tag(1, 0);
        }
    }
}

void Node::makerot()
{
    access(); splayO(); push_rev();
}

void link(Node *x, Node *y)
{
    y -> access(); y -> pushdown();
    x -> makerot(); x -> fa = y; x -> access(true);
}

void cut(Node *x, Node *y)
{
    x -> makerot(); y -> access(); y -> splayO();
    y -> pushdown(); x -> fa = y -> ch[0] = NULL; y -> update();
}

Node *find_rot(Node *x)
{
    x -> access(); x -> splayO(); x -> pushdown();
    while (x -> ch[0] != NULL) {
        x = x -> ch[0]; x -> pushdown();
    }
    return x;
}

int main()
{
    in(n); in(m);

    FOR(i, 1, n - 1) {
        in(input[i][0]); in(input[i][1]); 
    }

    FOR(i, 1, n) in(w[i]);

    initialize();

    in(rt);

    FOR(i, 1, n - 1) {
        link(to[input[i][0]], to[input[i][1]]);
    }

    FOR(i, 1, m) {
        int tp; in(tp);

        to[rt] -> makerot();

        //FOR(i, 1, n)
        //  to[i] -> access();

        //to[rt] -> splayO();

        //printf("%d\n", to[rt] -> data_all.sz);

        if (tp == 0) {
            int x, y; in(x); in(y);

            to[x] -> access(); to[x] -> splayO();

            if (x == rt) {
                to[x] -> push_tag_chain(Tag(0, y));
                to[x] -> push_tag_sub(Tag(0, y));
            }
            else {
                to[x] -> my = to[x] -> my.run(Tag(0, y));
                if (to[x] -> ch[3] != NULL) {
                    to[x] -> ch[3] -> push_tag_chain(Tag(0, y));
                    to[x] -> ch[3] -> push_tag_sub(Tag(0, y));
                }
                if (to[x] -> ch[2] != NULL) {
                    to[x] -> ch[2] -> push_tag_chain(Tag(0, y));
                    to[x] -> ch[2] -> push_tag_sub(Tag(0, y));
                }
                to[x] -> update();
            }
        }

        else if (tp == 1) {
            int x; in(x); rt = x;
        }

        else if (tp == 2) {
            int x, y, z; in(x); in(y); in(z);
            to[x] -> makerot(); to[y] -> access(); to[y] -> splayO();
            to[y] -> push_tag_chain(Tag(0, z));
        }

        else if (tp == 3) {
            int x; in(x); to[x] -> access();

            Data ret = Data();
            if (to[x] -> ch[2] != NULL) ret = ret.run(to[x] -> ch[2] -> data_all);
            if (to[x] -> ch[3] != NULL) ret = ret.run(to[x] -> ch[3] -> data_all);
            ret = ret.run(to[x] -> my);

            printf("%d\n", ret.minx);
        }

        else if (tp == 4) {
            int x; in(x); to[x] -> access();

            Data ret = Data();
            if (to[x] -> ch[2] != NULL) ret = ret.run(to[x] -> ch[2] -> data_all);
            if (to[x] -> ch[3] != NULL) ret = ret.run(to[x] -> ch[3] -> data_all);
            ret = ret.run(to[x] -> my);

            printf("%d\n", ret.maxx);
        }

        else if (tp == 5) {
            int x, y; in(x); in(y);

            to[x] -> access(); to[x] -> splayO();

            if (x == rt) {
                to[x] -> push_tag_chain(Tag(1, y));
                to[x] -> push_tag_sub(Tag(1, y));
            }
            else {
                to[x] -> my = to[x] -> my.run(Tag(1, y));
                if (to[x] -> ch[2] != NULL) {
                    to[x] -> ch[2] -> push_tag_chain(Tag(1, y));
                    to[x] -> ch[2] -> push_tag_sub(Tag(1, y));
                }
                if (to[x] -> ch[3] != NULL) {
                    to[x] -> ch[3] -> push_tag_chain(Tag(1, y));
                    to[x] -> ch[3] -> push_tag_sub(Tag(1, y));
                }
                to[x] -> update();
            }
        }

        else if (tp == 6) {
            int x, y, z; in(x); in(y); in(z);
            to[x] -> makerot(); to[y] -> access(); to[y] -> splayO();
            to[y] -> push_tag_chain(Tag(1, z));
        }

        else if (tp == 7) {
            int x, y; in(x); in(y);
            to[x] -> makerot(); to[y] -> access(); to[y] -> splayO();
            printf("%d\n", to[y] -> my.run(to[y] -> data_chain).minx);
        }

        else if (tp == 8) {
            int x, y; in(x); in(y);
            to[x] -> makerot(); to[y] -> access(); to[y] -> splayO();
            printf("%d\n", to[y] -> my.run(to[y] -> data_chain).maxx);
        }

        else if (tp == 9) {
            int x, y; in(x); in(y);

            to[y] -> access(); to[x] -> access();
            to[x] -> splayO(); to[x] -> pushdown();

            if (to[x] -> ch[0] == NULL) continue;
            else {
                to[y] -> access(); to[y] -> splayO();

                Node *tmp = to[x];
                while (!tmp -> is_top_out()) tmp = tmp -> fa;

                if (tmp == to[y]) continue;

                to[x] -> access(); to[x] -> splayO(); to[x] -> pushdown();
                tmp = to[x] -> ch[0]; tmp -> pushdown();
                while (tmp -> ch[1] != NULL) {tmp = tmp -> ch[1]; tmp -> pushdown();}

                cut(to[x], tmp); link(to[x], to[y]);
            }
        }

        else if (tp == 10) {
            int x, y; in(x); in(y);
            to[x] -> makerot(); to[y] -> access(); to[y] -> splayO();
            printf("%d\n", to[y] -> my.run(to[y] -> data_chain).sum);
        }

        else if (tp == 11) {
            int x; in(x); to[x] -> access(); //to[x] -> splayO();

            Data ret = Data();
            if (to[x] -> ch[2] != NULL) ret = ret.run(to[x] -> ch[2] -> data_all);
            if (to[x] -> ch[3] != NULL) ret = ret.run(to[x] -> ch[3] -> data_all);
            ret = ret.run(to[x] -> my);

            printf("%d\n", ret.sum);
        }
    }

    return 0;
}
XY20130630
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ3153 Sone1 （Toptree）
BIT_shenyunhan的博客
03-07 2915
上周看Lytning（鄙校一队某大佬）开了一个LCT的专题，里面有这个题，正好我也没怎么写过LCT维护子树的题，就决定拿这个题开刀。先来说说LCT维护子树的大致思路，LCT里的轻边在Splay里都是只有儿子指向父亲但是父亲不指向儿子的虚边，如果维护的是树链，只用维护Splay里的实边，但是维护子树的话只要把每个节点的虚边也维护一下就行了。我之前只写过不带修改的子树维护，不带修改只要把虚子树信息向上...
【(伪)Top tree】【BZOJ3153 Sone1 题解】
退役狗的专栏
02-05 8714
有什么错误欢迎指出,只求轻喷…… 很久以前在众多神犇的鄙视下找到了论文和代码啃了起来 由于要准备期末考试于是没有多少时间看但又突然不用期末考试了于是就开始看了唔好像扯得有点远而且一口气读完一长串没有标点符号的句子一定会比很累吧所以就不多扯了 首先是AAA树和top tree和self-adjust toptree到底哪个是哪个的问题 = = 找到了杜教、翱犇
【BZOJ3153】—Sone1（Top-Tree）
Stargazer的博客
09-18 1131
传送门 AC这道超级工业题留念 由于LctLctLct并不能支持子树操作，所以有了这种神奇的数据结构 好像实际上是叫AAAAAAAAA树 我也不清楚实际上和Top−TreeTop-TreeTop−Tree有啥区别… 大致思想就是在LctLctLct上每个节点222个儿子变成四个儿子 多的2个作为另外一颗splaysplaysplay的根的左右儿子 这个splaysplaysplay用来维护所有虚儿...
BZOJ3153 : Sone1
weixin_33885253的博客
05-12 124
Top Tree模板题，写起来真不是一般的蛋疼，调了两天。常数写渣了TAT   Top Tree就是在LCT的基础上加以改动，将虚边也用splay维护， 对于A向儿子所连出去的虚边，用Splay维护↓ 为了保证所有虚儿子不存在父子关系，需要让它们都是叶子节点，所以需要引入白色的内部点来维持这个结构。 就能支持子树操作了。 对于这样一棵以1为根的树。 在Top Tree...
[bzoj3153] sone1 - toptree
liuzhangfeiabc的博客
09-12 2779
传送门：https://www.lydsy.com/JudgeOnline/problem.php?id=3153。 AC这道超级工业题留念。花了我整整一个下午写代码+一个上午调代码…… 题目大意：维护一棵有点权的有根树，支持：linkcut，换根，对子树/链的赋值/加/询问sum/min/max。 一看12个操作就知道是大毒瘤题。 话说前几天我们某场校内模拟赛有位学长直接搬了这题原题上去...
【(伪)Top tree】【BZOJ3153 Sone1 题解】-附件资源
03-05
【(伪)Top tree】【BZOJ3153 Sone1 题解】-附件资源
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ第一部分
11-03
1. **基础编程语言**：BZOJ支持C、C++、Java、Python等多种编程语言，理解每种语言的基本语法和特性是必不可少的。 2. **数据结构**：数组、链表、栈、队列、树、图、哈希表等是解决问题的基础工具，熟练运用它们能...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
BZOJ3153 sone1
weixin_30755393的博客
04-09 299
原文链接www.cnblogs.com/zhouzhendong/p/BZOJ3153.html 题解 直接用splay维护虚子树。 细节真多。 暂时还不会证明。 可能是一个log或者两个log。 先咕一咕，等证明它挂了或者证明它是对的或者我弃疗不证明了再更新。 UPD(2019-04-10)：弃疗了证不出来不证了。只能证出复杂度上限是 $O(n\log ^2n)$ 的。14年论...
sone1动态树
weixin_30241919的博客
09-09 112
这尼吗桑心病狂的动态树：http://www.lydsy.com/JudgeOnline/problem.php?id=3153 终于让哥以一种碉堡的姿势过了： 牛B轰轰的最后两个都是我的。。。无法超越了。。。 转载于:https://www.cnblogs.com/Fatedayt/p/3310729.html...
【TOP-TREE】BZOJ3153 Sone1
MEET YOU FIRST TIME
04-08 590
【前言】 被拉过来做这个题，但是我根本不会。 最后强行写了写不过啊，半抄半改过了。 有一些不错的收获，比如重载运算符的各种细节吧，还有一些实现上的细节，标记细节。 浪费了一些时间。 【题目】 lydsy 给定一棵nnn个点的带点权树，QQQ次操作，支持：换根，链/子树权值修改，链/子树权值加，链/子树查询min,max,sum\text{min,max,sum}min,max,sum，换父亲。 n...
bzoj 3153: Sone1 Toptree
alex151194310的博客
05-12 196
3153: Sone1 Time Limit: 40 SecMemory Limit: 256 MBSubmit: 511Solved: 202[Submit][Status][Discuss] Description Sxyz里有一群sx。 在花老师的指导下，每周4都有一个集会活动，俗称“浇水”活动。 为了让花老师开花，这群sx都很努力地发言。 一次xbj对...
【BZOJ】【P3236】【Ahoi2013】【作业】【题解】【莫队】
退役狗的专栏
11-17 1353
传送门:http://www.lydsy.com/JudgeOnline/problem.php?id=3236
synchronized-4月5日.md
07-06
synchronized-4月5日.md
场景化落地应用推进制造企业数字化转型两套文档.pptx
07-05
场景化落地应用推进制造企业数字化转型两套文档.pptx
1111111111111111111111111111111
07-06
1111111111111111111111111111111
大型企业数字化转型管控平台解决方案两套材料.pptx
07-05
大型企业数字化转型管控平台解决方案两套材料.pptx
maven下载、安装、配置与使用教程&相关项目
最新发布
07-06
【maven】下载、安装、配置与使用教程&相关项目
BZOJ JOI 2013~2014 春季training合宿 系列题解1
08-04
"BZOJ JOI 2013~2014 春季training合宿 系列题解1" 这篇题解涉及到的是一个编程竞赛中的题目，主要运用了哈希算法来解决。哈希算法在计算机科学中是一种高效的数据结构和算法，它能够快速查找、插入和删除元素，其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值