[LOJ 2134][UOJ 132][BZOJ 4200][NOI 2015]小园丁与老司机

最新推荐文章于 2024-11-10 16:16:35 发布
最新推荐文章于 2024-11-10 16:16:35 发布
阅读量110 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/rvalue/p/11028922.html
版权

[LOJ 2134][UOJ 132][BZOJ 4200][NOI 2015]小园丁与老司机

题意

给定平面上的 \(n\) 个整点 \((x_i,y_i)\), 一共有两个问题.

第一个问题是从原点 \((0,0)\) 出发, 在只能向←↖↑↗→五个方向中有未到达的点的方向走且在没有到达一个点的时候不能中途转弯的情况下最多能到达的点数, 并输出一种可行方案.

第二个问题是如果用若干可以从任意点出发但是只能向↖↑↗方向沿着所有可能出现在最优解的直线上走的压路机将所有可能出现在最优解上的边都走过至少一遍所需要的最少的压路机数量.

\(n\le 50000,|x_i|\le 10^9,0<y_i\le 10^9\)

题解

农业题真tm劲啊

第一个问题相当于一个有特殊限制的分层图最长路.

显然走的时候 \(y\) 值是单调不降的, 我们可以从小到大枚举 \(y\) 坐标分层计算.

同一层的时候假设在 \(s\) 处进入, 从 \(t\) 处离开, 那么最优策略一定是先走到这一层中对 \(t\) 的对侧端点然后再回来. 我们设 \(f^{[1]}_i\) 为从原点走到 \(i\) 的最长路, \(f^{[2]}_i\) 为上一层中可以走到点 \(i\) 的点中最大的 \(f^{[1]}\), 即进入当前层之前的最长路.

因为↖↑↗三个方向能移动到的位置分别保持 \(x+y\), \(x\), \(x-y\) 相等, 于是可以全局维护一个哈希表或者 map 来维护 \(f^{[2]}_i\). 如果以前没有出现过相等位置则贡献为 \(-\infty\). 原点的贡献为 \(0\).

从 \(f^{[2]}\) 计算 \(f^{[1]}\) 则可以分类讨论, \(s=t\) 时是平凡情况, 注意这里到达后这个点会变成已到达的, 如果要访问同一层的其他点就会回不来, 于是这里直接等于 \(f^{[2]}_i+1\). 剩下的情况一个是 \(s<t\), 一个是 \(s>t\).

\(s<t\) 的时候可以访问到 \(t\) 左侧的所有点, \(s>t\) 的时候可以访问到 \(t\) 右侧的所有点, 显然这个贡献和 \(s\) 无关, 正反扫一遍记录一下前后缀最大的 \(f^{[2]}_i\) 就好了.

以上贡献的时候都需要维护一个 pair, 第一关键字是DP值, 第二关键字是来源. 用 pair 可以节省额外的记录方案代码. 注意 \(f^{[1]}_i\) 的来源记录的是同层的 \(s\) 的位置, \(f^{[2]}_i\) 的来源记录的是上一层的 \(t\) 的位置.

输出方案的时候处理一下同一层的特判一下 \(s=t\) 的情况第一个问题就做完了.

第二个问题依然比较恶心

下界最小流的模型很显然就不说了. 关键在于把这个图建出来. 因为它问的是所有可能出现在最优解的直线.

如果 \(u\) 沿↖↑↗三个方向可以到达 \(v\), 那么只要原点到 \(u\) 的最长路和 \(v\) 出发的最长路之和与第一问的答案相等就可以出现在最优解上. 那么就需要计算出从某个点出发的最长路的长度.

这个DP和第一问类似, 不再赘述. 不过这次可以在任意位置结束, 所以没有后继的时候贡献是 \(0\) 而不是 \(-\infty\).

最后注意一下不要写假Dinic...这题数据范围比较大, 假复杂度的Dinic很容易被卡...我猜Po姐就是因为写了假Dinic才没有阿克Day2的然而神仙Po姐实际上写了个费用流

参考代码

一杯茶, 一包烟, 一个破题调一天

#include <bits/stdc++.h>

const int MAXV=50010;
const int MAXN=50010;
const int MAXE=1e7+10;
const int INF=0x7FFFFFFF;
typedef std::pair<int,int> Pair;

struct Edge{
    int from;
    int to;
    int flow;
    bool blk;
    Edge* rev;
    Edge* next;
};
Edge E[MAXE];
Edge* head[MAXV];
Edge* cur[MAXV];
Edge* top=E;

int n;
int ycnt;
int s[MAXN];
Pair a[MAXN];
int id[MAXN];
int bk1[MAXN];
int bk2[MAXN];
Pair fw1[MAXN];
Pair fw2[MAXN];
int depth[MAXV];
std::map<int,int> bkX;
std::map<int,int> bkN;  // x+y fixed
std::map<int,int> bkZ;  // x-y fixed
std::map<int,Pair> fwX;
std::map<int,Pair> fwN; // x+y fixed
std::map<int,Pair> fwZ; // x-y fixed
std::vector<Pair> pos[MAXN];
std::pair<Pair,int> P[MAXN];

int ReadInt();
int GetB(int);
Pair GetF(int);
bool BFS(int,int);
int Dinic(int,int);
int DFS(int,int,int);
void UpdateF(int,int);
void UpdateB(int,int);
Edge* Insert(int,int,int);

int main(){
    n=ReadInt();
    for(int i=1;i<=n;i++){
        a[i].first=P[i].first.first=ReadInt();
        s[i]=a[i].second=P[i].first.second=ReadInt();
        P[i].second=i;
    }
    std::sort(s+1,s+n+1);
    std::sort(P+1,P+n+1);
    ycnt=std::unique(s+1,s+n+1)-(s+1);
    for(int i=1;i<=n;i++)
        pos[std::lower_bound(s+1,s+ycnt+1,P[i].first.second)-s].emplace_back(P[i].first.first,P[i].second);
    pos[0].emplace_back(0,0);
    UpdateF(0,0);
    Pair ans;
    for(int i=1;i<=ycnt;i++){
        for(size_t j=0;j<pos[i].size();j++){
            int x=pos[i][j].second;
            auto p=GetF(x);
            fw2[x]=p;
            fw1[x]=Pair(p.first+1,x);
        }
        auto maxf=Pair(INT_MIN,0);
        for(size_t j=0;j<pos[i].size();j++){
            int p=pos[i][j].second;
            id[p]=j;
            fw1[p]=std::max(fw1[p],Pair(maxf.first+j+1,maxf.second));
            if(fw2[p].first>=0)
                maxf=std::max(maxf,Pair(fw2[p].first,p));
        }
        maxf=Pair(INT_MIN,0);
        for(size_t j=pos[i].size()-1;j<pos[i].size();j--){
            int p=pos[i][j].second;
            fw1[p]=std::max(fw1[p],Pair(maxf.first+(pos[i].size()-j),maxf.second));
            if(fw2[p].first>=0)
                maxf=std::max(maxf,Pair(fw2[p].first,p));
            UpdateF(p,fw1[p].first);
            ans=std::max(ans,Pair(fw1[p].first,p));
        }
    }
    int bkans=0;
    for(int i=ycnt;i>=1;i--){
        for(size_t j=0;j<pos[i].size();j++){
            int x=pos[i][j].second;
            bk2[x]=GetB(x);
            bk1[x]=bk2[x]+1;
        }
        int maxb=0;
        for(size_t j=0;j<pos[i].size();j++){
            int p=pos[i][j].second;
            bk1[p]=std::max(bk1[p],maxb);
            maxb=std::max(maxb,int(bk2[p]+(pos[i].size()-j)));
        }
        maxb=0;
        for(size_t j=pos[i].size()-1;j<pos[i].size();j--){
            int p=pos[i][j].second;
            bk1[p]=std::max(bk1[p],maxb);
            maxb=std::max(maxb,int(bk2[p]+j+1));
            UpdateB(p,bk1[p]);
            bkans=std::max(bkans,bk1[p]);
        }
    }
    printf("%d\n",ans.first);
    std::vector<int> sol;
    for(int cur=ans.second;cur!=0;){
        sol.push_back(cur);
        int i=std::lower_bound(s+1,s+ycnt+1,a[cur].second)-s;
        if(fw1[cur].second!=cur){
            int next=fw1[cur].second;
            if(id[next]<id[cur]){
                for(int j=id[cur]-1;j>id[next];j--)
                    sol.push_back(pos[i][j].second);
                for(int j=0;j<=id[next];j++)
                    sol.push_back(pos[i][j].second);
            }
            else{
                for(int j=id[cur]+1;j<id[next];j++)
                    sol.push_back(pos[i][j].second);
                for(int j=pos[i].size()-1;j>=id[next];j--)
                    sol.push_back(pos[i][j].second);
            }
            cur=fw1[cur].second;
        }
        cur=fw2[cur].second;
    }
    for(int i=ans.first-1;i>=0;i--)
        printf("%d%c",sol[i]," \n"[i==0]);
    bkX.clear();
    bkN.clear();
    bkZ.clear();
    int ss=n+1,tt=n+2,s=n+3,t=n+4;
    Edge* Ex;
    std::vector<Edge*> aux;
    aux.push_back(Ex=Insert(t,s,INF));
    for(int i=0;i<=n;i++){
        Insert(s,i,INF);
        Insert(i,t,INF);
    }
    auto check=[=,&aux](int r,int k){
        if(fw1[r].first+bk1[k]==ans.first){
            Insert(r,k,INF);
            aux.push_back(Insert(ss,k,1));
            aux.push_back(Insert(r,tt,1));
        }
    };
    for(int i=ycnt;i>=0;i--){
        for(auto p:pos[i]){
            int x,y,r=p.second;
            std::tie(x,y)=a[r];
            if(bkX.count(x))
                check(r,bkX[x]);
            if(bkN.count(x+y))
                check(r,bkN[x+y]);
            if(bkZ.count(x-y))
                check(r,bkZ[x-y]);
            bkX[x]=r;
            bkN[x+y]=r;
            bkZ[x-y]=r;
        }
    }
    Dinic(ss,tt);
    for(auto p:aux)
        p->blk=p->rev->blk=true;
    int flow=Ex->rev->flow;
    flow-=Dinic(t,s);
    printf("%d\n",flow);
    return 0;
}

int GetB(int i){
    int ans=0;
    int x=a[i].first;
    int y=a[i].second;
    if(bkX.count(x))
        ans=std::max(ans,bkX[x]);
    if(bkN.count(x+y))
        ans=std::max(ans,bkN[x+y]);
    if(bkZ.count(x-y))
        ans=std::max(ans,bkZ[x-y]);
    return ans;
}

void UpdateB(int i,int d){
    if(d<0)
        return;
    int x=a[i].first;
    int y=a[i].second;
    auto f=[](int& x,int d){x=std::max(x,d);};
    f(bkX[x],d);
    f(bkN[x+y],d);
    f(bkZ[x-y],d);
}

Pair GetF(int i){
    int x=a[i].first;
    int y=a[i].second;
    Pair ans(INT_MIN,0);
    if(fwX.count(x))
        ans=std::max(ans,fwX[x]);
    if(fwN.count(x+y))
        ans=std::max(ans,fwN[x+y]);
    if(fwZ.count(x-y))
        ans=std::max(ans,fwZ[x-y]);
    return ans;
}

void UpdateF(int i,int d){
    if(d<0)
        return;
    int x=a[i].first;
    int y=a[i].second;
    auto p=Pair(d,i);
    auto f=[](Pair& x,Pair d){x=std::max(x,d);};
    f(fwX[x],p);
    f(fwN[x+y],p);
    f(fwZ[x-y],p);
}

int Dinic(int s,int t){
    int ans=0;
    while(BFS(s,t))
        ans+=DFS(s,INF,t);
    return ans;
}

bool BFS(int s,int t){
    memset(depth,0,sizeof(depth));
    std::queue<int> q;
    cur[s]=head[s];
    depth[s]=1;
    q.push(s);
    while(!q.empty()){
        s=q.front();
        q.pop();
        for(Edge* i=head[s];i!=NULL;i=i->next){
            if(!i->blk&&i->flow>0&&depth[i->to]==0){
                depth[i->to]=depth[s]+1;
                cur[i->to]=head[i->to];
                if(i->to==t)
                    return true;
                q.push(i->to);
            }
        }
    }
    return false;
}

int DFS(int s,int flow,int t){
    if(s==t||flow<=0)
        return flow;
    int rest=flow;
    for(Edge*& i=cur[s];i!=NULL;i=i->next){
        if(!i->blk&&i->flow>0&&depth[i->to]==depth[s]+1){
            int tmp=DFS(i->to,std::min(rest,i->flow),t);
            if(tmp<=0)
                depth[i->to]=0;
            rest-=tmp;
            i->flow-=tmp;
            i->rev->flow+=tmp;
            if(rest<=0)
                break;
        }
    }
    return flow-rest;
}

inline Edge* Insert(int from,int to,int flow){
    Edge* ret=top;
    top->from=from;
    top->to=to;
    top->flow=flow;
    top->blk=false;
    top->rev=top+1;
    top->next=head[from];
    head[from]=top++;

    top->from=to;
    top->to=from;
    top->flow=0;
    top->blk=false;
    top->rev=top-1;
    top->next=head[to];
    head[to]=top++;
    return ret;
}

inline int ReadInt(){
    int x=0;
    int sgn=1;
    register char ch=getchar();
    while(!isdigit(ch)){
        sgn=(ch=='-'?-sgn:sgn);
        ch=getchar();
    }
    while(isdigit(ch)){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*sgn;
}

o_59995658_p0.png

转载于:https://www.cnblogs.com/rvalue/p/11028922.html

weixin_30483495
关注
洛谷 4343 loj 2036 bzoj 4590 [SHOI2015]自动刷题机 题解
LightningUZ的博客
12-08 191
博客观赏效果更佳 题意简述 有一个刷题机，记录了这样的信息：有一个长度为n<=1e5n<=1e5n<=1e5的序列aaa，表示写（>0）或删（<0）了若干行代码。如果删除的代码行数超过了已有的代码行数，那就是保持为000行代码。每当你的代码行数>m>m>m之后，你就会自动AC一个题，代码清空。现在已知你AC了kkk个题。求mmm的范围。无解输出-1....
【BZOJ4200】【LOJ2134】【NOI2015】小园丁与老司机（DP，有源汇上下界最小流）
დ♂Hany01's Blog Space♂ღ
07-24 441
Description https://loj.ac/problem/2134 Solution Task 1 考虑将所有点以yyy为第一关键字、xxx为第二关键字排序。yyy坐标相同的点放在一起DP。 记录两个前驱。一个是在本行的前驱，如果无需跳到别的点，那么前驱等于自己；另一个是下一行的前驱。DFS一遍就可以把路径找出来了。 Task 2 要求选最少的路径遍历所有的边，直...
*LOJ#2134. 「NOI2015」小园丁与老司机
a2850363633的博客
07-10 165
$n \leq 5e4$个平面上的点，从原点出发，能从当前点向左、右、上、左上或右上到达该方向最近的给定点。问三个问：一、最多经过多少点；二、前一问的方案；三、其所有方案种非左右走的边至少要开几辆挖掘机走完，挖掘机能从任意点出发，走路方式跟上面一样。 前两问： 纵坐标是增的可在不同层之间直接dp。同层的话，如果从左边的点x到一个右边的点y，那最优情况是x往左走，走到不能走再往右，直到...
[BZOJ4200][NOI2015]小园丁与老司机
abcyan1235的博客
07-08 104
bzoj luogu loj上可以交部分分程序 description 小园丁 Mr. S 负责看管一片田野，田野可以看作一个二维平面。田野上有 \(n\) 棵许愿树，编号 \(1,2,3, \ldots ,n\)，每棵树可以看作平面上的一个点，其中第 \(i\) 棵树 （\(1 \leq i \leq n\)） 位于坐标 \((x_i,y_i)\)。任意两棵树的坐标均不相同。 老司机 ...
loj2134/uoj132/洛谷P2304/bzoj4200 小园丁与老司机 DP+有上下界网络流
litble的成(tui)长(fei)史
05-26 1589
题目分析 老司机 关于老司机的这一部分，显而易见是个dp。将纵坐标相等的点组成的集合称为层，则我们要逐层dp。 将(0,0)这个点看作一棵树，算出答案后再减去它的贡献。 首先预处理出每棵树向左上，上，右上会到哪棵树，这个可以离散+桶完成，正上的处理就是将x坐标放桶里，左上右上的就把经过该点的直线y=x+b1y=x+b1y=x+b_1和y=x−b2y=x−b2y=x-b_2对应的b1b1b_...
【洛谷2304_LOJ2134】[NOI2015]小园丁与老司机（动态规划_网络流）
weixin_30851409的博客
06-19 191
题目： 洛谷 2304 LOJ 2134 （LOJ 上每个测试点有部分分） 写了快一天 …… 好菜啊 分析： 毒瘤二合一题 …… 注意本题（及本文）使用 \(x\) 向右，\(y\) 向上的「数学坐标系」，而不是 \(x\) 向下，\(y\) 向右的所谓「OI 坐标系」。「同一行」指 \(y\) 相同，「同一列」指 \(x\) 相同。 老司机 注意，只能在 没有经过的 树下转向，并且每棵树只能访问...
NOI2015 小园丁和老司机
ab563268643的博客
02-23 201
题目链接 洛谷的，有点不清楚。 建议去UOJ上或LOJ切了再搬运。 luogu UOJ LOJ sol 老司机是一个显然的\(dp\)。 发现是个\(DAG\)，可以愉快的按\(y\)坐标排序转移。 发现五个移动不好算，那么设\(g[i]\)表示从\(i\)点开始前往\(y\)坐标比\(i\)大的点的最多到的许愿树个数，\(f[i]\)表示从\(i\)进入\(y\)坐标能够最多到的许愿树...
LOJ#2134 小园丁与老司机
weixin_34137799的博客
03-22 496
我的妈呀，这码农神题...... 第一问是个DP，要记录方案。先把纵向的转移建图。发现可以按照y坐标来划分阶段，每一层vector存一下，用前后缀最大值来转移。 第二问考虑所有可能成为最优方案的边。从终点倒推可以保证每条边都能到起点，而从起点出发就不一定能保证。这些边拿去网络流建图，然后最小流。 注意第二问找边的时候，每一层的点其实可以视作两个，经过同层转移的和未经过的。这两者不可混...
[LOJ 2720][BZOJ 5417][UOJ 395][NOI 2018]你的名字
weixin_30908707的博客
04-27 120
[LOJ 2720][BZOJ 5417][UOJ 395][NOI 2018]你的名字 题意 给定一个大串 \(S\) 以及 \(q\) 次询问, 每次询问给定一个串 \(T\) 和区间 \([l,r]\), 求 \(T\) 中有多少本质不同的子串不是 \(S[l:r]\) 的子串. \(|S|\le 5\times 10^5,q\le 10^5,\sum|T|\le10^6\). 题...
[LOJ 2133][UOJ 131][BZOJ 4199][NOI 2015]品酒大会
weixin_30467087的博客
05-31 94
[LOJ 2133][UOJ 131][BZOJ 4199][NOI 2015]品酒大会 题意 给定一个长度为 \(n\) 的字符串 \(s\), 对于所有 \(r\in[1,n]\) 求出 \(s\) 的所有LCP不小于 \(r\) 的后缀对的个数以及这些后缀对所能组成的最大权值. 一个后缀对 \((a,b)\) 的权值是它们左端点的权值的积. \(n\le 3\times 10^5\...
【LOJ574】「LibreOJ NOI Round #2」黄金矿工
cz_xuyixuan的博客
07-07 1323
【题目链接】 点击打开链接 【思路要点】 可参考 官方题解 。 以下为笔者个人的见解，方便起见，下称矿工为老鼠，金矿为洞。 我们可以对洞的权值加上深度，老鼠的权值减去深度，从而不需要考虑树的边权。 考虑新加一只老鼠带来的影响，可能的结果有如下三种： (1)(1)(1) 、与一个尚未匹配的洞一起加入当前已经匹配的集合。 (2)(2)(2) 、取代当前已经匹配的集合中的一只老鼠。 (3)(...
LOJ #510. 「LibreOJ NOI Round #1」北校门外的回忆（倍增+动态开点线段树）
Freopen的博客
10-24 310
题目 这个题是一个精彩的分析性质区间离散的问题 真的详细 维护链真的一绝。 LOJ\rm LOJLOJ最短AC Code\rm AC \ CodeAC Code #include<bits/stdc++.h> #define maxn 200005 #define lim 30 using namespace std; int n,q,K,f[lim][maxn]...
【LOJ575】「LibreOJ NOI Round #2」不等关系
cz_xuyixuan的博客
07-07 1342
【题目链接】 点击打开链接 【思路要点】 见 官方题解 。（反正也是我写的） 时间复杂度 O(NLog2N)O(NLog^2N)O(NLog2N) 。 【代码】 #include<bits/stdc++.h> using namespace std; const int MAXN = 262144; const int P = 998244353; typedef l...
[链分治] LOJ #511. 「LibreOJ NOI Round #1」验题
雯舞
07-23 810
直接按照字典序类似逐位确定 先从后往前诸位确定确定答案和当前的LCP 然后在从前往后逐位确定 然后就转化为一个 某些不能选 某些必须选 某些随意 的独立集计数 链分治#include<cstdio> #include<cstdlib> #include<algorithm> #include<vector> #define pb push_back using namespace std;
栈的实现（数组实现+链表实现）+括号匹配
一个小孩博客
11-08 688
在计算机科学中，栈是一种基础且重要的数据结构，它以“后进先出”（LIFO）的方式存储和管理数据。栈的概念在许多算法和程序设计中扮演着关键角色，从函数调用的堆栈管理到浏览器的前进后退功能，栈的应用无处不在。本文将带你深入了解栈的概念、操作、实现方式以及它的实际应用。// 定义一个类型别名 StackType，等同于 int 类型。// 指向一个整型数组的指针，用于存储栈中的元素。int size;// 栈中当前元素的数量。// 栈的最大容量。} ST;// 定义一个结构体类型 ST，代表栈。
LeetCode:27. 移除元素
2301_78566776的博客
11-06 295
设置一个指针k，并且遍历数组，当元素不为val时，nums[k]更新，并且k++。这样前k项正好是这个数组中不包含val的全部项。但是注意如果出现当两个值均为val的元素相邻时，后向前覆盖可能会导致漏删。此时在下面代码中的“i--”可规避掉这个问题。主要思路：从前往后遍历数组nums,当遇到值与val相等的元素，元素的顺序可能发生改变。如下例子，9,4前移覆盖掉2。移除所有数值等于 val。
【Rust设计模式之Fold模式】
m0_37719524的博客
11-08 378
如Rust Collection中的fold方法，是消耗迭代器适配器，将闭包应用于每一个元素，并将结果返回一样。Fold模式的中心思想也是如此，将元素折叠处理，最终计算出新的元素。而我们自己实现的Fold模式，一般用于映射数据结构，不同于面向对象的原地修改，由于Rust的引用和借用以及不可变性，生成新的结构从而替代老的结构调理更为清晰。总结：通常来说只有我们在自己编写一些数据结构的时候方才用得到这种fold模式，一般的业务逻辑相对的较少能够涉及到此，不过多懂一些也是极好的~“万全之计便是即刻行动”
leetcode206. Reverse Linked List
最新发布
weixin_44245188的博客
11-10 142
考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的 next 引用指向。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]输出：[5,4,3,2,1]
leetcode动态规划（二十九）-最大子数组和
weixin_40198632的博客
11-05 378
给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。是数组中的一个连续部分。6连续子数组 [4,-1,2,1] 的和最大，为 6。
有源汇有上下界的最小流（LOJ117）
06-11
这是一个IT类问题。该问题可以使用网络流算法解决。首先用 Dinic 或 ISAP 算法求出最大流，然后根据最大流的值和边的上下界，构造一个新图，使得原图中的每条边都对应着新图中的一些流量限制。具体地，对于一条容量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值