SDOI2015 Round1总结

最新推荐文章于 2020-04-13 11:22:55 发布
最新推荐文章于 2020-04-13 11:22:55 发布
阅读量1k 收藏
点赞数
分类专栏： 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PhilipsWeng/article/details/45155793
版权

SDOI2015 Round1总结

这次总体上考出了自己的水平。但还是有做的不足的地方。

做题过程

  • 一开始先看了题目，发现第二，三题看起来比较水。然后第一题刚看懂题意就开始放弃了。

  • 第二题因为之前做过类似的题目，于是就马上想到了带权重心。纠结了差不多一个多钟应该要怎么点剖来维护答案。结果没有YY出来。此时只剩下3个半钟，马上去敲了第三题。

  • 第三题和MX的组合数的主体思想几乎一模一样，所以花了大概1个钟左右的时间就打完了暴力和程序，但是FFT一开始居然还打错了，调了一会儿才调出来。对于FFT还是太不熟悉。

然后我就一直在纠结第二题！！！！

  • 再打第二题时，因为有点心急，就马上打了了LCT准备骗分，结果连骗分都没有想好。然后我忽然发现自己太过急躁，马上冷静下来。望着我的暴力半天，结果想到了一个复杂度还算可以的算法。。打完又拍完之后就只剩半个钟了。

  • 本来我还想把第一题的暴力也打了。但是我计算了一下我的算法的复杂度。自我感觉过不了，然后就没有打了。。。。。结果。事实证明这是能拿30分的。。

最后总分200。。。。切了后两题。

暴露的主要问题。

  • 遇到一个与之前做过差不多的题，总是会不由自主的往那个方向去想。容易导致自己走入弯路。
  • 当一道自己觉得比较水的题目调不出来的时候，容易变得心急。然后问题就被自己无限放大了。。
  • 把自己会做的题目调对的时候会变得十分激动。其他题目就容易对自己的做法分析错误，导致不应该的失分。

改正方向

  • 敲代码前一定要想清楚，不能太心急。要让自己平静下来。
  • 不会做的题目一定要打暴力，尽量拿分。
  • 在暴力程序中适当加上一些要依赖数据的算法有时候会跑得更多的分数。

GDOI BLESS!!!

题解

第一题

  • 我们可以发现对于一种合法操作序列，我们对于他的全排列都是合法的。所以我们可以从小到大操作来枚举。
    假设当前的分块是这样
    A1|A2|A3|A4|A5|A6|A7|A8
    我们将相邻两个块连成一个大块。
    A1 A2|A3 A4|A5 A6|A7 A8

    可以发现对于处在同一个大块当中的两个小块，他们只可能在当前被交换。
    我们定义两个相邻小块|A1A2…An|An+1An+2….An+2^k|的不合法为
    An + 1 ≠ An+1.
    那么假设我们现在有k个大块中的两个小块不合法，我们分类讨论。

    1. k = 0,也就是说对于我们当前这种分块我们不需要进行操作。
    2. k = 1,只有一个大块中的两个小块需要交换，我们尝试交换，若合法我们继续递归。
    3. k = 2
      |a1a2| |a3a4|
      我们尝试交换a1,a3或a1,a4或a2,a3，或a2,a4，若合法，我们继续递归。
    4. k > 2,不可能合法
      就这样，我们就可以得到一个O(2^N * N)复杂度的算法。
第二题

  • 这题是我花的时间最多的题目了。
    可以发现的一个性质是我们的出发点必定为有效点中随意一个点。
    那现在的问题就只是怎么计算从一个点出发回到这个点的答案了。

    我们先考虑以1为根时的答案。设其为F1
    若我们现在一个操作为add(u)[Del(u)是等价的].
    我们设j为u的祖先中，深度最小的，满足Size(j)=0的点。Size(x)表示x的子树中有效点的数量。
    那么我们add(u)之后，j->u上的所有边都会对F1做出贡献。
    维护好F1后，我们考虑怎么求Fv
    假如我们当前是从Fu->Fv,v是u的儿子。

    1. Size(v) ≠ 0,那么Fv = Fu - 2 * e(u,v)
    2. Total≠Size(v),Total表示总共的有效点，那么Fv = Fu + 2 * e(u,v)
      我们肯定是从1一直转移到v的，我们可以用与求F1同样的方法来求Fv.
      先考虑情况1，二分出深度最小的满足Size(j)=0的点j,那么从1->fa(j)上的所有边都要被减去。
      再考虑情况2，二分出深度最小的满足Size(j)≠Total的j，那么从j->v上的所有边都要被加上。
      问题被完美解决。时间复杂度O(Nlog^2N)[当然，假如你愿意打LCT，时间复杂度可以少个log]
第三题

这里写图片描述
这里写图片描述

贴代码

T1
   #include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int MAXN = 15,MAXM = 10005;

bool ch[MAXM];
int Na[MAXM],P[MAXN],Pow[MAXN],Fac[MAXN],N,Len;
long long Ans;

void Dfs(int Now,int L)
{
    if (Now == N) {Ans += Fac[L];return;}
    int False = 0,xp = -1,yp = -1;
    for(int i = 0;i < Len / Pow[Now + 1];i ++)
    {
        int fi = i * Pow[Now + 1] + 1,fx = fi + Pow[Now];
        if (Na[fi + Pow[Now] - 1] - Na[fx] != -1) 
        {
            False ++;
            if (xp == -1) xp = i; else yp = i;
        }
    }
    if (False > 2) return;
    if (!False) Dfs(Now + 1,L); else
    {
        if (False == 1)
        {
            int fi = xp * Pow[Now + 1] + 1,fx = fi + Pow[Now];
            for(int j = 1;j <= Pow[Now];j ++) swap(Na[fi + j - 1],Na[fx + j - 1]);
            if (Na[fi + Pow[Now] - 1] - Na[fx] == -1) Dfs(Now + 1,L + 1);
            for(int j = 1;j <= Pow[Now];j ++) swap(Na[fi + j - 1],Na[fx + j - 1]);
        } else
        {
            int p[4][2];
            p[0][0] = xp * Pow[Now + 1] + 1,p[1][0] = p[0][0] + Pow[Now],p[2][0] = yp * Pow[Now + 1] + 1,p[3][0] = p[2][0] + Pow[Now];
            for(int i = 0;i < 2;i ++) p[i][1] = p[0][0];
            for(int i = 2;i < 4;i ++) p[i][1] = p[2][0];
            for(int i = 0;i < 2;i ++)
                for(int j = 2;j < 4;j ++)
                {

                    int fi = p[i][0],fx = p[j][0];
                    for(int k = 1;k <= Pow[Now];k ++) swap(Na[fi + k - 1],Na[fx + k - 1]);
                    if (Na[p[i][1] + Pow[Now] - 1] - Na[p[i][1] + Pow[Now]] == -1 && Na[p[j][1] + Pow[Now] - 1] - Na[p[j][1] + Pow[Now]] == -1) 
                        Dfs(Now + 1,L + 1);
                    for(int k = 1;k <= Pow[Now];k ++) swap(Na[fi + k - 1],Na[fx + k - 1]);
                }
        }
    }
}

int main()
{
    scanf("%d", &N);
    Pow[0] = 1;Fac[0] = 1;
    for(int i = 1;i <= N;i ++) Pow[i] = Pow[i - 1] * 2,Fac[i] = Fac[i - 1] * i;
    Len = Pow[N];
    for(int i = 1;i <= Len;i ++) scanf("%d", &Na[i]);
    Dfs(0,0);
    printf("%lld\n", Ans);
    return 0;
}
T2
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>

using namespace std;

const int MAXN = 100005;

typedef long long LL;

struct Node
{
    int To,Next,Cost;
    Node(void){}
    Node(int a,int b,int c) : To(a),Next(b),Cost(c){}
}E[MAXN * 2];

set<int>T;
bool Tr[MAXN];
LL Deep[MAXN],High[MAXN],VSum[MAXN],F1;
int So[MAXN],L[MAXN],R[MAXN],cnt;
int V[MAXN],Size[MAXN],C[MAXN],Fa[18][MAXN],Final[MAXN],tot,N,M,Cnt;


void read(int &x)
{
    char c;
    while (c = getchar(),c < '0' || c > '9');
    x = c - 48;
    while (c = getchar(),c >= '0' && c <= '9') x = x * 10 + c - 48;
}

void Link(int u,int v,int c)
{
    E[++ tot] = Node(v,Final[u],c),Final[u] = tot;
}

void Dfs(int Now,int Pre)
{
    Fa[0][Now] = Pre;
    L[Now] = R[Now] = ++ cnt;
    High[Now] = High[Pre] + 1;
    for(int i = Final[Now];i;i = E[i].Next)
    if (E[i].To != Pre)
    {
        V[E[i].To] = 2 * E[i].Cost;VSum[E[i].To] = VSum[Now] + 2 * E[i].Cost;
        Deep[E[i].To] = Deep[Now] + E[i].Cost;
        Dfs(E[i].To,Now);
        R[Now] = R[E[i].To];
    }
}

int LCA(int a,int b)
{
    if (High[a] > High[b]) swap(a,b);
    for(int i = 17;i + 1;i --)
    if (High[Fa[i][b]] >= High[a]) b = Fa[i][b];
    if (a == b) return a;
    for(int i = 17;i + 1;i --)
    if (Fa[i][a] != Fa[i][b]) a = Fa[i][a],b = Fa[i][b];
    return Fa[0][a];
}

LL Dis(int a,int b)
{
    return Deep[a] + Deep[b] - 2 * Deep[LCA(a,b)];
}

void Modify(int p,int ad)
{
    p = L[p];
    for(;p <= N;p += p & -p) So[p] += ad;
}

int Sum(int p)
{
    int tmp = 0;
    for(;p;p -= p & -p) tmp += So[p];
    return tmp;
}

int Get_Size(int u)
{
    return Sum(R[u]) - Sum(L[u] - 1);
}

void Change(int p,int ad)
{
    int cur = p,need;bool ch = 0;
    if (ad == 1) need = 0; else need = 1;
    for(int i = 17;i + 1;i --)
    if (Fa[i][cur] && (Get_Size(Fa[i][cur]) == need)) cur = Fa[i][cur],ch = 1;
    if (Get_Size(p) != need) {Modify(p,ad);return;}
    Modify(p,ad);
    cur = Fa[0][cur];
    LL C = VSum[p] - VSum[cur];
    if (ad == 1) F1 += C; else F1 -= C;
}

LL Get_Ans(int p)
{
    int cur = p,total = Get_Size(1);
    for(int i = 17;i + 1;i --)
    if (Fa[i][cur] && (Get_Size(Fa[i][cur]) != total)) cur = Fa[i][cur];
    LL Tmp = F1;
    if (Get_Size(p) != total) Tmp += VSum[p] - VSum[Fa[0][cur]];
    cur = p;
    for(int i = 17;i + 1;i --)
    if (Fa[i][cur] && (!Get_Size(Fa[i][cur]))) cur = Fa[i][cur];
    if (!Get_Size(p)) Tmp -= VSum[Fa[0][cur]]; else Tmp -= VSum[cur];
    return Tmp;
}

int main()
{
    read(N),read(M);
    for(int i = 1;i < N;i ++)
    {
        int u,v,c;read(u),read(v),read(c);
        Link(u,v,c),Link(v,u,c);
    }
    Dfs(1,0);
    for(int i = 1;i < 18;i ++)
        for(int j = 1;j <= N;j ++) Fa[i][j] = Fa[i - 1][Fa[i - 1][j]];
    for(int i = 1;i <= M;i ++)
    {
        int p,ad = 0,top;read(p);
        if (Tr[p]) ad = -1,T.erase(T.find(p)); else ad = 1,T.insert(p);
        Change(p,ad);
        Tr[p] ^= 1;
        Cnt += ad;
        if (T.empty()) {printf("0\n");continue;}
        LL acu = 0,lst = 0;
        int Hev = *T.begin();
        printf("%lld\n", Get_Ans(Hev));
    }
    return 0;
}
T3
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int MAXN = 16400,Mo = 1004535809,G = 3;

typedef long long LL;
typedef LL Dp[MAXN];

Dp tp,C,Tmp,Wi,BakC;
int A[MAXN],Rev[MAXN],N,M,L,x,Len,Re,digit;

void Get_Origin(int t)
{
    int r = 0;
    for(int i = 1;i < t;i ++)
    {
        bool ok = 1;
        for(int j = 1,tmp = 1;j < t - 1;j ++)
        {
            tmp = tmp * LL(i) % t;
            if (tmp == 1) {ok = 0;break;}
        }
        if (ok) {r = i;break;}
    }
    for(int i = 0,tmp = 1;i < t - 1;tmp = (tmp * LL(r)) % t,i ++)
        Rev[tmp] = i;
}

int Fast(int a,int b,int mo)
{
    if (!b) return 1;
    LL mid = Fast(a,b / 2,mo);
    if (b & 1) return mid * mid % mo * a % mo;
    return mid * mid % mo;
}

void FFT_PREPARE()
{
    Wi[0] = 1,Wi[1] = Fast(G,(Mo - 1) / Len,Mo);
    for(int i = 2;i <= Len;i ++) Wi[i] = Wi[i - 1] * LL(Wi[1]) % Mo;
}

void DFT(Dp &a,int sig) 
{
    for(int i = 0;i < Len;i ++)
    {
        int tmp = 0;
        for(int j = i,c = 0;c < digit;c ++,j >>= 1) tmp = (tmp <<= 1) |= (j & 1);
        tp[tmp] = a[i];
    }
    for(int m = 1;m <= Len;m <<= 1)
        for(int i = 0,half = m / 2;i < half;i ++)
        {
            int w = sig > 0 ? Wi[i * Len / m] : Wi[Len - i * Len / m];
            for(int j = i;j < Len;j += m)
            {
                int u = tp[j],v = w * LL(tp[j + half]) % Mo;
                tp[j] = (u + v) % Mo;
                tp[j + half] = (u - v + Mo) % Mo;
            }
        }
    for(int i = 0;i < Len;i ++) a[i] = tp[i];
}

void Multiply(Dp &c,Dp &a,Dp &b)
{
    DFT(a,1),DFT(b,1);
    for(int i = 0;i < Len;i ++) a[i] = LL(a[i]) * b[i] % Mo;
    DFT(a,-1);
    for(int i = 0;i < Len;i ++) c[i] = LL(a[i]) * Re % Mo;
    for(int i = M - 1;i < Len;i ++)
    {
        (c[i % (M - 1)] += c[i]) %= Mo,c[i] = 0;
    }
}

int main()
{
    scanf("%d%d%d%d", &N, &M, &x, &L);
    for(Len = 1,digit = 0;Len < M * 2;Len <<= 1,digit ++);
    Re = Fast(Len,Mo - 2,Mo);
    FFT_PREPARE();
    Get_Origin(M);
    for(int i = 1;i <= L;i ++)
    {
        int p;scanf("%d", &p);
        if (p % M) C[Rev[p % M]] ++;
    }
    Tmp[0] = 1;
    /* for(int i = 1;i <= N;i ++)
    {
        for(int i = 0;i < Len;i ++) BakC[i] = C[i];
        Multiply(Tmp,Tmp,BakC);
    } */
    for(;N;N >>= 1)
    {
        for(int i = 0;i < Len;i ++) BakC[i] = C[i];
        if (N & 1) Multiply(Tmp,Tmp,BakC);
        for(int i = 0;i < Len;i ++) BakC[i] = C[i];
        Multiply(C,C,BakC);
    }
    printf("%d\n", Tmp[Rev[x]]);
    return 0;
}
PhilipsWeng
关注
专栏目录
SDOI2015 总结
qq_42835841的博客
04-22 223
文章目录4343【SDOI2015】排序4344【SDOI2015】寻宝游戏4346【SDOI2015】星际战争4347【SDOI2015】约数个数和4348【SDOI2015】道路修建5432【SDOI2015】音质检测5434【SDOI2015】双旋转字符串 4343【SDOI2015】排序 dfsdfsdfs，发现顺序无影响，所以按长度依次dfsdfsdfs1,2,4⋯ ,2n1,2,4\c...
4.21模拟，SDOI2015Round1Test2
PhilipsWeng的专栏
04-21 897
总结今天发挥的实在是太差了。。做题过程 一开始先看题，第一题是道一眼题，看上去就是送分的，第二题题面非常简洁，一看又觉得很眼熟，估计就是莫比乌斯之类的题目，第三题看了4，5分钟的题才完全注意到了所有的限制，但是还是没有什么思路，平时对于这种会讨论很多地方的题目就是没什么感觉。 接着就去打第一题，因为是一道比较显然的网络流，所以20来分钟就敲完了，过了样例之后又出了几个超小的数据，感觉没什么问题，出了
【SDOI2015Round1】游记Day2
CreationAugust is 14 years old forever
04-12 1451
终于结束了啊。 早上吃早饭时候还想着说不定今天还有最后一点希望可以翻盘 最后还是没有做到啊。。。果然还是能力不够 T1明明做过一样的题，但是就是没写出来 T3暴力好像还有问题 R2肯定是去不了了。 什么也不能说只能怪自己太弱太蠢太天真 准备一周选修课吧。如果能拿个不错的成绩也是个小小的安慰了。 祝贺zky大爷Round1成功虐场高分进R2 祝贺TA神犇即将成为高一唯一的进队爷 下
[SDOI 2015] 排序（深搜+阶乘）（考试）
anchengao1503的博客
07-10 149
题干：　　小A有一个1~2N的排列A[1..2N]，他希望将数组A从小到大排序。小A可以执行的操作有N种，每种操作最多可以执行一次。对于所有的i(1<=i<=N)，第i种操作为：将序列从左到右划分成2N-i+1段，每段恰好包含2i-1个数，然后整体交换其中的两段。小A想知道可以将数组A从小到大排序的不同的操作序列有多少个。小A认为两个操作序列不同，当且仅当操作的个数不同，或者...
[SDOI2015]寻宝游戏
青烟绕指柔的博客
04-13 183
题目链接：[SDOI2015]寻宝游戏 从任意一个关键点出去，然后走回来路径长度都是一样的。因为是一个回路。 答案其实跟dfs序有关。 我们对关键点按照dfs序排序之后可以发现：就是两两之间的距离之和+首尾距离。 然后我们就可以用set维护集合的dfs序点，然后树剖求距离即可。 AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") ...
SDOI2015R1教训
liangjs的专栏
04-16 756
D1T3暴内存，D2T3动态内存被cena卡成狗，一共少了90分。。 考成这烂样R2要努力了
sdoi2017R1D2
04-16
标签 "sdoi2017 round1" 进一步确认了这是一个与sdoi平台相关的2017年第一轮比赛的活动。这个标签可能用于分类或者标记相关的资源，便于参赛者找到对应的比赛题目或数据。 压缩包子文件的文件名称列表仅给出 "Day2...
SDOI2017 Round 1 游记
yyx2000的博客
04-08 1515
我也不知道为什么要参加省选 反正也AK不了，打打暴力玩。 day0 2点的火车，上午看了一早晨《winter journal》感觉要完。 于是弃疗了，火车上接着看，我发现我从没看过以第二人称写人生经历的 到了济南感觉好热啊，坐个公交车都快中暑了，然而去了山师还是站着，感觉要低血压了。 为什么好多人忘带报名费？？ 我的饭钱都快被借完了 到达宾馆，感觉好高级啊，没住过这么强的宾馆 于是
sdoi2017R1D1
04-16
标签 "sdoi2017 round1" 重申了这个项目的背景，它属于2017年sdoi的第一轮比赛。这样的标签通常用于组织和分类竞赛中的不同阶段，帮助参与者和组织者追踪和理解各个部分的内容。 由于提供的信息仅包含一个名为 "Day...
GoogleCodeJam Round1 Problem1 2015
05-06
GCJ Round1 Problem1 C++ code.
SDOI2015 道路修建
g21wcr的博客
09-20 278
传送门 参考博客 线段树维护最小生成树。两个结点合并就是把两个结点之间的两条横边加上后形成一个环，然后剪掉环上的最大值即可得到当前最小生成树。（不会证） 于是现在只需要考虑怎么找最大值。 首先这个环一定是如下构成：两边是左节点的最右竖边和右节点的最左竖边，然后中间是所有的上下两行横边。如下图红色部分。 那么发现维护每个节点的最右（左）竖边及其右（左）边的最大值即可。 然而，如果左边只剩下了一条竖...
「SDOI 2015」道路修建
forever_dreams的博客
10-14 381
算法标签：线段树，2*n网格图的最小生成树
SDOI2015游记
TA
04-13 1951
Day1 今天的遗憾主要在于T1，没有想到2个块里可能会有两种不等价的交换，其实这种计数问题，应该要想到会有不等价的情况的。。但是我还是没想到，导致白丢了15分。 但是反过来想，其实即使我想到了不等价的情况，实际上我也觉得我搞不出正解的，我并没有想到可以用搜索来解决这个问题，虽然它在知道题解之后看起来很显然了。 那么，作为总结的话，是要告诉自己以后该怎么避免这种情况的发生。
【SDOI2015】临行前的夜
CreationAugust is 14 years old forever
04-10 735
第一次省选前每个人都有不同的心情吧。。。 想到可能遇到一些糟糕的事情去找学长宣泄了一下感觉舒服多了→+← 顺便交谈了一些奇怪的事情=。= 省选前不立乱七八糟的flag啦！ 就随随便便写个祝福好了 祝 zky大爷省选顺利~祝其他学长省选顺利~ （黄学长二轮前我给他送了祝福然后他进队了是不是这个祝福也有奇怪的效果2333）
[SDOI2015]排序
spzb的博客
05-05 369
此题一看就有点像快排，先对最小一层操作，逐次向上，直到完成。考虑如何操作，对于每一层（长度为2^x），暴力找出每段是否排好序，如果不是，num++,对于每一层，如果num&gt;2显然无解，因为上一层已经排好，将其分成两段，暴力调换，如果可以，继续枚举最后发现操作顺序无关（显然）,每次加上操作数的阶乘太暴力了，没什么优化#include &lt;cstdio&gt; using namespace...
[SDOI 2015] 排序
HT008的Blog
03-10 309
题目描述： 语死早，描述不出来TAT. 题目分析： 对于任何一个操作序列，操作顺序不影响最后结果 所以当K次操作可以成功的时候 贡献即为 K! 我们从小到大DFS，对于第i次操作我们将序列分成2n−i2n−i2^{n-i}段，每段长度2i2i2^i 我$们找到序列中不是连续递增的段，如果这样的段超过2个，显然这种情况无法使之合法 如果没有这样的段，就不需要执行这个操作 如果有一个这...
【SDOI2015】游记Day0
CreationAugust is 14 years old forever
04-10 1136
下午13:00从老校出发踏上征程，路上除了睡觉就是看风景听音乐和队友互相嘲讽 然后16:30左右抵达目的地 入住了一家宾馆叫海通酒店还是什么 一开始一看在街里面而且外观看起来有点破破烂烂。。。印象不太好 但是入住之后就感觉超级high 有网线有电源有干净的卫浴和床铺 灯光是那种淡淡的昏黄色，感觉不错蛮有气氛的，这种光休息起来也比较舒服吧 说实话做了一下午车感觉挺累的但是到了晚上吃饭的时
[sdoi2015]排序（搜索+剪枝优化）
weixin_30865427的博客
07-09 97
Description 小A有一个1-2^N的排列A[1..2^N],他希望将A数组从小到大排序,小A可以执行的操作有N种,每种操作最多可以执行一次,对于所有的i(1<=i<=N),第i中操作为将序列从左到右划分为2^{N-i+1}段,每段恰好包括2^{i-1}个数,然后整体交换其中两段.小A想知道可以将数组A从小到大排序的不同的操作序列有多少个,小A认为两个操作序列不同,当且...
java round函数 -1
最新发布
06-09
Java中的round函数是用于对一个浮点数进行四舍五入的操作。其语法为： ``` public static long round(double d) ``` 其中，d为需要进行四舍五入的浮点数，返回值类型为long。注意，如果d的小数部分小于0.5，则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值