Codeforces Round 920 (Div. 3)

最新推荐文章于 2024-06-02 16:48:54 发布
最新推荐文章于 2024-06-02 16:48:54 发布
阅读量911 收藏 24
点赞数 24
分类专栏： codeforce 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74911187/article/details/135752770
版权

文章目录

A. Square(简单模拟）

思路 ：简单的模拟，将 a i a_{i} ai​的总和与 b i b_{i} bi​的总和加起来后进行比较即可。
代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;cin>>t;
    while(t--)
    {
        vector<int>x(4),y(4);
        for(int i=0;i<4;i++)
        {
            cin>>x[i]>>y[i];
        }
        sort(x.begin(),x.end());
        sort(y.begin(),y.end());
        cout<<(y[2]-y[0])*(x[2]-x[0])<<"\n";
    }
    return 0;
}

B. Arranging Cats（简单思维）

题意：给定两个01序列a,b,求用以下操作将序列a修改成序列b所需最少的操作数。
操作1：将序列a的某一位0变成1。
操作2：将序列a的某一位1变成0。
操作3：将序列a中的任意一对 ( 0 , 1 ) (0,1) (0,1)进行交换
思路：首先求出序列a和b中的1的总数cnta,cntb，再减去序列a与b中的同时为1的位置的个数，答案就是 m a x ( c n t a , c n t b ) max(cnta,cntb) max(cnta,cntb)
代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int T;cin>>T;
    while(T--)
    {
        int n;cin>>n;
        string s,t;
        cin>>s>>t;
        
        int cnts=0,cntt=0;
        for(int i=0;i<n;i++)cnts+=(s[i]=='1');
        for(int i=0;i<n;i++)cntt+=(t[i]=='1');

        for(int i=0;i<n;i++)
        {
            if(s[i]=='1'&&t[i]=='1')cnts--,cntt--;
        }

        cout<<max(cnts,cntt)<<"\n";
    }
    return 0;
}

C. Sending Messages（贪心）

题意：给定一个序列arr表示时间，一个人需要在这些时间发送短信，初始时这个人的手机电量为f，每过一个单位的时间，手机的电量会减少a，这个人也可以选择关机，关机后每过一个单位的时间，手机的电量不会改变，但是再次开机时会损耗b的电量。问这个人以最优操作来操作手机，是否能发完所有的短信
思路：我们可以枚举序列arr每两个时间直接扣电和关机时损耗的电量，每次操作都选择最小的操作进行操作，看最后电量是否＞0即可。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int T;cin>>T;
    while(T--)
    {
        ll n,f,a,b;cin>>n>>f>>a>>b;
        vector<int>arr(n+1);
        arr[0]=0;
        for(int i=1;i<=n;i++)cin>>arr[i];

        for(int i=1;i<=n;i++)
        {
            f-=min(1ll*(arr[i]-arr[i-1])*a,b);
        }

        if(f>0)cout<<"YES"<<"\n";
        else cout<<"NO"<<"\n";
    }
    return 0;
}

D. Very Different Array（贪心）

题意：给定一个长度为n的序列a，再给定一个长度为m的序列b ( m ≥ n ) (m \ge n) (m≥n)，要求在序列b中挑选n个数，组成序列c，使得 ∑ i = 1 n ∣ a i − c i ∣ \sum_{i=1}^{n}|a_i-c_i| ∑i=1n​∣ai​−ci​∣最大
思路：首先将序列a和序列b从小到大排序，我们贪心的选择，序列a的两端i，j，开始向中间，一个一个的来选取对应的 c i c_i ci​，那么对于 a i a_i ai​和 a j a_j aj​如何选取能使得答案最大呢：

定义序列b的两端为 L , R L,R L,R。
那么对于 a i a_i ai​有两种选择选择 b L b_L bL​和 b R b_R bR​。
同样的对于 b j b_j bj​也有两种选择 b L b_L bL​和 b R b_R bR​。

对于这四种情况，我们每次选择最大的情况即可
双指针从两端向中间遍历
代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int T;cin>>T;
    while(T--)
    {
        int n,m;cin>>n>>m;
        vector<ll>a(n),b(m);
        for(int i=0;i<n;i++)cin>>a[i];
        for(int i=0;i<m;i++)cin>>b[i];

        sort(a.begin(),a.end());
        sort(b.begin(),b.end());

        ll ans=0;
        int L=0,R=m-1;
        for(int i=0,j=n-1;i<=j;)
        {
            int res1=max(abs(a[i]-b[L]),abs(a[i]-b[R]));
            int res2=max(abs(a[j]-b[L]),abs(a[j]-b[R]));

            if(res1>=res2)
            {
                ans+=res1;
                
                if(abs(b[L]-a[i])>=abs(b[R]-a[i]))
                {
                    i++;
                    L++;
                }
                else 
                {
                    i++;
                    R--;
                }
            }
            else
            {
                ans+=res2;
                if(abs(b[L]-a[j])>=abs(b[R]-a[j]))
                {
                    j--;
                    L++;
                }
                else 
                {
                    j--;
                    R--;
                }
            }
        }
        cout<<ans<<"\n";

    }
    return 0;
}

E. Eat the Chip（贪心）

题意： 在一个 n ∗ m n*m n∗m 的网格中，放入一个黑色棋子与白色棋子，每一次，白色棋子可以选择向正下方，左下，右下，三个方向移动棋子，黑色棋子每次可以选择正上方，左上，右上三个方向移动棋子。两个棋子都以最优方案操作，如果白色棋子能抓大棋子那么Alice获胜，否则Bob获胜。如果白色棋子走到最底下，黑丝棋子走到最上方，那么就是平局，输出Draw
思路：每一次白色棋子会向下走一步，黑色棋子会向上走一步，因此，我们只需要判断两棋子相遇前的最后一步是谁走的，然后再判断每个棋子应该往哪个方向一直走，例如，最后一步是白色棋子走，那么白色棋子就是白色棋子往黑色棋子的方向走，如果最后一步是黑色棋子走，那么就是黑色棋子向白色棋子的方向走，另一个棋子与之相同的方向走。最后再判断以下二者的位置即可
代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int T;cin>>T;
    while(T--)
    {
        int h,w,xa,xb,ya,yb;
        cin>>h>>w>>xa>>ya>>xb>>yb;

        if(xa>=xb)
        {
            cout<<"Draw"<<"\n";
            continue;
        }

        int col_dis=xb-xa-1;//求出黑白两色棋子的距离，判断最后是白色棋子走还是黑色棋子走

        int col_a=0,col_b=0;
        if(col_dis&1)
        {
            col_dis/=2;
            col_dis++;
            if(ya<=yb)//判断是白色棋子向黑色棋子的方向走还是黑色棋子向白色棋子的方向走
            {
                col_a=max(ya-col_dis,1);
                col_b=max(yb-col_dis,1);
                if(col_a>=col_b)cout<<"Bob"<<"\n";
                else cout<<"Draw"<<"\n";
            }
            else
            {
                col_a=min(ya+col_dis,w);
                col_b=min(yb+col_dis,w);
                if(col_b>=col_a)cout<<"Bob"<<"\n";
                else cout<<"Draw"<<"\n";
            }
        }
        else
        {
            col_dis/=2;
            if(ya<=yb)
            {
                col_a=min(ya+col_dis+1,w);
                col_b=min(yb+col_dis,w);
                if(col_a>=col_b)cout<<"Alice"<<"\n";
                else cout<<"Draw"<<"\n";
            }
            else
            {
                col_a=max(ya-col_dis-1,1);
                col_b=max(yb-col_dis,1);
                if(col_b>=col_a)cout<<"Alice"<<"\n";
                else cout<<"Draw"<<"\n";
            }
            
        }
    }
    return 0;
}

F. Sum of Progression（根号分治）

题意：给一个长度为n的序列a，有q个询问，对于每个询问q，给定三个参数 s , d , k s,d,k s,d,k来求 a s + a s + d ∗ 2 + … … a s + ( k − 1 ) ∗ d ∗ k a_s+a_{s+d}*2+……a_{s+(k-1)*d}*k as​+as+d​∗2+……as+(k−1)∗d​∗k的总和
思路：这题如果暴力求解很简单，但是一定是会超时的。有一种算法专门处理这类问题，那就是根号分治，根号分治的的思想就是取一个值X，用X把问题分成两个部分，当操作次数 ≤ X \le X ≤X时，可以暴力计算，当操作次数 ≥ X \ge X ≥X时，可以采用之前预处理好的东西直接得到答案。

那么这个 X 取什么值合适呢？对于上述的第一种操作，时间复杂度是 O ( x ) O(x) O(x),对于第二种操时间复杂度为 O ( n x O(\frac{n}{x} O(xn​)，那么一次操作的时间复杂度最坏就是 m a x ( O ( x ) , O ( n x ) ) max(O(x),O(\frac{n}{x})) max(O(x),O(xn​)),毫无疑问，选择 X = n X=\sqrt{n} X=n ​时，时间复杂度是最低的。

现在看一道例题，来更好的了解根号分治这个算法: 洛谷P3396 哈希冲突
这题我们可以把模数看成上述的X，用 m o d [ x ] [ y ] mod[x][y] mod[x][y]表示modx为y的数的总和，预处理出来模数 X ≤ n X\le \sqrt{n} X≤n ​时所有的情况，对于 X ≥ n X\ge \sqrt{n} X≥n ​的情况， 暴力计算即可，修改也是同样
那么总的时间复杂度就是 O ( N l o g N ) O(NlogN) O(NlogN)
代码在https://www.luogu.com.cn/record/143536024

现在接着看这道题：我们同样可以用根号分治的方案，首先预处理出来所有 d ≤ s q r t ( n ) d \le sqrt(n) d≤sqrt(n)的不带权的前缀和，用 p r e pre pre数组记录下来，也就是首先不管上述题目中的K，然后再计算一个带权的前缀和，用 s p r e spre spre记录。最后我们对于每个s，判断一个是否是 s p r e spre spre数组中的第一项，如果不是，所有的权值都要减小 ( s − 1 ) / d ∗ k (s-1)/d*k (s−1)/d∗k,具体先代

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

ll pre[N][320];
ll spre[N][320];

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

    int T;cin>>T;
    while(T--)
    {
        int n,m;cin>>n>>m;
        vector<int>a(n+1);
        for(int i=1;i<=n;i++)cin>>a[i];

        int D=320;//即sqrt(n)
        for(int d=1;d<=min(D,n);d++)//预处理所有d<sqrt(n)的情况
        {
            for(int i=1;i<=d;i++)
            {
                for(int j=i;j<=n;j+=d)
                {
                    pre[j][d]=(j<=d?0:pre[j-d][d])+1ll*a[j];
                    spre[j][d]=(j<=d?0:spre[j-d][d])+1ll*a[j]*((j-i)/d+1);
                }
            }
        }
        while(m--)
        {
            int s,d,k;cin>>s>>d>>k;
            if(d>D)//d>sqrt(n)时暴力计算
            {
                ll ans=0;
                for(int j=1;j<=k;j++)ans+=1ll*a[s+(j-1)*d]*j;
                cout<<ans<<" ";
            }
            else
            {
                ll p1=spre[s+(k-1)*d][d]-(s-d<=0?0:spre[s-d][d]);
                ll p2=pre[s+(k-1)*d][d]-(s-d<=0?0:pre[s-d][d]);///注意要特判
                ll ans=p1-1ll*(s-1)/d*p2;
                cout<<ans<<" ";
            }
        }
        cout<<"\n";
    }    
    return 0;
}

G. Mischievous Shooter（前缀和+思维）

题意：在一个 n ∗ m n*m n∗m的网格中有许多个得分点，给定参数k，可以向一个点的四个方向投放炸弹，会得到该方向长度为 ( k + 1 ) (k+1) (k+1)的三角形内的所有的得分点的总和，问能得到的得分点的总和最大为多少。
思路：这题看似复杂，有四个方向，其实我们只需要选取一个方向，然后旋转网格四次即可，那么我们如果我们选择这个方向的三角形，如何通过递推从 ( i , j − 1 ) (i,j-1) (i,j−1)得到 ( i , j ) (i,j) (i,j)下一个三角形的值呢，只需要加上红色区域的值减去绿色区域的值即可
在这里插入图片描述因此只要预处理出来列方向上的前缀和和一个对角线方向上的一个前缀和即可。注意要判断一个边界问题。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int T;
    cin >> T;
    while (T--)
    {
        int n, m, k;
        cin >> n >> m >> k;
        k++;
        vector<string> s(n + 1);
        for (int i = 1; i <= n; i++)
        {
            cin >> s[i];
            s[i] = " " + s[i];
        }

        int ans = 0;
        for (int t = 0; t < 4; t++)//四个方向，每次旋转90度
        {
            vector<vector<int>> col(n + 1, vector<int>(m + 1, 0));//列方向上的前缀和
            vector<vector<int>> dia(n + 1, vector<int>(m + 1, 0));//对角线上的前缀和

            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= m; j++)
                {
                    col[i][j] = col[i - 1][j] + (s[i][j] == '#');
                    dia[i][j] = dia[i - 1][j - 1] + (s[i][j] == '#');
                }

            for (int i = 1; i <= n; i++)
            {
                int now = 0;
                for (int j = 1; j <= m; j++)
                {
                    now += col[min(n, i + k - 1)][j] - col[i - 1][j];

                    int x = i + k - 1, y = j - 1;
                    if (x >= n)//注意判断对角线上的边界问题
                        y -= (x - n), x = n;
                    now -= (y >= 1 ? dia[x][y] : 0);
                    now -= (i - 1 >= 1 && j - k - 1 >= 1 ? -dia[i - 1][j - k - 1] : 0);
                    ans = max(ans, now);
                }
            }

            swap(n, m);//旋转网格需要交换n和m
            vector<string> p(n + 1, string(m + 1, '.'));
            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= m; j++)
                    p[i][j] = s[j][n - i + 1];//找到对应关系然后求得翻转后的网格
            s = p;//复制回去
        }
        cout << ans << "\n";
    }
    return 0;
}
m0_74911187
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m ...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round 920 (Div. 3)（A~F)
2301_76650919的博客
01-16 1482
河南下雪了，还挺好的，突然想到在师大这几年还是没有下过雪，回来就直接暴雪，可能这就是天意吧，这场比赛E题没有想到两人位于同一Y轴应该是bob必赢的没有写出来，挺遗憾的，但是也没有什么办法，俯冲1300。
Codeforces Round 920 div3 ---- F Sum of Progression --- 题解
weixin_73936404的博客
01-18 386
然后他是根据步长来得到答案，如果步长较长，那么n / d就会变得较小，此时直接遍历得到答案是可以接受的时间复杂度。则可以发现 A - B - 3 * C，此时我们就可以得到答案，所以我们只需要后缀和预处理，就能实现快速查询。如果 a5后面还有其他元素，其实我们只能较方便得到 A = a1 + 2*a3 + 3*a5 + 4*a7 + 5*a9......如果s = 1， d = 2， k = 3， 那么答案为 a1 + 2 * a3 + 3 * a5。(约为447）时，直接采取暴力求解此时k<=447。
【寒假复健Day2】Codeforces 920题解
multiple_issue的博客
01-17 1249
Codeforces Round 920 (DIv.3) 题解
F. Sum of Progression
weixin_73550568的博客
01-16 420
例如要查询7,10,那么相当于结果为 1*7+2*10，我们发现它其实是 3*7+4*10-2*(7+10);2.d<=S，我们根据d值来分组，d值相同的肯定分到一组。比如分为三组：(3,6,9),(1,4,7,10)(2,5,8),思路：首先根据数据范围，可以发现，可以用分治来写。根据感觉可以猜一猜，让S=350。1.如果d>=S，直接暴力算。
D. Different Arrays
zzzyyzz_的博客
08-03 181
D. Different Arrays
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
B. K-th Beautiful String 题目链接-B. K-th Beautiful String 题目大意 长度为n的字符串包含n−2n−2n−2个aaa和222个bbb，求按照字典序排列输出第kkk个字符串 解题思路 第一个bbb在倒数第二位有1个字符串，在...
Codeforces Round 920 (Div. 3)(A-E)
鱼香rose_的博客
01-17 991
Codeforces Round 920 (Div. 3) Problems A. Square Problems B. Arranging Cats Problems C. Sending Messages Problems D. Very Different Array Problems E. Eat the Chip
D. Difference Array #808 div2
m0_63305704的博客
07-28 297
差分+排序
E. Eat the Chip
心如冰清，天塌不惊
01-17 384
更正式地说，如果在爱丽丝回合开始时，她在坐标为（xa，ya）的单元格中，那么她可以将她的芯片移动到其中一个单元格（xa+1,ya）或（xa+1,ya−1）或（xa+1,ya+1）。轮到Bob时，他可以从单元格（xb,yb）移动到（xb−1,yb)或（xb−1,yb-1)或（xb−1,yb+1)。每个测试用例由一行组成，包含六个整数h，w，xa，ya，xb，yb（1 ≤ xa，xb ≤ h ≤ 1e6，1 ≤ ya，yb ≤ w ≤ 1e9）——板的尺寸以及Alice和Bob芯片的初始位置。
CF920 D. Very Different Array（排序+贪心）
sigd的博客
01-29 541
现在b数组数量多过a数组，那么选取规则（贪心）就演变成b数组前面的k个数字和a数组后k个数字匹配。b数组后面n-k个数字和a数组前n-k个匹配。为求出这个合适的K值，需要枚举。下面代码先从k=n开始计算，当k为n-1时，原本abs(a1-bn)变为abs(a1-bm)，依次类推。分析：如果b数组也是n个数字，那么a和b排序后，a最小匹配b最大（a1 bn），依次（a2 bn-1）.。题意：a数组n个数字给定，b数组m个数字中选出n个，与a数组对应差的绝对值和最大。
Codeforces Round 920 (Div. 3) D、E题解
omegg的博客
01-21 1519
在这个问题中，我们使用了贪心算法来最大化Vasya数组和Petya数组之间的总差异。: 首先计算Alice和Bob棋子在横向上的初始距离。通过这个过程，我们每步都选择当前最大的差异，确保了。进行排序，为双指针操作做准备。和Vasya可选的数字集合。中的所有元素都被处理完毕。首先对Petya的数组。使用两个指针，分别指向。即为所求的最大总差异。
算法-找出N个数组的共同元素
最新发布
Python领域优质萌新创作者
06-02 487
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
LeetCode 2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3）
<font color="Pink">Tisfy的博客</font>
05-31 1062
【LetMeFly】2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3） 给你一个下标从 0 开始的二维整数矩阵 grid，大小为 n * n ，其中的值在 [1, n2] 范围内。除了 a 出现 两次，b 缺失 之外，每个整数都 恰好出现一次 。 任务是找出重复的数字a 和缺失的数字 b 。 返回一个下标从 0 开始、长度为 2 的整数数组 ans ，其中 ans[0] 等于 a ，ans[1] 等于 b 。
【算法】宵暗的妖怪
一岁就可帅的博客
05-31 452
值得注意的是，若取两段进行吞噬，反而最多只能获得6的饱食度，并不是最大的。选择[2,4,1]和[4,2,1]这两段即可。饱食度为4+2=6。选择[1,7,2]这一段即可。一个正整数，代表最终饱食度的最大值。
Codeforces Round 894 (Div. 3)
08-29
- *3* [Codeforces Round 894 (Div. 3)A~E题解](https://blog.csdn.net/gyeolhada/article/details/132491891)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值