codeM 2018 资格赛

最新推荐文章于 2022-08-04 13:15:22 发布
最新推荐文章于 2022-08-04 13:15:22 发布
阅读量96 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/weiyinfu/p/9127063.html
版权

比赛链接：https://www.nowcoder.com/activity/2018codem/index?from=meituan

1、下单

给定若干商品，可以选择打折、满减两种方式。

#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
struct Manjian {
  int x, y;
};
const int N = 107;
const int M = 1007;
int price[N];
int can[N];
Manjian manjian[M];
int n, m;
int main() {
 // freopen("in.txt", "r", stdin);
  cin >> n >> m;
  for (int i = 0; i < n; i++) {
    cin >> price[i] >> can[i];
  }
  for (int i = 0; i < m; i++) {
    cin >> manjian[i].x >> manjian[i].y;
  }
  double useZheco = 0;
  for (int i = 0; i < n; i++) {
    if (can[i]) {
      useZheco += 0.8 * price[i];
    }else{
        useZheco+=price[i];
    }
  }
  double jian = 0xfffffff;
  double s = 0;
  for (int i = 0; i < n; i++) s += price[i];
  for (int i = 0; i < m; i++) {
    if (manjian[i].x <= s) {
      jian = min(s - manjian[i].y, jian);
    }
  }
  double ans = min(jian, useZheco);
  printf("%.2f\n",ans);
  return 0;
}

2、买可乐

此题看上去可乐可以买多种，实际上只能买一种。因为每种可乐都是不限数量的，如果限制数量那也很简单，也是一个排序问题。

#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN=1e4+7;
int n,m,k;
int a[MAXN],b[MAXN];
int buy[MAXN];
double good(int x){
    return a[x]*m+b[x]*(n-m);
}
int main() {
  //freopen("in.txt", "r", stdin);
  cin>>n>>m>>k;
  int ans=0;
  for(int i=0;i<k;i++){
      cin>>a[i]>>b[i];
  }
  for(int i=0;i<k;i++){
      if(good(i)>=good(ans)){
          ans=i;
      }
  }
  buy[ans]=n;
  cout<<buy[0];
  for(int i=1;i<k;i++){
      cout<<" "<<buy[i];
  }
  cout<<endl;
  return 0;
}

3、世界杯足球赛

16支球队组成一颗4层的二叉树，求每支球队到达根的概率。

#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 1e4 + 7;
double a[17][17];
struct Node {
  double a[17];
};
Node b[100];
void solve(int x) {
  for (int i = 0; i < 16; i++) b[x].a[i] = 0;
  if (x >= 16) {
    b[x].a[x - 16] = 1;
  } else {
    solve(x << 1);
    solve((x << 1) | 1);
    for (int i = 0; i < 16; i++) {
      for (int j = 0; j < 16; j++) {
        b[x].a[i] += a[i][j] * b[x << 1].a[i] * b[x << 1 | 1].a[j];
        b[x].a[j] += a[j][i] * b[x << 1].a[i] * b[x << 1 | 1].a[j];
      }
    }
  }
  //cout<<x<<endl;
  //cout<<"======"<<endl;
  //for(int i=0;i<16;i++)cout<<" "<<b[x].a[i];
  //cout<<endl;
}
int main() {
 // freopen("in.txt", "r", stdin);
  for (int i = 0; i < 16; i++) {
    for (int j = 0; j < 16; j++) {
      cin >> a[i][j];
    }
  }
  solve(1);
  cout << b[1].a[0];
  for (int i = 0; i < 16; i++) {
    cout << " " << b[1].a[i];
  }
  cout << endl;
  return 0;
}

4、MedoC资格赛

这道题坑有不少，如果实在不知道哪里错了，重写一遍。
人脑读代码时总是有一种惰性，因此无法发现隐含的bug。人读代码时，容易被代码牵着思路走。
而写代码时，人脑是主动输出的。

这道题注意点如下：

  • 每轮比赛的权值不能出现浮点，出现浮点后可能会造成结果不精确。实际上，这道题的权值使用long就能够存下了。第i轮资格赛更新后的权值为$w_i^'=prod/roundMax_i\prodw_i$
  • 排名并列就是不确定能否出线，如果第k+1名的成绩不等于第k名，那么这些并列第k名的都是稳赢。
  • 胜负和的判断
    在任何情形下都胜利的人就是胜利；
    在任何情形下都失败的人就是失败；
    其余情况，就是不太确定的情况。
  • 需要分两种情况考虑，有没有不确定量
    如果存在-1，那么需要枚举这个人所能够取得的一切成绩
    如果不存在-1，那么只需要考虑当前情况即可
    这道题只有一个-1，真的是已经非常友好了。
  • 只看首尾是错误的
    比如C的取值为50,那么只看C=0和C=50两种情况是不够的，结果是错误的。
    因为C的取值可能影响比赛各个轮次的权重，从而影响每个人的成绩。
import java.util.Arrays;
import java.util.Scanner;

public class Main {
int n, m, k, C;
final int MAX_N = 507;
final int MAX_M = 7;
int w[] = new int[MAX_M];
long a[][] = new long[MAX_N][MAX_M];
int res[][] = new int[MAX_N][MAX_N];//每轮是否能够胜出
final int WIN = 1, LOSE = 2, PEACE = 3;

class Pair {
    int ind;
    long value;

    Pair(int ind, long value) {
        this.ind = ind;
        this.value = value;
    }

    @Override
    public String toString() {
        return String.format("%d %d", ind, value);
    }
}

void solve(int[] res) {
    long[] we = new long[MAX_M];
    long[] ma = new long[MAX_M];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            ma[j] = Math.max(ma[j], a[i][j]);
    long prod = 1;
    for (int i = 0; i < m; i++)
        if (ma[i] > 0)
            prod *= ma[i];
    for (int i = 0; i < m; i++)
        if (ma[i] > 0) we[i] = prod / ma[i] * w[i];
        else we[i] = 0;
    long[] score = new long[MAX_N];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (ma[j] > 0)
                score[i] += we[j] * a[i][j];
    Pair pairs[] = new Pair[MAX_N];
    for (int i = 0; i < n; i++) pairs[i] = new Pair(i, score[i]);
    Arrays.sort(pairs, 0, n, (o1, o2) -> {
        if (o1.value < o2.value) return 1;
        else if (o1.value == o2.value) return 0;
        else return -1;
    });

    int unsureBeg = k - 1, unsureEnd = k - 1;
    while (unsureBeg >= 0 && pairs[unsureBeg].value == pairs[k - 1].value) unsureBeg--;
    while (unsureEnd < n && pairs[unsureEnd].value == pairs[k - 1].value) unsureEnd++;
    if (unsureEnd == k) unsureBeg = k - 1;
    for (int i = 0; i <= unsureBeg; i++) res[pairs[i].ind] = WIN;
    for (int i = unsureBeg + 1; i < unsureEnd; i++) res[pairs[i].ind] = PEACE;
    for (int i = unsureEnd; i < n; i++) res[pairs[i].ind] = LOSE;
//    for (int i = 0; i < n; i++) {
//        System.out.println(pairs[i]);
//    }
//    for (int i = 0; i < n; i++) {
//        System.out.print(res[i] + " ");
//    }
//    System.out.println("==============");
}

boolean all(int x, int y) {
    for (int j = 0; j <= C; j++)
        if (res[j][x] != y)
            return false;
    return true;
}

Main() {
    Scanner cin = new Scanner(System.in);
    n = cin.nextInt();
    m = cin.nextInt();
    k = cin.nextInt();
    C = cin.nextInt();
    for (int i = 0; i < m; i++) w[i] = cin.nextInt();
    int badX = -1, badY = -1;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            a[i][j] = cin.nextInt();
            if (a[i][j] == -1) {
                badX = i;
                badY = j;
            }
        }
    }
    if (badX == -1) {
        solve(res[0]);
        for (int i = 0; i < n; i++) {
            System.out.println(res[0][i]);
        }
    } else {
        for (int i = 0; i <= C; i++) {
            a[badX][badY] = i;
            solve(res[i]);
        }
        for (int i = 0; i < n; i++) {
            if (all(i, WIN)) {
                System.out.println(WIN);
            } else if (all(i, LOSE)) {
                System.out.println(LOSE);
            } else {
                System.out.println(PEACE);
            }
        }
    }
    cin.close();

}

public static void main(String[] args) {
    new Main();
}
}

5、万无一失的旅行方案

这道题对了一半。
要保证最优路径中的每一站都能换乘，其实能否换乘是由城市决定的，一个城市有一个最晚出发时间，大于最晚出发时间的车次是无论如何不能订票的，因为大于最晚出发时间的车次是用来改签的。

首先，从n号结点出发用队列搜索一遍，初始化每个城市的最晚出发时间；
然后，从n号结点出发用队列搜索一遍，求dp[城市][出发时间]

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN =507;//最大结点数
const int MAXM = 15007;//最大边数
const int MAXTIME = 49;//最大时间

struct Edge {
    int x, y,c,ts,td;//出发地，目的地，花费，出发时间，到达时间
};
Edge g[MAXN][MAXM];//g[i][j]表示到达结点i的第j条边
int startTime[MAXN];//每个结点的最晚出发时间（可以去等号），晚于此时间没有备选方案
int len[MAXN]; //len[i]表示到达结点i的边数
int n,m;   //n个结点，m条边
int dp[MAXN][MAXTIME];//动态规划，dp[i][j]表示在j时间出发，从城市i到达n所需要的最少花费
const int MAXCOST = 1007 * MAXM;//花费的上界
//自定义队列
struct Queue {
    int a[MAXN];
    bool inq[MAXN];//每个元素只进队列一次
    int head = 0;
    int tail = 0;
    void init() {
        head = 0;
        tail = 0;
        for (int i = 0; i < MAXN; i++)inq[i] = false;
    }
    void enq(int x) {
        if (inq[x]) return;
        a[tail] = x;
        inq[x] = 1;
        tail = (tail + 1) % MAXN;
    }
    int deq() {
        int ans = a[head];
        head = (head + 1) % MAXN;
        inq[ans] = 0;
        return ans;
    }
    bool empty() {
        return head == tail;
    }
}q;

void showEdge(Edge &e) {
    printf("%d(%d)-%d->%d(%d) ", e.x, e.ts, e.c, e.y, e.td);
}
void showNode(int city) {
    cout << "city " << city << " startTime " << startTime[city] << endl;
    for (int i = 0; i < len[city]; i++) {
        if (g[city][i].ts > startTime[g[city][i].x]) {
            cout << " [start late] ";
        }
        showEdge(g[city][i]);
        if (g[city][i].td > startTime[city] - 1) {
            cout << " [reach late] ";
        }
    }
    puts("");
}
void showGraph() {
    for (int i = 1; i <= n; i++) {
        showNode(i);
    }
    puts("================");
}
//计算从每个城市出发的最晚时间
void cutEdges() {
    //每个城市的出发时间
    for (int i = 0; i < n; i++) {
        startTime[i] = -1;//出发时间初始化为尽量小
    }
    //目的结点入队
    startTime[n] = MAXTIME;
    q.init();
    q.enq(n);
    while (!q.empty()) {
        int now=q.deq(); 
        for (int i = 0; i < len[now]; i++) {
            Edge* e = &g[now][i]; 
            if (e->td < startTime[e->y]-1) {//到达时间必须早于目的地的出发时间
                int ts = e->ts - 1;//-1表示留下改签的时间 
                if (startTime[e->x] < ts) {
                    q.enq(e->x);
                    startTime[e->x] = ts;
                }
            }
        }
    }
}
void update(int city, int startTime, int cost) {
    for (int i = 0; i <= startTime; i++) {
        dp[city][i] = min(dp[city][i], cost);
    }
}
void solve() { 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= MAXTIME; j++) {
            dp[i][j] = MAXCOST;
        }
    }
    for (int i = 0; i <= MAXTIME; i++)dp[n][i] = 0;
    q.init();
    q.enq(n);
    while (!q.empty()) {
        int now = q.deq(); 
        for (int i = 0; i < len[now]; i++) {
            Edge*e = &g[now][i]; 
            //如果到达时间太晚，直接跳出
            if (e->td >= startTime[e->y]) break;
            //如果出发时间太晚，继续循环
            if (e->ts > startTime[e->x])continue;
            int co = e->c + dp[e->y][e->td+1]; 
            if (co < dp[e->x][e->ts]) {
                update(e->x, e->ts, co);
                q.enq(e->x);
            }
        }
    }
}

int comp(const void *x,const void *y) {
    Edge *xx = (Edge*)x;
    Edge *yy = (Edge *)y;
    return xx->td-yy->td;
}
void sortEdges() {
    for (int i = 1; i <= n; i++) {
        qsort(g[i], len[i], sizeof(Edge), comp);
    }
}
void showDp() {
    cout << "DP is:" << endl;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < MAXTIME; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    freopen("in.txt", "r", stdin); 
    scanf("%d%d", &n,&m);
    for (int i = 0; i < m; i++) {
        int x,y,c ,h1, m1, h2, m2;
        scanf("%d%d%d%d:%d%d:%d",&x,&y,&c,&h1,&m1,&h2,&m2); 
        Edge *e = &g[y][len[y]++];
        e->x = x;
        e->y = y;
        e-> c = c;
        e->ts = h1 << 1 | (m1==30?1:0);
        e->td = h2 << 1 | (m2 == 30 ? 1 : 0);
    } 
    sortEdges(); 
    cutEdges(); 
    solve(); 
    int ans = MAXCOST;
    for (int i = 0; i < MAXTIME; i++) {
        ans = min(dp[1][i],ans);
    }
    if (ans == MAXCOST)ans = -1;
    cout << ans << endl;
    return 0;
}

编程时，多打印些东西，多写点注释，多重构或重写，就容易发现bug。

转载于:https://www.cnblogs.com/weiyinfu/p/9127063.html

dejing6575
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CodeM资格赛B 锦标赛 题解
DarkoDu的博客
06-22 592
CodeM资格赛B题解
C语言实现美团下单优惠系统（2018CodeM Q1）
li99yangg的博客
06-06 1353
题目描述美团在吃喝玩乐等很多方面都给大家提供了便利。最近又增加了一项新业务：小象生鲜。这是新零售超市，你既可以在线下超市门店选购生鲜食品，也可以在手机App上下单，最快30分钟就配送到家。新店开张免不了大优惠。我们要在小象生鲜超市里采购n个物品，每个物品价格为ai，有一些物品可以选择八折优惠（称为特价优惠）。有m种满减优惠方式，满减优惠方式只有在所有物品都不选择特价优惠时才能使用，且最多只可以选择...
组委会正在为美团点评CodeM大赛的决赛设计新赛制
weixin_30607659的博客
06-12 269
比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获胜者获得参加下一轮的资格，输的人被淘汰。重复这个过程，直至决出冠军。现在请问，参赛者小美最多可以活到第几轮（...
【CodeM编程】锦标赛
gx_up
06-18 886
  [编程题] 锦标赛 时间限制：1秒 空间限制：32768K 组委会正在为美团点评CodeM大赛的决赛设计新赛制。 比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则...
CodeM资格赛第二题
Xerath的博客
06-12 942
[编程|1000分] 锦标赛 时间限制：1秒 空间限制：32768K 题目描述 组委会正在为美团点评CodeM大赛的决赛设计新赛制。 比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我
美团2018年CodeM大赛-决赛 C Traffic
TYB的博客
08-25 367
题解： 先考虑一下怎么走。显然不会有先跳到前面再跳到后面的走法，因为如果有a&lt;b&lt;ca&lt;b&lt;cabbb跳到aaa，aaa再跳到ccc，那么bbb一定可以直接跳到ccc。所以我们可以先考虑向后跳。对于一个固定的起点iii，如果它只向后跳，那么可以用一个数组维护跳xxx步后的最远位置，这样能求出从它开始只向后跳的答案。然后再来考虑往前面跳，我们从当前答案小的点开始更新其它点，...
美团点评宣布启动CodeM编程大赛 —— 致力打造中国最纯正的技术奥林匹克
weixin_33805557的博客
07-04 99
《企业网D1Net》6月11日(北京) 今天，美团点评启动全新的编程大赛——CodeM。大赛旨在打造中国最纯正的编程大赛，以展示、激发和培养编程人才的专业能力。同时，依托美团点评全球领先的生活服务平台技术实力，搭建“以解决世界级算法难题为乐趣”的技术交流平台。CodeM的slogan是Just Code It，比赛重点关注算法和编程能力，赛制和赛题都向...
codem
03-11
标题中的"codem"可能指的是一个项目或者代码库的名称，而"codem_env_jungle"则可能是该项目的一个特定环境或场景，可能是游戏环境或虚拟现实应用，因为提到了使用虚幻引擎4进行开发。虚幻引擎4是一款由Epic Games...
codeM.rar_The Image
07-15
the code of image demosicking
codem-transcode：使用node.js编写的脱机视频转码器
03-01
Codem-transcode可以与Codem-schedule（ ）结合使用，以进行可靠的作业调度和通知，也可以在有或没有自定义调度程序的情况下单独使用。 要求 ffmpeg（至少0.10，并根据自己的喜好进行编译/配置） sqlite3 / MySQL /...
美团CodeM编程大赛资格赛题解
luuuyi的博客
06-23 6988
写在前面： 最近闲来没事参加了美团的CodeM大赛，赛程最初是一个资格赛环节，只要能够答对任意一题即可以进入初赛环节，本着锻炼自己的目的就报名参加了，没有想过拿到什么名次，大学这么多年，总是仰望各种大神去参加计算机竞赛，这一次自己也去体验一下。 大赛主页：美团点评变成大赛 进入正题： 概要： 总共6个题，三个小时的时间安排。晋级要求只需要答出其中一道题即可。 第一题 音乐研究 题目
美团资格赛 赛题2
weixin_30402085的博客
06-15 126
版权声明：本文为博主原创文章，未经博主允许不得转载。 组委会正在为美团点评CodeM大赛的决赛设计新赛制。比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获...
算法（四）
wys的专栏
08-04 308
组委会正在为美团点评CodeM大赛的决赛设计新赛制
锦标赛-c语言
BLADCS的博客
09-16 1110
链接：https://ac.nowcoder.com/acm/problem/13223 来源：牛客网 **题目描述 ** 组委会正在为美团点评CodeM大赛的决赛设计新赛制。 比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获胜者获得参加下一轮的资格，输的人被淘汰。重
资格赛c题
ZZU_DF的专栏
06-03 427
#include #include int main() {     int i,j;     float a[13][2];     float sum,average;     for(i=1;i        for(j=1;j          scanf("%f",&a[i][j]);     for(i=1;i       for(j=1;j         s
CodeM资格赛第一题
Xerath的博客
06-12 658
[编程|1000分] 音乐研究 时间限制：1秒 空间限制：32768K 题目描述 美团外卖的品牌代言人袋鼠先生最近正在进行音乐研究。他有两段音频，每段音频是一个表示音高的序列。现在袋鼠先生想要在第二段音频中找出与第一段音频最相近的部分。 具体地说，就是在第二段音频中找到一个长度和第一段音频相等且是连续的子序列，使得它们的 difference 最小。两段等长音频的
2018美团CodeM编程大赛资格赛第一题
qq_39159168的博客
06-08 335
一、问题描述 题目描述 美团在吃喝玩乐等很多方面都给大家提供了便利。最近又增加了一项新业务：小象生鲜。这是新零售超市，你既可以在线下超市门店选购生鲜食品，也可以在手机App上下单，最快30分钟就配送到家。 新店开张免不了大优惠。我们要在小象生鲜超市里采购n个物品，每个物品价格为ai，有一些物品可以选择八折优惠（称为特价优惠）。 有m种满减优惠方式，满减优惠方式只有在所有物品都不选择特价优惠...
2018美团codeM资格赛——python代码
GeekZW的博客
06-06 926
2018美团codeM资格赛——python代码第一题：下单题目描述美团在吃喝玩乐等很多方面都给大家提供了便利。最近又增加了一项新业务：小象生鲜。这是新零售超市，你既可以在线下超市门店选购生鲜食品，也可以在手机App上下单，最快30分钟就配送到家。新店开张免不了大优惠。我们要在小象生鲜超市里采购n个物品，每个物品价格为ai，有一些物品可以选择八折优惠（称为特价优惠）。有m种满减优惠方式，满减优惠方...
美团CodeM资格赛第二题
weixin_30585437的博客
06-18 125
锦标赛 时间限制：1秒 空间限制：32768K 组委会正在为美团点评CodeM大赛的决赛设计新赛制。比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生...
美团点评2017年CodeM大赛-资格赛 —C锦标赛
refrrir的博客
05-19 532
题目描述组委会正在为美团点评CodeM大赛的决赛设计新赛制。 比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获胜者获得参加下一轮的资格，输的人被淘汰。重复这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值