「JOI 2017/2018 决赛」题解

最新推荐文章于 2020-05-30 16:38:55 发布
最新推荐文章于 2020-05-30 16:38:55 发布
阅读量1.4k 收藏
点赞数
分类专栏： 乱七八糟的东西
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_0_forever_lf/article/details/80494422
版权

LOJ 2347~2351
BZOJ上只有其中2道： 4273,4279

寒冬暖炉
dp可以推个柿子把转移优化到 O(1) O ( 1 ) ，再套个wqs二分把状态数优化到 O(nlogn) O ( n l o g n )

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
#define ld long double
using namespace std;

inline void read(int &x)
{
    char c; while(!((c=getchar())>='0'&&c<='9'));
    x=c-'0';
    while((c=getchar())>='0'&&c<='9') (x*=10)+=c-'0';
}
const int maxn = 210000;
const ld eps = 1e-12;

int n,K;
int a[maxn],b[maxn],ti[maxn];

struct node
{
    int k; ld x;
}f[maxn];
int dp(ld mid)
{
    f[0]=(node){0,0.0};
    int nown=0;
    for(int i=1;i<=n;i++)
    {
        f[i].k=f[nown].k+1;
        f[i].x=f[nown].x-b[nown]+(ld)a[i]+mid;
        if(f[i].x-b[i]<f[nown].x-b[nown]) nown=i;
    }
    return f[n].k;
}

int main()
{
    //freopen("tmp.in","r",stdin);
    //freopen("tmp.out","w",stdout);

    read(n); read(K);
    for(int i=1;i<=n;i++) read(ti[i]);
    for(int i=0;i<=n;i++) a[i]=ti[i]+1,b[i]=ti[i+1];

    ld l=-ti[n],r=ti[n];
    while(r-l>eps)
    {
        ld mid=(l+r)/2.0;
        int k=dp(mid);
        if(k==K) { l=mid;break; }
        if(k<K) r=mid;
        else l=mid;
    }
    printf("%.0Lf\n",f[n].x-l*K);

    return 0;
}

美术展览
从小到大枚举Amax，最优的Amin可以 O(1) O ( 1 ) 维护

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

void read(ll &x)
{
    char c; while(!((c=getchar())>='0'&&c<='9'));
    x=c-'0';
    while((c=getchar())>='0'&&c<='9') (x*=10ll)+=c-'0';
}
const int maxn = 510000;

int n;
struct node
{
    ll a,b;
    friend inline bool operator <(const node x,const node y){return x.a<y.a;}
}a[maxn];

int main()
{
    //freopen("tmp.in","r",stdin);
    //freopen("tmp.out","w",stdout);

    scanf("%d",&n);
    for(int i=1;i<=n;i++) read(a[i].a),read(a[i].b);
    sort(a+1,a+n+1);

    ll sum=0,pn=a[1].a,ans=0;
    for(int i=1;i<=n;i++)
    {
        sum+=a[i].b;
        ans=max(ans,pn-a[i].a+sum);
        pn=max(pn,a[i+1].a-sum);
    }
    printf("%lld\n",ans);

    return 0;
}

团子制作

将RGB定义为012，将一串团子在1处计数
发现不在同一对角线的1，他们串的团子不可能相交，同一对角线只有相邻的1有可能相交，对每一个对角线做一个dp，复杂度是线性的

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

inline void up(int &a,const int &b){if(a<b)a=b;}
const int maxn =  3100;

int n,m,ans;
int a[maxn][maxn];
int Matchl(int i,int j)
{
    return a[i][j-1]==0&&a[i][j]==1&&a[i][j+1]==2;
}
int Matchc(int i,int j)
{
    return a[i-1][j]==0&&a[i][j]==1&&a[i+1][j]==2;
}
int f[2][3];

char str[maxn];

int main()
{
    //freopen("tmp.in","r",stdin);
    //freopen("tmp.out","w",stdout);

    memset(a,-1,sizeof a);

    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",str+1);
        for(int j=1;j<=m;j++) a[i][j]=str[j]=='R'?0:(str[j]=='G'?1:2);
    }

    int ans=0;
    for(int s=2;s<=n+m;s++)
    {
        memset(f,0,sizeof f); int now=0;
        for(int j=max(1,s-n);j<=m&&j+1<=s;j++)
        {
            int i=s-j;
            now=!now;
            for(int l=0;l<3;l++)
            {
                int &temp=f[!now][l];
                up(f[now][0],temp);
                if(l!=2&&Matchl(i,j)) up(f[now][1],temp+1);
                if(l!=1&&Matchc(i,j)) up(f[now][2],temp+1);
                temp=0;
            }
        }
        up(f[now][0],f[now][1]);
        up(f[now][0],f[now][2]);
        ans+=f[now][0];
    }
    printf("%d\n",ans);

    return 0;
}

月票购买

一开始不会做，想了想部分分发现好像会了qaq
不难证明最终答案里U到V的最短路径，和S到T的月票线路只会有一段相交
枚举相交那一段的方向，也就是S->T和T->S两个方向，给每条有可能在ST最短路上的边定向，规定如果这条边要走0费用，一定要沿这个方向走
然后每个点拆3个点：还没相交，在相交段内，已过了相交段，跑Dijskral

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

inline void read(int &x)
{
    char c; while(!((c=getchar())>='0'&&c<='9'));
    x=c-'0';
    while((c=getchar())>='0'&&c<='9') (x*=10)+=c-'0';
}
const int maxn = 210000;
const int maxm = 410000;

ll ans;
int n,m,S,T,U,V;
int e[maxm][3],ec[maxm];
struct Graph
{
    struct edge{int y,c,i,nex;}a[maxm]; int len,fir[maxn];
    inline void ins(const int x,const int y,const int c,const int i)
    {
        a[++len]=(edge){y,c,i,fir[x]};fir[x]=len;
    }

    struct node
    {
        ll x; int i;
        friend inline bool operator <(const node &x,const node &y){return x.x>y.x;}
    }; priority_queue<node>q;

    ll dis1[maxn],dis2[maxn],d[maxn<<1];
    void Dij(int st,ll dis[])
    {
        for(int i=1;i<=n;i++) dis[i]=LLONG_MAX;
        dis[st]=0; q.push((node){0ll,st});
        while(!q.empty())
        {
            const node now=q.top(); q.pop();
            int x=now.i; if(dis[x]!=now.x) continue;
            for(int k=fir[x],y=a[k].y;k;k=a[k].nex,y=a[k].y) if(dis[y]>dis[x]+a[k].c)
                dis[y]=dis[x]+a[k].c,q.push((node){dis[y],y});
        }
    }
    void solve(int st,ll D,ll d1[],ll d2[])
    {
        for(int i=1;i<=m;i++) ec[i]=-1;
        for(int x=1;x<=n;x++)
        {
            for(int k=fir[x],y=a[k].y;k;k=a[k].nex,y=a[k].y) if(d1[x]<d1[y]&&d1[x]+a[k].c+d2[y]==D)
                ec[a[k].i]=x<y;
        }

        for(int i=1;i<=n*3;i++) d[i]=LLONG_MAX;
        d[U]=0; q.push((node){d[U],U});
        while(!q.empty())
        {
            const node now=q.top(); q.pop();
            int x=now.i; if(d[x]!=now.x) continue;
            int use=(x-1)/n; x=(x-1)%n+1;

            for(int k=fir[x],y=a[k].y;k;k=a[k].nex,y=a[k].y)
            {
                if(use!=2&&ec[a[k].i]==(x<y))
                {
                    if(d[y+n]>now.x) d[y+n]=now.x,q.push((node){d[y+n],y+n});
                }
                int nu=use==1?2:use;
                if(d[y+nu*n]>now.x+a[k].c)
                    d[y+nu*n]=now.x+a[k].c,q.push((node){d[y+nu*n],y+nu*n});
            }
        }
        for(int i=0;i<3;i++) ans=min(ans,d[i*n+V]);
    }
}g;
void Solve()
{
    ans=LLONG_MAX;
    g.solve(S,g.dis1[T],g.dis1,g.dis2);
    g.solve(T,g.dis2[S],g.dis2,g.dis1);
}

int main()
{
    //freopen("tmp.in","r",stdin);
    //freopen("tmp.out","w",stdout);

    read(n); read(m);
    read(S); read(T);
    read(U); read(V);
    for(int i=1;i<=m;i++)
    {
        int x,y,c; read(x),read(y),read(c);
        g.ins(x,y,c,i); g.ins(y,x,c,i);
        e[i][0]=x,e[i][1]=y,e[i][2]=c;
    }
    g.Dij(S,g.dis1); g.Dij(T,g.dis2);

    Solve();
    printf("%lld\n",ans);

    return 0;
}

毒蛇越狱

关于通配符的处理，一种方法是用子集和处理，但用子集和有个问题，就是询问串中要求为1的位置可能会算到0的情况，我们可以套一个容斥，但这个容斥的复杂度是单次 O(2L) O ( 2 L ) 的，太高了无法接受
观察发现1的个数，0的个数，？的个数最小值<=6，我们可以分三类，1的个数<=6时做子集和的容斥，0的个数<=6的时候，类似1的，我们可以另外做一个反向的子集和然后容斥，？的个数<=6时我们可以直接枚举所有匹配的情况统计和

总复杂度 O(2L+26q) O ( 2 L + 2 6 q )

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
#define cal(x) __builtin_popcount(x)
using namespace std;

const int maxn = (1<<20)+20;

int n,m,al;
int s[maxn],f1[maxn],f0[maxn];

char str[maxn];

int main()
{
    //freopen("tmp.in","r",stdin);
    //freopen("tmp.out","w",stdout);

    scanf("%d%d",&n,&m); al=1<<n;
    scanf("%s",str);
    for(int i=0;i<al;i++) f1[i]=f0[i]=s[i]=str[i]-'0';

    for(int i=0;i<n;i++)
        for(int t=1<<i,j=0;j<al;j++) if(!(j>>i&1))
        {
            f1[j+t]+=f1[j];
            f0[j]+=f0[j+t];
        }

    while(m--)
    {
        scanf("%s",str);
        int x=0,y=0,z=0;
        for(int i=0;i<n;i++) str[n-i-1]=='1'?x|=1<<i:(str[n-i-1]=='0'?y|=1<<i:z|=1<<i);

        int ans=0;
        if(cal(x)<=6)
        {
            for(int i=x;;i=(i-1)&x)
            {
                (cal(x^i)&1)?ans-=f1[i|z]:ans+=f1[i|z];
                if(!i) break;
            }
        }
        else if(cal(y)<=6)
        {
            for(int i=y;;i=(i-1)&y)
            {
                (cal(i)&1)?ans-=f0[i|x]:ans+=f0[i|x];
                if(!i) break;
            }
        }
        else
        {
            for(int i=z;;i=(i-1)&z)
            {
                ans+=s[i|x];
                if(!i) break;
            }
        }
        printf("%d\n",ans);
    }

    return 0;
}
L_0_Forever_LF
关注
专栏目录
题解洛谷P5100（c++解法）[JOI 2017 Final]足球
dogcat987的博客
05-13 275
此题带球传球控球的状态转换较为复杂，我们可以考虑 拆点 。 首先我们发现最优解一定不会出现一个人重复控球（这个……很容易想到吧） 分析每一个坐标可能出现的状态，分为控球和不控球两种情况 而不控球又分为停留在该坐标和滚动经过该坐标两种情况 而滚动又分为上下左右滚 口胡完毕，总而言之就是一个坐标要拆成六个点（据说可以只拆五个点，但是六个点可能更加便于理解？） 经过简单的分析，我们可以想到用p点的坐标 + k * 场地的点数来表示拆点后的图中某一个点（k为该点的状态序号），可以用x * (w + 1) + y表示
[JOI 2017 Final]足球
C202044zxy的博客
05-30 238
一、题目 点此看题 二、解法 把每一个位置拆成666个点：0−30-30−3分别代表球正在向上下左右四个方向滚动，444代表球在该点但是没人持球，555代表球在该点而且有人持球。下面详细讲一下建边的方法： 没人持球到有人持球，召唤离当前点最近的 工具 人，这人不用考虑移动，因为一个人持球并踢开后就不可能再持球了，找这个最近的人就可以用bfsbfsbfs 某个方向到无人持球，边权为000 某个方向继续滚动，边权为AAA 有人持球到下一个位置继续持球，边权为CCC 有人持球到踢出去（状态还是在当前点），边权为
loj2335. 「JOI 2017 Final」足球
weixin_30618985的博客
07-17 172
题意 几个人在足球场上踢球（笛卡尔坐标），要把球从一个点搞到另一个点。 可以通过传球，带球，无球跑动等方式实现传递（只能平行于坐标轴），不同的方式产生的疲劳值不同（和距离成不同的线性关系）。 要求最后所有人的疲劳值最小。 题解 观察几个性质： 1.一个人最多控一次球（至少进行了传球或者带球）； 2.一个人的路线一定是：（无球跑动->）（带球->）传球/带球（带括号表示非必选项）； 那么...
[JOI 2017 Final] 足球 （建图，最短路）
DD(XYX)的硫氰化氘博客
05-30 498
题面 题解 我们可以总结出球的两种状态，要么自己飞，要么在球员脚下被带飞。 自己飞的情况下，他只能单向直线运动，每一步代价为A，被带飞可以乱走，每一步代价为C。 从自己飞到被带飞需要一个距离自己最近的球员过来，代价为 ，对于每个格点，这个代价都是确定的，因为球不可能两次到同一个球员脚下，所以球员就相当于一次性的工具人，输入后bfs处理 就可以了。 从被带飞到自己飞需要踢一脚，给它自由，代价为B。 那么我们可以把每个格点拆成5个点，然后建个图。 自己飞要四个点，分别表示四个方向，每个点朝那
LOJ#2336「JOI 2017 Final」绳
Log_x's Blog
02-27 363
Address LOJ#2336 Solution 题目的限制有些复杂，先做一些简化。 首先染色一定不会折叠的过程中进行，因为厚度可以叠加的限制恰好保证了在折叠过程中染色不会比一开始染色更优，并且也没有必要把同一根线染色多次。 由此可知，染色之后的绳子至多只有两种颜色。 一个关键的结论： 染色之后绳长可以缩短至 222 的充分必要条件是：除了首尾两段，其余的同色连续段的长度都为偶数。 证明： ...
JOI Spring Camp 2019 简要题解
wxh010910
03-23 1085
Day 1 examination 直接上三维数点就能过，也可以容斥一下变成二维数点。 #include <bits/stdc++.h> using namespace std; template<typename T> class fenwick { public: vector<T> fenw; int n; fenwick(int n)...
[LOJ2334] 「JOI 2017 Final」JOIOI 王国（二分答案）
lunch__的博客
12-07 858
题目链接 JOIOI 王国是一个 HHH 行 WWW 列的长方形网格，每个 1×11\times 11×1 的子网格都是一个正方形的小区块。为了提高管理效率，我们决定把整个国家划分成两个省 JOI 和 IOI 。 我们定义，两个同省的区块互相连接，意为从一个区块出发，不用穿过任何一个不同省的区块，就可以移动到另一个区块。有公共边的区块间可以任意移动。我们不希望划分得过于复杂，因此划分方案需满足以下...
BZOJ JOI 2013~2014 春季training合宿 系列题解1
08-04
BZOJ JOI 2013~2014 春季training合宿 系列题解1 本文主要讲述哈希算法在OJ系统中的应用，通过对BZOJ JOI 2013~2014 春季training合宿 系列题解1的分析，来阐述哈希算法的原理和实现。 首先，我们来看一下哈希算法...
joi-date:约会的Joi扩展名
05-17
"joi-date:约会的Joi扩展名"是专门为JavaScript中的数据验证库Joi设计的一个扩展模块。Joi是一个强大的验证库，广泛用于确保输入的数据符合预期的格式和规则，从而提高应用程序的安全性和稳定性。而"joi-date"扩展则...
loj2336. 「JOI 2017 Final」绳
weixin_30515513的博客
07-19 107
题意 折一根绳子，绳子上的每一段有颜色和厚度（初始都是1），每次要求折叠部分每段颜色对应相同，每次折叠后厚度叠加。修改一段颜色的费用为该段绳子的厚度。 求对于每种颜色，求在以某种方式将绳子折成长度为2的状态后这个颜色仍存在的情况下费用最小。 题解 感觉自己又斯波了。 最显然的一个性质：在开始修改一定不比在折了几段绳子后修改更劣（因为每个线段最多改一次颜色一定优）。 那那些才是最终合法的情...
loj 2336「JOI 2017 Final」绳
weixin_30882895的博客
09-19 235
loj 首先,所有位置最多被染色一次,因为要染多次的话,还不如一开始就染成最终的颜色.并且你可以一开始就染好色 因为最终长度为2,那么如果染完后这个序列可以被折完,那么首先最多只有两种颜色,还有就是要满足对于所有同色极大联通块长度都要是偶数,不过第一个和最后一个长度可以为奇数 证明的话,先证充分条件,即这样子一定合法.可以搞出一个方法,每次只操作后面.先把最后面一个连通块长度缩成1(这样...
[loj2334][JOI 2017 Final]JOIOI 王国——二分答案+贪心
aizhuji9626的博客
10-31 248
题目大意： JOIOI 王国は H 行 W 列のマスに区切られた長方形の形をしている．JOIOI 王国では，行政の効率化のた め，国全体を 2 つの地域 JOI と IOI に分けることにした． 地域の分け方が複雑になりすぎるのを防ぐため，以下の条件を満たすように分割を行うことにした： • 各地域は，1 つ以上のマスを含む． • それぞれのマスは，2 つの地域のうちのちょうど 1 つに属...
[JOI2017] サッカー (Soccer)
weixin_33701564的博客
10-31 97
原题题面看不懂的可以看下面的\(CJ\)版中文题面 $ $ \(CJ\)版： $ $ 这道题是\(JOI\)的\(T4\)，放到联赛大概就是\(Day2,T3\)的难度 $ $ \(5\)分： 这一档分就是一个分类讨论，因为\(N=2\) 一共有\(3\)种情况可以出现最优解： \(1\)带球跑到\(2\)，\(ans=C*(\left|h1-h2\right...
「JOI 2017 Final」JOIOI 王国
weixin_34391854的博客
09-21 345
「JOI 2017 Final」JOIOI 王国 题目描述 题目译自 JOI 2017 Final T3「 JOIOI 王国 / The Kingdom of JOIOI」 JOIOI 王国是一个 HHH 行 WWW 列的长方形网格，每个 1×11\times 11×1 的子网格都是一个正方形的小区块。为了提高管理效率，我们决定把整个国家划分成两个省 JOI 和 IOI 。 我们定义，两个...
[JOI 2017 Final]王国
C202044zxy的博客
11-30 244
一、题目 二、解法 考虑二分答案，我们把最小值强加于JOI\text{JOI}JOI，最大值强加于IOI\text{IOI}IOI。 考虑怎样检查，先想一想势力范围应该如何划分。 假设蓝色是JOI\text{JOI}JOI的势力范围，可以发现如果一列一列地区填的话，能填的行应该是单调递减的，既然我们已经二分了答案，为了减轻对面的负担，JOI\text{JOI}JOI肯定拿的越多越好，所以我们就...
T3：LOJ2332「JOI 2017 Final」焚风现象.cpp
zlkoer的博客
09-18 348
JOI 2018 Final 题解
adfa4535的博客
03-16 203
题目列表：https://loj.ac/problems/search?keyword=JOI+2018+Final T1 寒冬暖炉 贪心 暴力考虑每相邻两个人之间的间隔，从小到大选取即可 #include<iostream> #include<string.h> #include<string> #include<stdio.h> #in...
【2018.9.20】JOI 2017 Final T2「準急電車 / Semiexpress」
weixin_30716141的博客
09-20 433
题目描述 JOI 铁路公司是 JOI 国唯一的铁路公司。 在某条铁路沿线共有 $N$座车站，依次编号为 $1...N$。 目前，正在服役的车次按照运行速度可分为两类：高速电车（简称快车）与普通电车（简称慢车）。 慢车每站都停。乘慢车时，对于任意一座车站 $i(1⩽i<N)$，车站 $i$到车站$i+1$用时均为 $A$。 快车只在车站$S_1, S_2, \ldots,...
[JOI 2017 Final T3] JOIOI 王国
ICEEBBING的博客
11-30 294
题目 戳这 思路 首先，根据题意，假设所选取的某一个省图像必须为一个阶梯状，这样才能符合横竖中没有被岔开的。 因为要求是最大的值最小，很显然，可以进行二分答案。 对图中的方差，得到最大值和最小值，答案的方差一定会是在0 ~ max - min 的范围内。那么分别就设定了l 和 r， mid就是二分的答案。 那么，怎么验证这个mid是否合法呢？这里，我们划分的图像为不上升的阶梯。假设前一个阶梯划分的...
joi如何处理multipart/form-data
最新发布
03-09
Joi是一个流行的Node.js库，用于验证和处理数据。它提供了一种简单而强大的方式来定义和验证数据模式。当处理multipart/form-data时，Joi可以用于验证上传的文件和其他表单字段。 要使用Joi处理multipart/form-data，你需要使用其他中间件（如multer）来解析请求并将文件保存到服务器上。然后，你可以使用Joi来验证文件和其他表单字段的值。 以下是一个使用Joi处理multipart/form-data的示例代码： ```javascript const Joi = require('joi'); const multer = require('multer'); // 创建multer实例并配置文件存储位置 const storage = multer.diskStorage({ destination: function (req, file, cb) { cb(null, 'uploads/'); // 文件存储在uploads文件夹中 }, filename: function (req, file, cb) { cb(null, file.originalname); // 使用原始文件名作为文件名 } }); const upload = multer({ storage: storage }); // 定义Joi验证规则 const schema = Joi.object({ username: Joi.string().required(), avatar: Joi.string().required(), file: Joi.string().required() }); // 处理上传请求 app.post('/upload', upload.single('file'), (req, res) => { // 验证请求数据 const { error, value } = schema.validate(req.body); if (error) { // 数据验证失败 res.status(400).json({ error: error.details[0].message }); } else { // 数据验证成功 // 执行其他操作... res.json({ message: '上传成功' }); } }); ``` 在上面的示例中，我们使用multer中间件来解析multipart/form-data请求，并将文件保存到服务器上的uploads文件夹中。然后，我们使用Joi来定义验证规则，并在处理上传请求时验证请求数据。如果验证失败，我们返回一个错误响应；如果验证成功，我们可以执行其他操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值