蓝桥杯训练day2

最新推荐文章于 2024-09-04 18:55:10 发布
最新推荐文章于 2024-09-04 18:55:10 发布
阅读量2.3k 收藏 8
点赞数 1
分类专栏： 蓝桥杯备考题集 文章标签： 蓝桥杯 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60343477/article/details/129271273
版权

day2

1.二分

(1)789. 数的范围

在这里插入图片描述

思路：
需要找到一个值的区间。比如1 2 2 3 4 5 找2的区间，即[1,2]
因为数组是有序的，所以可以使用二分查找。

(1)使用二分查找找左边界
(2)使用二分查找找右边界

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=100010;

int  n,q;
 
int a[N];

int find1(int t)  //找到当前查找数的区间左边界
{
    int res=-1;
    int l=0,r=n-1;
    int mid=(l+r)>>1;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]>t)r=mid-1;
        else if(a[mid]<t)
            l=mid+1;
        else
        {
            res=mid;
            r=mid-1;
        }
    }
    return res;
}

int find2(int t)
{
    int res=-1;
    int l=0,r=n-1;
    int mid=(l+r)>>1;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]>t)r=mid-1;
        else if(a[mid]<t)
            l=mid+1;
        else
        {
            res=mid;
            l=mid+1;
        }
    }
    return res;
}


int main()
{
    cin>>n>>q;
    for(int i=0;i<n;i++)
        cin>>a[i];
    while(q--)
    {
        int t;
        cin>>t;
        cout<<find1(t)<<" "<<find2(t)<<endl;
    }
    return 0;
}

(2)四平方和

在这里插入图片描述

经典哈希问题，二分问题。
第一步：先找出两个数的平方和的所有组合（不超过n）
第二步：n减去两个数的平方和，剩下的数看是否在第一步预处理过。

为什么可以保证字典序最小呢：
（1）在第二步中，a，b是从小到大枚举的，且可以保证a<=b恒成立，为什么？如果a>b成立，那么把a，b置换一下，一样成立。然后第一次成立就会结束，所以不可能遇到a>b的情况

(2)C[k],D[k]也是一样的道理。在第一步就可以证明。

（1）哈希表做法

#include<iostream>
#include<cstring>
using namespace std;

const int N=5000010;

int C[N],D[N];

int n;

int main()
{
    cin>>n;
    memset(C,-1,sizeof C);
    //第一步：将所有两个数的组合都算出来
    for(int a=0;a*a<=n;a++)
    {
        for(int b=a;b*b+a*a<=n;b++)
        {
            int k=a*a+b*b;
            if(C[k]==-1)
            {
                C[k]=a,D[k]=b;
            }
        }
    }
    
    //第二步，将n减去ab两个数的组合，剩下的看之前是否存储，如果有，直接输出。而且一定满足字典序最小
    
    for(int a=0;a*a<=n;a++)
    {
        for(int b=a;b*b+a*a<=n;b++)
        {
            int k=n-a*a-b*b;
            if(C[k]!=-1)
            {
                cout<<a<<" "<<b<<" "<<C[k]<<" "<<D[k]<<endl;
                return 0;
            }
        }
    }
    return 0;
    
}

（2）二分做法

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=5000010;

struct Sum
{
    int s,c,d;   //s表示a*a+b*b
    bool operator<(const Sum &t)const   //为什么重载小于号
    {
        if(s!=t.s)return s<t.s;
        if(c!=t.c)return c<t.c;
        return d<t.d;
    }
}sum[N];


int n;
int m;

int main()
{
    cin>>n;
    for(int c=0;c*c<=n;c++)
        for(int d=c;c*c+d*d<=n;d++)
            sum[m++]={c*c+d*d,c,d};
            
    sort(sum,sum+m);
    
    for(int a=0;a*a<=n;a++)
    {
        for(int b=a;b*b+a*a<=n;b++)
        {
            int t=n-a*a-b*b;
            int l=0,r=m-1;
            while(l<r)
            {
                int mid=(l+r)>>1;
                if(t<=sum[mid].s)
                    r=mid;
                else
                    l=mid+1;
            }
            if(t==sum[l].s)  //或者t==sum[r].s  因为最终l==r
            {
                cout<<a<<" "<<b<<" "<<sum[r].c<<" "<<sum[r].d<<endl;
                return 0;
            }
        }
        
    }
    return 0;
}

(3)1227. 分巧克力

在这里插入图片描述

还以为有什么技巧咧，看半天。。就一个暴力做法。。。二分正方形的边长

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=1e5+10;

int n,k;

int H[N],W[N];


bool check(int t)
{
    long long res=0;
    for(int i=0;i<n;i++)
    {
        res+=H[i]/t*(W[i]/t);
        if(res>=k)return  true;
    }
    return false;
}
int main()
{
    cin>>n>>k;
    for(int i=0;i<n;i++)
        cin>>H[i]>>W[i];
        
    int l=1,r=1e5;
    while(l<r)
    {
        int mid=(l+r+1)>>1;   //为什么+1，这是因为避免死循环，为什么会死循环。博客里面有相关文章
        if(check(mid))l=mid;
        else
            r=mid-1;
    }
    
    cout<<l<<endl;
    return 0;
}

（4）113. 特殊排序

在这里插入图片描述

难难难！！!
关键在于对“无序二分”的合理证明。
二分一定是有道理才能的。光看难懂，要仔细体会。不会的小伙伴可以私信，我这个菜鸟看了30分钟才看懂😢

// Forward declaration of compare API.
// bool compare(int a, int b);
// return bool means whether a is less than b.

class Solution 
{
public:
    vector<int> specialSort(int N) 
    {
        vector<int>res;
        res.push_back(1);    //使用插入排序+二分，res就是排序主体，开始数组只有1个元素，当然是有序的
        for(int i=2;i<=N;i++)
        {
            //这里规定找到第一个小于i的位置，且该位置后面一个数大于i。然后让i插入到第一个小于i的位置后面的一个位置
            //这是合理的.
            //如果当前数x比i小，那么i一定可以在x右边放下：如果x右边所有的数都比i小，那么i放在最右端
            //如果x右边有一个数比i大，那么i放在该数位置，该数以及后面的数右移。
            //所以找到第一个小于i的数且后面大于i的数（也可以没有）即可
            //注意，如果没有小于i的数，那么i放在第一位
            int l=0,r=res.size()-1;
            
            while(l<r)
            {
                int mid=(l+r+1)>>1;
                if(compare(res[mid],i))l=mid;   //如果mid小于i，那么i一定可以插入到mid后面(也可能可以插入到mid左边)
                else
                    r=mid-1;
            }
            res.push_back(i);
            //最后l==r，[l，l+1]分别表示小于i，大于i的数
            for(int j=res.size()-2;j>r;j--)
                swap(res[j],res[j+1]);
                
            //判断r是否合理。如果i比res[r]小，则和我们假设不符合，那么就只有一种可能，i比所有数都小，自然也比第一个数小，这个时候i只可能是第二个数，那么和第一个数交换位置即可
            if(compare(i,res[r]))swap(res[r],res[r+1]);
            //也可写 if(compare(res[r+1],res[r])swap(res[r],res[r+1]);
            
        }
   
        return res;
        
    }
};

(5)1460. 我在哪？

在这里插入图片描述

这道题数据很小，可以直接暴力解决。直接枚举所有连续的字符串的组合，找到唯一的那一个，记录下长度即可，非常简单。但是标签是二分，待我去看看题解如何解答。。

//目的找到一个最小长度且没有重复的字符串

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using  namespace std;

const int N=110;

int n;
char str[N];
int res;


int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>str[i];
        
    unordered_map<string,int>Hash;
    for(int len=1;len<=n;len++)  //枚举长度
    {
        int cnt=0;
        for(int start=1;start+len-1<=n;start++)  //枚举起点
        {
            string temp="";
            for(int j=start;j<=start+len-1;j++)  //累计枚举区间的字符串
                temp+=str[j];
            Hash[temp]++;
            if(Hash[temp]==1)cnt++;
        }
        if(cnt==n-len+1)  //说明该长度的所有组合都是第一次出现
        {
            cout<<len<<endl;
            return 0;
        }
    }
    return
    
}

二分还真可以做，需要字符串哈希的我知识，也可以直接用stl
先贴一个代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_set>

using namespace std;

int n;
string str;
unordered_set<string> S;

bool check(int mid)
{
    S.clear();
    for (int i = 0; i + mid - 1 < n; i ++ )
    {
        string s = str.substr(i, mid);
        if (S.count(s)) return false;
        S.insert(s);
    }

    return true;
}

int main()
{
    cin >> n >> str;

    int l = 1, r = n;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }

    cout << r << endl;

    return 0;
}

2.双指针

(1)1238. 日志统计

在这里插入图片描述

双指针的习题：
思路：先给排序，排序规则：帖子编号从小到大，如果帖子编号一样，则给时间从小到大排序

然后用一个l，r指向一个帖子的区间，判断该帖子是否满足要求，然后判断下一个帖子

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 1e5 + 10;

int n, d, k;

int res[N];
int rc=0;

struct node
{
    int id;
    int ts;
    node():id(0),ts(0){}
};

node a[N];


bool cmp(node &a, node& b)  
{
    if (a.id == b.id)return a.ts < b.ts;
    return a.id<b.id;
}


int main()
{
    cin >> n >> d >> k;
    for (int i = 0; i < n; i++)
        cin >> a[i].ts >> a[i].id;

    sort(a, a + n, cmp);
    // for (int i = 0; i < n; i++)
    // {
    //     cout << a[i].ts << " " << a[i].id << endl;
    // }
    
    //对帖子一个个进行判断
    //一个指针指向起始时间，一个指向末尾时间
    int l=0,r=0;  //l，r分别是一个帖子的不同时间(开始时间和截至时间)
    int cnt=0;
    while(l<n&&r<n)
    {
        if(a[l].id==a[r].id)  //帖子一样
        {
            if(a[r].ts-a[l].ts+1<=d)
            {
                cnt++;
                r++;
            }
            else
            {
                l++;
                cnt--;
            }
            if(cnt==k)
            {
                res[rc++]=a[l].id;
                cnt=0;
                int t=a[l].id;
                while(a[l].id==t)
                    l++;
                r=l;
            }
        }
        
        else
        {
            l=r;
            cnt=0;
        }
        
        
    }
    
    

    
    for(int i=0;i<rc;i++)
        cout<<res[i]<<endl;

    return 0;
}

(2)1240. 完全二叉树的权值

在这里插入图片描述
思路：
先将每一层的权值算出来，然后用一个变量res记录最大值。因为层数从小到大遍历，遇到大的才更新，所以可以保证第一次遇到的最大值层数最小。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int n;
int a[N];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);

    LL maxs = -1e18;
    int depth = 0;

    for (int d = 1, i = 1; i <= n; i *= 2, d ++ )
    {
        LL s = 0;
        for (int j = i; j < i + (1 << d - 1) && j <= n; j ++ )
            s += a[j];
        
        cout<<s<<endl;
        if (s > maxs)
        {
            maxs = s;
            depth = d;
        }
    }

    printf("%d\n", depth);

    return 0;
}

贴上自己第一次写的代码，说明功底还不够

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=1e6+10;

ll a[N];
ll deep[N];  //deep[i]=j表示深度为i的那一层的权值之和为j
int dc=1;

int n;


struct node
{
    int d;
    ll cnt;
};

node b[N];

bool cmp(node &a,node &b)
{
    if(a.cnt==b.cnt)return a.d<b.d;
    return a.cnt>b.cnt;
    
}

void count()  //计算每一层的个数
{
    int start=0; //一层的开始
    int k=1;  //一层的个数
    while(start<=n)   //计算每一层的权值
    { 
        for(int i=start;i<min(n,start+k);i++)
        {
           deep[dc]+=a[i];
        }
        start+=k;
        k*=2;
        dc++;
    }
}


int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    
    count();
    
    // for(int i=1;i<dc;i++)
    //     cout<<deep[i]<<" ";
    
    //将每一层的权值之和都算出来就简单了，想怎么做都可以,用一个结构体存下层数和大小，先按大小排序，
    //cout<<dc<<endl;
    //如果大小一样，就按照层数排序
    for(int i=1;i<dc;i++)
    {
        b[i].d=i;
        b[i].cnt=deep[i];
    }
    sort(b+1,b+dc,cmp);
    
    cout<<b[1].d<<endl;
    
    return 0;
    
}

（3）字符串删减

在这里插入图片描述

思路：
准备工作：
（1）变量ok，遇到x置为true，否则false
（2）left，right指针，left指向第一个遇到的x，right指向最后一个遇到的x

一次遍历即可

#include<iostream>
#include<cstring>

using namespace std;



const int N=110;

int n;
char a[N];
int res=0;


int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
       
    int l,r;
    int sum=0;
    bool ok=false;
    for(int i=0;i<n;i++)
    {
        if(a[i]=='x')
        {
            if(!ok)
            {
                l=r=i;
                sum=1;
                ok=true;
            }
            else
            {
                r++;
                sum++;
            }
        }
        else
        {
            ok=false;
            if(sum>=3)
            {
                res+=sum-2;
                sum=0;
            }
        }
    }
    if(sum>=3)res+=sum-2;
    cout<<res<<endl;
    return 0;
    
}

(4)799. 最长连续不重复子序列

在这里插入图片描述
用一个哈希表实时记录出现的元素次数，两个指针指向前后一次遍历即可

#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_map>
using namespace std;


const int N = 1e5 + 10;

int a[N];
int n;

int res = 0;

int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];

    unordered_map<int, int>Hash;  //哈希表

    int l = 0, r = 0;

    while (l < n && r < n)
    {
        if (Hash.count(a[r]) == 0 || Hash[a[r]] == 0)
        {
            Hash[a[r]] = 1;
            r++;
        }
        else
        {
            res = max(res, r - l);
            while (l < n && a[l] != a[r])
            {
                Hash[a[l]] = 0;
                l++;
            }
            Hash[a[l]] = 0;
            l++;
        }
    }
    res=max(res,r-l);  //最后一次判断，以免漏掉
    cout << res;
    return 0;

}

(5)800. 数组元素的目标和

在这里插入图片描述

经典双指针，一前一后。用反证法证明不会漏过答案

#include<iostream>
#include<cstring>
using namespace std;


const int N=1e5+10;

int a[N];
int b[N];

int n,m;
int k;

int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int j=1;j<=m;j++)
        cin>>b[j];
    
    int l=1,r=m;
    bool ok=true;
    while(ok)
    {
        if(a[l]+b[r]>k)
            r--;
        else if(a[l]+b[r]<k)
            l++;
        else
            ok=false;
    }
    cout<<l-1<<" "<<r-1<<endl;
    return 0;
    
}

(6)判断子序列

在这里插入图片描述

#include<iostream>
#include<cstring>
using namespace std;

const int N=1e5+10;

int n,m;

int a[N],b[N];

int main()
{
    cin>>n>>m;
    
    for(int i=0;i<n;i++)
        cin>>a[i];
    for(int i=0;i<m;i++)
        cin>>b[i];
    int i,j;
    for(i=0,j=0;i<n&&j<m;j++)
    {
        if(a[i]==b[j])
            i++;
    }
    
    if(i==n)cout<<"Yes";
    else    cout<<"No";
    
    
    return 0;
}
哆啦刘小洋
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
蓝桥杯训练day2_10
m0_58290966的博客
02-10 151
今天写了九道简单题，总结一下知识点。 输出保留两位小数 我在做题时最常用的有两种。 double num = 3.14159; System.out.printf("%.2f",num); java.text.DecimalFormat f = new java.text.DecimalFormat("0.00")； System.out.println(f.format(num)); 不考虑单词大小写比较内容是否相同 ...
蓝桥杯训练day4
m0_60343477的博客
03-25 560
每个家族有唯一的一个族长，如果给出家族所有人之间的关系，要将所有的人归类到确定的家族（有什么意义？比如我知道a是b的姑妈，但是这并不知道a是哪个家族(A,B)的，如果知道a是A族长的女儿，那么间接就知道了b是A族长女儿的侄子，那么b就是A族的成员) 这就是并查集要做的。第二件事情：如果将AB连两个族合并，不需要将A族的成员的全部转移到B族，只需要将A族族长和B族族长联系起来就可以。将元素放入末尾，然后向上进行比较和转移，维护二叉树的性质（对于任意节点，他大于等于他的左右孩子节点）对于堆的操作，简单介绍。
蓝桥杯训练Day1
m0_65787494的博客
10-25 233
蓝桥杯备赛
蓝桥杯训练day1
m0_60343477的博客
02-20 466
这个题目难啊，由于所有的数都要一样，所有差分数组必须除了第一个数其余全是0.由于差分数组每次操作都需要b[L]+1,b[R+1]-1或b[L]-1,b[R+1]+1.所以将正数和负数相互抵消后，剩下的数要么和b[1]抵消，要么和b[n+1]抵消。只有后缀和满足1/3的下标大于前缀和的下标，就加（具体看代码）过（19/22）数据。就从后往前读一遍看看哪些位置可以为1就可以了，应该是个简单到不能再简单的题，，，这个题目，看的第一感觉应该是个简单题，没想到是个中等题，暴力只能过一半数据。
蓝桥杯训练day3
a201808064823的博客
02-12 186
问题 1102: 明明的随机数 时间限制: 1Sec 内存限制: 128MB 提交: 2182 解决: 935 题目描述 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查...
蓝桥杯入门刷题训练day2
2301_76721805的博客
01-04 407
时间加法数列最大距离。
蓝桥杯训练 day4 题解
den11551的博客
04-05 145
A - 整除的尾数 枚举一下后两位数。 代码： #include<bits/stdc++.h> using namespace std; int main() { int a, b; while(scanf("%d%d", &a, &b), a || b) { a *= 100; bool is =...
蓝桥杯训练（python）Day2
weixin_51534001的博客
01-19 4805
蓝桥杯练习
蓝桥杯训练-闰年判断（day2）
2303_77845502的博客
01-22 2182
给定一个年份，判断是否为闰年输入：整数y表示当前的年份输出：若给定年份是闰年输出yes,否则输出no.
蓝桥杯备赛（Day1）
weixin_60535956的博客
12-15 4490
备战Day1
Python算法学习: 计蒜客蓝桥杯训练营题解(持续更新)
普通Gopher
02-21 1309
文章目录day1字符串和日期:特殊的三角形字母三角形字符串寻找字符串恋爱纪念日day3代码能力提升机器人矩阵旋转矩阵最大子阵day4:常用STL蒜头君面试day5:栈和递归练习括号匹配蒜头君吃桃day6:深度优先搜索踏青最大的蛋糕数迷宫的方案数家谱马的覆盖点 day1字符串和日期: 特殊的三角形 ''' 特殊的三角形 输入:9 输出: 1 121 123...
蓝桥杯-字符串训练第一天
qq_54885233的博客
03-03 286
题目描述-单词分析 小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组 成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。 现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。 输入描述 输入一行包含一个单词，单词只由小写英文字母组成。 对于所有的评测用例，输入的单词长度不超过 1000。 输出描述 输出两行，第一行包含一个英文字母，表示单词中出现得
蓝桥杯 算法训练 未名湖边的烦恼 C语言
高瑜的博客
05-10 4157
问题描述 每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。 　　每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法） 输入格式 　　两个整数，表示m和n 输出格式 　　一个整数，表示队伍的排法的方案数。 样例输入 3 2 样例输出 5 数据规模和约定 　　m,n∈［0,18］ 思路：首
蓝桥杯大赛C++算法训练——天天向上
qq_42698743的博客
03-08 894
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、问题描述二、问题解析1.思路2.具体实现总结 前言 本题是蓝桥杯算法训练中经典题目，主要考察动态规划这个知识点，另外在网上大多数人的做法是将这道题看做寻找满足条件的可行路问题来求解的。因此我想用图文结合的方式讲述这道题。 一、问题描述 A同学的学习成绩十分不稳定，于是老师对他说：“只要你连续4天成绩有进步，那我就奖励给你一朵小红花。”可是这对于A同学太困难了。于是，老师对他放宽了要求：“只要你有4天成绩是递增的，我
第十五届蓝桥杯 Python 省赛题目及解析
最新发布
伶俐角少儿编程
09-04 1677
第十五届蓝桥杯Python省赛真题及解析
【题目全解】蓝桥杯24省赛C++中高级组题干题解
Macw07的博客
09-04 1184
蓝桥杯24省赛C++中高级组题干题解
蓝桥杯备赛day01：循环
qq_53237241的博客
09-03 561
这类题目较为简单，就不写解析了，提供三种语言的参考代码，欢迎在评论区讨论！
2024年第十五届蓝桥杯青少组国赛撞期GESP认证、放弃那个？
小码农的博客
09-04 834
同学们首先明天先在蓝桥杯青少组官网下载国赛准考证，看看所报名的科目和gesp认证的科目是否在同一时间，蓝桥杯青少组的科目多，预计2天，gesp只需要在9月7日一天，如果报考科目不同，时间是可以错开的，蓝桥杯青少组的国赛基本和复赛的时间一样，大家先对比一下！蓝桥杯青少组和gesp认证重叠的科目就Scratch图形化编程、Python编程、C++编程三个，先说一下Scratch实验室个人的看法，如果同学们蓝桥杯青少组进国赛的是上面三个语言，scratch和Python语言，建议是选择蓝桥杯青少组的国赛。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值