ACM-ICPC 2018 北京赛区网络预赛（A B C D H）

最新推荐文章于 2019-12-04 23:29:22 发布
最新推荐文章于 2019-12-04 23:29:22 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： ACM BruteForce 文章标签： ACM ICPC 北京赛区网络预赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lfhase/article/details/82821403
版权

ACM-ICPC 2018 北京赛区网络预赛（A B C D H）

自闭症患者

A. Saving Tang Monk II

题目链接
题面：

划掉

题意：

大搜索，队友写的

思路：

大搜索，队友写的

AC代码：
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
char pic[102][102];
int dp[6][102][102];
struct step {
    int x, y, w;
    step() {}
    step(int _x, int _y, int _w) : x(_x), y(_y), w(_w) {}
};
queue<step> bfs;
int dirx[4] = { -1, 0, 1, 0 };
int diry[4] = { 0, 1, 0, -1 };
int main() {
    int x, y;
    while (scanf("%d %d", &x, &y) != EOF && x > 0 && y > 0) {
        for (int i = 0; i < x; i++) {
            scanf("%s", pic[i]);
        }
        memset(dp, 0x3f3f3f3f, sizeof(dp));
        while (!bfs.empty()) bfs.pop();
        int sx, sy, tx, ty;
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                if (pic[i][j] == 'S') sx = i, sy = j;
                if (pic[i][j] == 'T') tx = i, ty = j;
            }
        }
        dp[0][sx][sy] = 0;
        bfs.push(step(sx, sy, 0));
        while (!bfs.empty()) {
            step topx = bfs.front();
            bfs.pop();
            for (int k = 0; k < 4; k++) {
                int nt = dp[topx.w][topx.x][topx.y];
                int nx = topx.x + dirx[k];
                int ny = topx.y + diry[k];
                int nw = topx.w;
                if (nx >= 0 && ny >= 0 && nx < x && ny < y) {
                    if (pic[nx][ny] == '#') {
                        if (nw == 0) continue;
                        nw--;
                        nt++;
                    } else if (pic[nx][ny] == 'B') {
                        if (nw < 5) nw++;
                    } 
                    if (pic[topx.x][topx.y] != 'P') {
                        nt++;
                    }
                    if (nt < dp[nw][nx][ny]) {
                        dp[nw][nx][ny] = nt;
                        if (pic[nx][ny] != 'T') {
                            bfs.push(step(nx, ny, nw));
                        }
                    }
                }
            }
        }
//         for (int w = 0; w <= 5; w++) {
//             for (int i = 0; i < x; i++) {
//                 for (int j = 0; j < y; j++) {
//                     printf("%d ", dp[w][i][j]);
//                 }printf("\n");
//             }printf("\n\n");
//         }
        int ans = 0x3f3f3f3f;
        for (int i = 0; i <= 5; i++) {
            ans = min(ans, dp[i][tx][ty]);
        }
        printf("%d\n", ans == 0x3f3f3f3f ? -1 : ans);
    }
    return 0;
}

B. Tomb Raider

题目链接
题面：

划掉

题意：

寻址n个串的最长公共子序列。

思路：

拿一个最短串枚举所有子序列，在其他串中查找。暴力

AC代码：
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <cmath>
#include <map>

using namespace std;

typedef long long LL;

const int MAXN = 1000005;

string s[12];
int use[10];
string ans;

int main()
{
    int n;
    string temp;
    string now;
    while(cin >> n){
        for(int i = 0; i < n; ++i){
            cin >> s[i];

        }
        for(int i = 1; i < n; ++i){
            s[i] += s[i];
            //cout << s[i] << endl;
        }
        int len = s[0].length();
        int maxx = (1<<len);
        ans = "";
        for(int i = 0; i < maxx; ++i){
            temp = "";
            int cnt = 0;
            for(int j = 0; j < len; ++j){
                if(i&(1<<j)){
                    temp += s[0][j];
                }
            }
            int tl = temp.length();
            for(int x = 0; x < tl; ++x){
                now = temp.substr(x+1, tl-(x+1)) + temp.substr(0, x);
                now.push_back(temp[x]);
                int nl = now.length();
                //cout << now << endl;
                bool flag = true;
                bool tempflag;
                for(int j = 1; j < n; ++j){
                    int lj = s[j].length()/2;
                    tempflag = false;
                    for(int st = 0; st < lj; ++st){
                        if(s[j][st] != now[0]) continue;
                        int cur = 1;
                        if(nl == 1){
                            tempflag = true;
                            break;
                        }
                        for(int k = st+1; k < st+lj; ++k){
                            if(s[j][k] == now[cur]){
                                ++cur;
                                if(cur == nl){
                                    tempflag = true;
                                    break;
                                }
                            }
                        }
                        if(tempflag) break;
                    }
                    if(!tempflag){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    //cout << now << endl;
                    if(now.length() > ans.length()){
                        ans = now;
                        reverse(now.begin(), now.end());
                        if(now < ans){
                            ans = now;
                        }
                    }else if(now.length() == ans.length()){
                        if(now < ans){
                            ans = now;
                        }
                        reverse(now.begin(), now.end());
                        if(now < ans){
                            ans = now;
                        }
                    }
                }
            }
        }
        if(ans == ""){
            cout << 0 << endl;
        }else{
            cout << ans << endl;
        }
    }
}

C. Cheat

题目链接
题面：

划掉

题意：

斗地主。

思路：

大模拟，队友写的。

AC代码：
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int dictOrder[] = {9, 1, 2, 3, 4, 5, 6, 7, 8, 0, 10, 12, 11};
int cards[4][13];
int fuck[4][13];
int tables[13];
char fv[5];
int rankNow = 0, rounderRank = -1, rounderCnt = -1, roundext = -1, roundNow = 0;
int getcard(char* sp) {
#define card(a, b) if (strcmp(sp, a) == 0) return b;
    card("A", 0); card("2", 1); card("3", 2); card("4", 3); card("5", 4); card("6", 5);
    card("7", 6); card("8", 7); card("9", 8); card("10", 9); card("J", 10); card("Q", 11);
    card("K", 12);
    return -1;
#undef card
}
const char* getcardII(int sp) {
#define card(b, a) if (sp == a) return b;
    card("A", 0); card("2", 1); card("3", 2); card("4", 3); card("5", 4); card("6", 5);
    card("7", 6); card("8", 7); card("9", 8); card("10", 9); card("J", 10); card("Q", 11);
    card("K", 12);
    return "?";
#undef card
}
int findSmallest(int p) {
    for (int i = 0; i < 13; i++) {
        if (cards[p][dictOrder[i]] > 0) {
            return dictOrder[i];
        }
    }
    return -1;
}
int findNextCard(int p) {
    for (int i = 0; i < 13; i++) {
        if (fuck[p][i] > 0) {
            fuck[p][i]--;
            return i;
        }
    }
    return -1;
}
void putOneDictSmallest(int p) {
    int ck = findSmallest(p);
    if (ck >= 0) {
        cards[p][ck]--;
        rounderCnt = 1;
        rounderRank = ck;
        tables[ck]++;
    }
}
void putSomeTrueCard(int p, int cnt) {
    rounderCnt = cnt;
    cards[p][rankNow] -= cnt;
    rounderRank = rankNow;
    tables[rankNow] += cnt;
}
bool action(int p, bool realDo, int rankx) {
    if (realDo) roundext = -1;
    if (p == 0) {
        if (cards[p][rankx] > 0) {
            if (realDo) putSomeTrueCard(p, 1);
            return true;
        } else {
            if (realDo) putOneDictSmallest(p);
            return false;
        }
    } else if (p == 1) {
        if (cards[p][rankx] > 0) {
            if (realDo) putSomeTrueCard(p, cards[p][rankx]);
            return true;
        } else {
            if (realDo) putOneDictSmallest(p);
            return false;
        }
    } else if (p == 2) {
        if (cards[p][rankx] > 0) {
            if (realDo) putSomeTrueCard(p, cards[p][rankx]);
            return true;
        } else {
            if (realDo) {
                int nums = 9999, idx = -1;
                for (int i = 0; i < 13; i++) {
                    if (cards[p][dictOrder[i]] > 0) {
                        if (cards[p][dictOrder[i]] < nums) {
                            nums = cards[p][dictOrder[i]];
                            idx = dictOrder[i];
                        }
                    }
                }
                rounderCnt = cards[p][idx];
                cards[p][idx] = 0;
                rounderRank = idx;
                tables[idx] += rounderCnt;
            }
            return false;
        }
    } else if (p == 3) {
        if (cards[p][rankx] > 2) {
            if (realDo) putSomeTrueCard(p, cards[p][rankx]);
            return true;
        } else {
            if (realDo) {
                putSomeTrueCard(p, cards[p][rankx]);
                roundext = findSmallest(p);
                if (roundext >= 0) {
                    cards[p][roundext]--;
                    tables[roundext]++;
                }
                return roundext == -1;
            }
            return false;
        }
    }
}
bool shouldFuck(int p) {
    if (p == 0) {
        if ((roundNow + 1) % 4 == p && !action(p, false, (rankNow + 1) % 13)) {
            return true;
        } else {
            return cards[p][rankNow] + (rounderCnt + (roundext >= 0)) > 4;
        }
    } else if (p == 1) {
        return (roundNow + 1) % 4 == p && !action(p, false, (rankNow + 1) % 13);
    } else if (p == 2) {
        return cards[p][rankNow] == 4;
    } else if (p == 3) {
        return findSmallest(roundNow % 4) == -1;
    }
}
void getAllCards(int p) {
    for (int i = 0; i < 13; i++) {
        cards[p][i] += tables[i];
        tables[i] = 0;
    }
}
void printCards() {
    memcpy(fuck, cards, sizeof(cards));
    for (int i = 0; i < 4; i++) {
        for (int k = 0; k < 998; k++) {
            int next = findNextCard(i);
            if (next == -1) {
                if (k == 0) printf("WINNER");
                printf("\n");
                break;
            }
            else {
                if (k > 0) printf(" ");
                printf("%s", getcardII(next));
            }
        }
    }
}
int main() {
    bool gaming = true;
    while (gaming) {
        memset(cards, 0, sizeof(cards));
        memset(tables, 0, sizeof(tables));
        for (int i = 0, j = -1; i < 52; i++) {
            if (i % 13 == 0) j++;
            if (scanf("%s", fv) == EOF) {
                gaming = false;
                break;
            }
            int cc = getcard(fv);
            if (cc >= 0) cards[j][cc]++;
        }
        rankNow = 0, roundNow = 0, rounderRank = -1, rounderCnt = -1, roundext = -1;
        if (gaming) {
            while (true) {
                //printf("round: %s\n", getcardII(rankNow));
                bool really = action(roundNow % 4, true, rankNow);
                //printCards();
                //printf("rankcnt %d ext: %s\n", rounderCnt, getcardII(roundext));
                //printf("p%d is really: %d\n", roundNow % 4, really);
                for (int j = roundNow + 1; j < roundNow + 4; j++) {
                    if (shouldFuck(j % 4)) {
                        //printf("p%d do fuck!\n", j % 4);
                        if (!really) {
                            getAllCards(roundNow % 4);
                        } else {
                            getAllCards(j % 4);
                        }
                        break;
                    }
                }
                rankNow = (rankNow + 1) % 13;
                if (findSmallest(roundNow % 4) == -1) break;
                roundNow++;
            }
            printCards();
        }
    }
    return 0;
}

D. 80Days

题目链接
题面：

划掉

题意：

n个成环的城市，到达第i个城市获得 a i a_i ai​，离开丢掉 b i b_i bi​，初始有c，全程拥有值不能为负数，问是否可行，可行就输出最小的出发点。

思路：

尺取法，维护一个连续段的区间以及C+在该区间旅游费用和，左端点不变，右端点向右移，如果遇到无法进行的情况则移动左端点。

AC代码：
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <cmath>
#include <map>

using namespace std;

typedef long long LL;

const int MAXN = 1000005;

LL a[2*MAXN];
LL b[2*MAXN];

int main()
{
    int t;
    cin >> t;
    int n;
    LL c;
    while(t--){
        scanf("%d%lld", &n, &c);
        for(int i = 1; i <= n; ++i){
            scanf("%lld", &a[i]);
            a[n+i] = a[i];
        }
        for(int i = 1; i <= n; ++i){
            scanf("%lld", &b[i]);
            b[n+i] = b[i];
        }
        int l = 1, r = 1;
        LL now = c + a[1];
        bool flag = false;
        while(true){
            now -= b[r];
            while(now < 0 && l < r){
                now -= a[l];
                now += b[l];
                l++;
            }
            if(l == r && now < 0){
                l++;
                r++;
                now = c + a[l];
                continue;
            }
            r++;
            if(r-l == n){
                flag = true;
                break;
            }
            now += a[r];
            while(now < 0 && l < r){
                now -= a[l];
                now += b[l];
                l++;
            }
            if(l > n){
                flag = false;
                break;
            }
        }
        if(flag){
            printf("%d\n", l);
        }else{
            printf("-1\n");
        }
    }
}

H. K-Demensional Foil II

题目链接
题面：

划掉

题意：

K维空间，给定一个曼哈顿距离意义下的球，N个点，求这些点到该球上在欧几里得距离下最小的点。

思路：

直接考虑对欧几里得距离进行缩小，那么可以写成一个类似于方差形式的表达式，那么要使得该表达式最小，令这K维当中对表达式值贡献最大的值减小。
问题变形为满足哈密顿距离小于R时放缩该表达式使得其值最小，二分即可。

AC代码：
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <stack>
#include <bitset>

using namespace std;

#define FSIO  ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define DEBUG(a)   cout<<"DEBUG: "<<(a)<<endl;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define X  first
#define Y  second
#define REP(i,st,ed)    for(int i=st;i<=ed;++i)
#define IREP(i,st,ed)   for(int i=ed;i>=st;--i)
#define TCASE(T)    cin>>T;while(T--)


const int MAXN = 105;
const int MOD = 2333333 ;
const int INF = 1e9+7;

int _;

using namespace std;

const double EPS = 1e-6;

double foil[MAXN];
double spcf[MAXN];
double go[MAXN];
bool mk[MAXN];
int N, K;
double R;

int main()
{
    //freopen("test.in","r",stdin);
    //freopen("test.out","w+",stdin);
    TCASE(_)
    {
        scanf("%d%d",&N,&K);
        scanf("%lf",&R);
        REP(i,1,K)  scanf("%lf",&foil[i]);
        REP(t,1,N)
        {
            REP(i,1,K)
            {
                scanf("%lf",&spcf[i]);
                go[i] = fabs(spcf[i]-foil[i]);
                mk[i] = (spcf[i]>=foil[i]);
            }
            double minn = 0;
            double maxn = 1e8;
            double mid, tmp;
            while(minn+EPS<=maxn)
            {
                mid = (minn+maxn)/2.0;
                tmp = 0;
                REP(kk,1,K) tmp+=max(0.0,go[kk]-mid);
                if(tmp<=R)  maxn = mid-EPS;
                else    minn = mid+EPS;
            }
            REP(i,1,K)
            {
                if(go[i]>=maxn)    go[i]=maxn;
                if(mk[i])   tmp = spcf[i]-go[i];
                else    tmp = spcf[i]+go[i];
                printf("%.5f ",tmp);
            }
            printf("\n");
        }
    }
    return 0;
}
LFhase
关注
专栏目录
ACM-ICPC北京赛区2018 D　Frog and Portal（构造）
Ever_glow的博客
11-13 438
时间限制:1000ms 单点时限:1000ms 内存限制:512MB 描述 A small frog wants to get to the other side of a river. The frog is initially located at one bank of the river (position 0) and wants to get to the other bank...
ACM-ICPC 2018 青岛赛区网络预赛 B. Red Black Tree (LCA、二分)
__喵喵喵的博客
09-18 525
传送门：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5807   题意：   给出一棵树，根节点为1。每条边有一个距离，树上有m个点为红色的点，其余为黑色，每个点的权值为到其最近红色祖先的距离。有q次询问，每次给出一个点集，问在树上涂红一个点后，点集中所有点的最大值的最小值是多少。   思路：   预处理每个点到...
ACM/ICPC 2018亚洲区预选赛北京赛站网络赛题目4 : 80 Days
weixin_41391865的博客
09-22 635
#include &lt;map&gt; #include &lt;cstring&gt; #include &lt;string&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cctype&amp
ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 A（bfs）
Chen.Jr的博客
09-23 851
传送门 题面： #1828 : Saving Tang Monk II 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 《Journey to the West》(also 《Monkey》) is one of the Four Great Classical Novels of Chinese literature. It was written by...
ACM-ICPC2018北京网络赛 Tomb Raider（暴力）
weixin_30651273的博客
09-22 172
题目2 : Tomb Raider 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 Lara Croft, the fiercely independent daughter of a missing adventurer, must push herself beyond her limits when she discovers...
2018北京icpc区域赛 A Jin Yong’s Wukong Ranking List
c3po
05-08 527
直接用一个map映射一下，数字小的不可能出现在数字大的前面 #include <bits/stdc++.h> using namespace std; typedef long long ll; typedef unsigned long long ull; const int maxn=100+5; std::map<string,int> mp; int n; i...
ACM-ICPC 2018 南京赛区网络预赛 题解（未完）
OOOak
09-01 472
目录   A.An Olympian Math Problem【签到题】 J.Sum【分解质因数+线性筛】 A.An Olympian Math Problem【签到题】 传送门 题意： 给你一个n 求S模n的值 题解：推规律 AC_code: #include&lt;bits/stdc++.h&gt; #define ll long long using namesp...
ACM-ICPC 2018 青岛赛区网络预赛 G.Couleur (逆序对、主席树)
__喵喵喵的博客
09-28 334
传送门：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5808   题意：   给出一个数列，每次都会删去一个数并将原数列分为两段，问每次删数前所有段中逆序对的最大数量，强制在线。   思路：   利用主席树可以每次O(log(n))算出一个点在某个区间的逆序对数量，一开始还没删的时候先统计总共有多少逆序对。  ...
ACM-ICPC 2018南京赛区网络预赛 J Sum（线性筛）
yypurpose的博客
09-02 879
A square-free integer is an integer which is indivisible by any square number except 11. For example, 6 = 2 \cdot 36=2⋅3 is square-free, but 12 = 2^2 \cdot 312=22⋅3 is not, because 2^222 is a square n...
ACM-ICPC 2018 南京赛区网络预赛 An Easy Problem On The Trees [LCT]
ACTerminate的博客
09-02 464
题意 给你n个节点的一颗树，m个操作，操作有三种： 1. 连接a与b。 2. 以x为根节点，将b与其父节点连接的边删除。 3. 询问从x开始最后走回x的期望步数（每条边等概率移动）。 题解 对于询问3可以推出一个结论，期望的步数是2*(size(x)-1)/du(x)，通过这个结论我们只需要用LCT维护子树大小即可。 AC代码 #include&amp;amp;lt;stdio.h&amp;amp;gt; #...
ACM/ICPC 2018亚洲区预选赛北京赛站网络赛
weixin_33725272的博客
09-22 104
菜鸡只配拥有三题，难过 题目1 : Saving Tang Monk II 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 《Journey to the West》(also 《Monkey》) is one of the Four Great Classical Novels of Chinese literature...
2018ICPC 北京
weixin_30486037的博客
08-22 120
A.0:27:15 solved by hl 感人的数据范围，每次连上边之后dfs一下前者看能不能找到自己就行 #include <iostream> #include <string> #include <map> #include <vector> #include <cstdio> using ...
2018北京icpc区域赛 H - Approximate Matching（AC自动机+DP）
qq_43544481的博客
12-04 277
String matching, a common problem in DNA sequence analysis and text editing, is to find the occurrences of one certain string (called pattern) in a larger string (called text). In some cases, the patte...
2018北京ICPC H. Approximate Matching（AC自动机+DP）
加载中...
11-11 746
  H : Approximate Matching 时间限制:1000ms，单点时限:1000ms，内存限制:512MB 描述 String matching, a common problem in DNA sequence analysis and text editing, is to find the occurrences of one certain string (calle...
2018icpc北京站总结
Ivan_zcy的博客
11-15 1040
​ 亚洲区预赛北京站应该是国内最难打的一站吧。。刚开始就没抱什么期待。比赛前一星期做了青岛的重现赛，5题银牌水平，突然就对北京有了一丝期待，但愿能获个奖，希望今年不白玩。 ​ 现场赛开始后刚开始，队友告诉我I题可以用数位dp做，连忙看起了i，另两个队友看起了A题。没过10分钟清华大学A题一血。增林老哥紧随其后没多久A题Accept。赛后问队友A题好像是传递闭包，然后自己今天补了一下这道题：链接 ​...
2018.9.29 icpc15北京区域赛重现
AAAAAAAC的博客
09-29 377
A：Xiongnu's Land  （树状数组的差分数组） 题意：矩形沙漠（0，0）到（R，R），有n片绿洲，每个绿洲也是矩形，且不重叠。求一个整数分割线分割x，使得 1.左面与右面的绿洲面积尽量接近 2.若不能相等，就让左面的绿洲面积尽量的大 3.在绿洲面积差优先约束下，分割线尽量靠右 思路： 需要把面积是按x轴分割，所以要把面积落下来，落到x轴上，比如某绿洲的x范围是【L，R】，高...
【hiho】2018ICPC北京赛区网络赛B Tomb Raider（暴力dfs）
よろしくお願いします
09-23 591
题目链接 #1829 : Tomb Raider 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 Lara Croft, the fiercely independent daughter of a missing adventurer, must push herself beyond her limits when she discovers the i...
ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 C-cheat
Seeyouer的博客
09-22 569
超级水的模拟的，我也就会做模拟了……坑有点多，一直没调出来bug，赛后才发现少了一个数字…… 描述 Cheat is a card game played by four players sitting around a table. They are numbered from 1 to 4 in clockwise order. A pack of 52 cards is used. The...
ACM/ICPC 2018亚洲区预选赛北京赛站网络赛D-80 Days--------树状数组
qq_40921866的博客
09-22 146
题意就是说1-N个城市为一个环，最开始你手里有C块钱，问从1->N这些城市中，选择任意一个，然后按照顺序绕环一圈，进入每个城市会有a[i]元钱，出来每个城市会有b[i]个城市，问是否能保证经过每个城市，钱都不会能为0，如果可以请输出最小的那个 这题最开始队员想错了。。。后来思路就乱了，整理一下思路，你会发现，其实我们要求的就是从i到n+i的前缀和最小值一定要大于c。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值