nefu暑假集训3 并查集与最小生成树 个人模板+例题汇总

于 2024-08-31 15:12:25 发布
阅读量395 收藏 4
点赞数 16
分类专栏： 算法学习+刷题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wzh20060111/article/details/141751497
版权

前言：

  并查集与最小生成树的训练。

正文：

链接：并查集与最小生成树 - Virtual Judge (vjudge.net)

题目：

A - 关押罪犯：

#include <bits/stdc++.h>
using namespace std;
const int N=200005;
int fa[N],d[N];
typedef struct stu{
	int a;
	int b;
	int c;
}node; 
node q[N];
int find(int x){
	if(fa[x]==x)return x;
	return fa[x]=find(fa[x]);
}
void merge(int x,int y){
	x=find(x);y=find(y);
	fa[x]=y;
}
bool cmp(node x,node y){
	return x.c>y.c;
}
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)fa[i]=i;
	for(int i=1;i<=m;i++){
		cin>>q[i].a>>q[i].b>>q[i].c;
	}
	sort(q+1,q+m+1,cmp);
	for(int i=1;i<=m+1;i++){
		if(find(q[i].a)==find(q[i].b)){
			cout<<q[i].c;
			break;
		}
		else{
			if(!d[q[i].a])d[q[i].a]=q[i].b;
			else merge(d[q[i].a],q[i].b);
			if(!d[q[i].b])d[q[i].b]=q[i].a;
			else merge(d[q[i].b],q[i].a);
		}
	}
	return 0;
}

我们先将所有囚犯之间的矛盾按怨气大小排序，怨气最大的那两个人一定是优先放在俩个地方，我们枚举排序过的囚犯组合，先判断他们是否再同一并查集内，若是则直接输出答案，不是就分别判断他俩目前是否有敌人，若无则将敌人记录下来，若有则将该囚犯的两个敌人合并至一个并查集内（敌人的敌人就是朋友），不断进行以上操作最终可以得到答案。

B - Shichikuji and Power Grid：

 

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long
typedef pair<int,int> PII;
struct node{
	int x,y,c,k;
}a[2005];
struct nod{
	int fa,ne,w; 
}p[4000040];
int cnt = 0;
int sum = 0;
vector<int> ans;
vector<PII> res; 
int f[2005];
int find(int x){
	if(f[x] == x)
	return x;
	return f[x] = find(f[x]); 
}
bool cmp(nod a,nod b){
	return a.w < b.w;
} 
void solve(){
	int n;
	cin >> n; 
	for(int i = 1;i <= n;i++){
		cin >> a[i].x >> a[i].y;
	}
	for(int i = 1;i <= n;i++)
	f[i] = i;
	for(int i = 1;i <= n;i++){
		cin >> a[i].c;
		p[++cnt].fa = 0;
		p[cnt].ne = i;
		p[cnt].w = a[i].c;
	}
	for(int i = 1;i <= n;i++){
		cin >> a[i].k;
	}
	for(int i = 1;i <= n;i++){
		for(int j = i + 1;j <= n;j++){
			p[++cnt].fa = i;
			p[cnt].ne = j;
			p[cnt].w = (abs(a[i].x - a[j].x) + abs(a[i].y - a[j].y))*(a[i].k + a[j].k);
		}
	}
	sort(p + 1,p +1 + cnt,cmp);
	int s = 0;
	for(int i = 1;i <= cnt;i++){
		int x = find(p[i].fa);
		int y = find(p[i].ne);
		if(x == y){
			continue;
		}
		if(p[i].fa == 0){
			ans.push_back(p[i].ne);
		}
		else{
			res.push_back({p[i].fa,p[i].ne});
		}
		f[x] = y;
		sum += p[i].w;
		s++; 
		if(s == n)
		break;
	}
	cout << sum <<"\n";
	cout << ans.size() <<"\n";
	for(auto i:ans)	
	cout <<i << ' ';
	cout <<"\n";
	cout << res.size() <<"\n";
	for(auto t:res){
		cout <<t.first <<" "<<t.second <<"\n";
	}
}
signed main(){
	int t = 1;
	while(t--)
	{
		solve(); 
	}
	return 0;
}

超级源点问题。

C - Power Tree：（待补）

 

D - 食物链：

 

#include <bits/stdc++.h>
using namespace std;
const int N = 50010;
int n, m;
int p[N], d[N];
int find(int x){
    if (p[x] != x){
        int t = find(p[x]);
        d[x] += d[p[x]];
        p[x] = t;
    }
    return p[x];
}
int main(){
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) p[i] = i;
	int res = 0;
    while (m -- ){
        int t, x, y;
        scanf("%d%d%d", &t, &x, &y);
        if (x > n || y > n) res ++ ;
        else{
            int px = find(x), py = find(y);
            if (t == 1){
                if (px == py && (d[x] - d[y]) % 3) res ++ ;
                else if (px != py){
                    p[px] = py;
                    d[px] = d[y] - d[x];
                }
            }
            else{
                if (px == py && (d[x] - d[y] - 1) % 3) res ++ ;
                else if (px != py){
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];
                }
            }
        }
    }
    printf("%d\n", res);
    return 0;
}

非常经典的带权并查集题目了，我们可以开一个数组d，d[i]表示i这个点到根节点的距离，我们我们将同类的点距离设为0，捕食关系距离设为1，被捕食关系距离设为2，我们就可以据此通过两个点之间的距离%3来判断他们之间的关系。

E - How Many Answers Are Wrong：（待补）

 

F - 银河英雄传说：

 

#include <bits/stdc++.h>
using namespace std;
const int N=300005;
int fa[N],d[N],a[N];
int find(int x){
	if(fa[x]!=x){
		int u=fa[x];
		fa[x]=find(fa[x]);
		d[x]+=d[u];
		a[x]=a[fa[x]];
	}
	return fa[x];
}
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=300000;i++){
		fa[i]=i;d[i]=0;a[i]=1;
	}
	for(int i=1;i<=n;i++){
		char s;
		int x,y,fx,fy;
		cin>>s>>x>>y;
		if(s=='M'){
			fx=find(x);fy=find(y);
			fa[fx]=fy;
			d[fx]+=a[fy];
			a[fx]+=a[fy];a[fy]=a[fx];
		}
		if(s=='C'){
			fx=find(x);fy=find(y);
			if(fx!=fy){
				cout<<-1<<endl;
				continue;
			}
			else{
				cout<<abs(d[x]-d[y])-1<<endl;
			}
		}
	}
	return 0;
}

这题和上题类似，不过多了一个a数组，主要作用是维护连通块的大小以正确表达出该点到根节点的距离。

G - News Distribution：

 

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
const int maxn=1e6+5;
int n,m,f[maxn],num[maxn];
int find_x(int x) {
	if(f[x]!=x)return f[x]=find_x(f[x]);
	else return f[x];
}
void unite(int x,int y) {
	int aa=find_x(x);
	int bb=find_x(y);
	if(aa!=bb)f[aa]=bb;
}
int main() {
	IOS;
	cin>>n>>m;
	for(int i=0; i<=n; i++)f[i]=i;
	while(m--){
		int k,a,b;
		cin>>k;
		if(k!=0)cin>>a;
		for(int i=1; i<k; i++) {
			cin>>b;
			unite(a,b);
		}
	}
	for(int i=1; i<=n; i++)num[find_x(i)]++;
	cout<<num[find_x(1)];
	for(int i=2; i<=n; i++)cout<<" "<<num[find_x(i)];
	cout<<endl;
}

题目可理解为输出1 - n每个号码所在团体总人数，利用并查集不断向集合添加成员，记录每个集合的人数，保存在根节点的sum[]中，查询每个节点的根节点，输出根节点sum

H - Phase Shift（待补）：

 

I - 星球大战：​​​​​​​

#include <bits/stdc++.h>
using namespace std;
const int N = 4 * 1e5 + 10; // 全局变量;
int res;    // 储存答案;
int n, m, k;
// n 星球数目, m 以太隧道数目, k 遭受攻击的星球数目
int fa[N];
// 并查集
int h[N], s[N], e[N], ne[N], idx;
// 存图, e[] 存边到达的终点, s 存边的起点
bool st[N];

void add(int a, int b) 
{
    e[idx] = b, s[idx] = a, ne[idx] = h[a], h[a] = idx ++;
}

int find(int x) // 并查集, 找祖先 (路径压缩)
{
    if (x == fa[x]) return x;
    return fa[x] = find(fa[x]);
}

int main()
{
    memset(h, -1, sizeof h);    // 初始化表头
    memset(st, true, sizeof st);// 初始时没有点被摧毁

    scanf("%d %d", &n, &m);

    for (int i = 1; i <= n; i ++ ) fa[i] = i;

    for (int i = 1; i <= m; i ++ )  
    {
        int x, y;

        scanf("%d %d", &x, &y);
        add(x, y), add(y, x);   // 读入无向边
    }

    scanf("%d", &k);    // 读入遭受攻击的星球数目

    stack<int> pk, ans; 
    // 分别储存 pk 被攻击的星球, ans 输出答案
    for (int i = 1; i <= k; i ++ )
    {
        int q;
        scanf("%d", &q);

        st[q] = false, pk.push(q);  
        // 标记为摧毁, 算法核心是将摧毁转换成 修建 , 所以逆时间顺序压入栈中
    }

    m = 2 * m, res = n - k;
    // 无向边边数 * 2, res 储存连通块数量
    for (int i = 1; i <= m; i ++ )  // 先找所有完好的边构成的连通块数量
    {
        int S = find(s[i]), E = find(e[i]); 
        // 先找到这条边的入点和出点
        if(st[e[i]] && st[s[i]] && S != E)  // 如果这两条边都没有被摧毁, 且不在同一个连通块中
        {
            res --;     // 连通块的数量就可以减一了
            fa[E] = S;  // 加入同一个连通块
        }
    }

    ans.push(res);  // 逆时间的初始答案, k 个点都被摧毁 或 理解为没有新增的点
    while(pk.size())    // 只要不为空
    {
        int tot = pk.top(); // 取出栈顶
        pk.pop();
        res ++;         // 多了一个星球，连通块数量加一
        st[tot] = true; // 当前星球已被修建

        for (int i = h[tot]; i != -1; i = ne[i])    // 遍历这个点的所有出边
        {
            int j = e[i];   // 边的终点
            int S = find(tot), E = find(e[i]);  // 找到起点和终点的祖先
            if (st[j] && S != E)    // 终点没有被摧毁, 不是一个祖先也就是不在一个连通块中
            {
                res --;     // 连通块数量减一
                fa[E] = S;  // 加入一个连通块
            }
        }
        ans.push(res); // 压入当前修建好这个星球的答案
    }
    while (ans.size()) // 逆输出答案
    {
        res = ans.top();
        ans.pop();
        printf("%d\n", res);
    }

    return 0;
}

 逆向过程建图。

J - 货车运输：​​​​​​​

 

#include<bits/stdc++.h>  
const int  MAXN =10005 ;
const long long  INF =999999999; 
using namespace std; 
struct Edge1{  
    int x,y,dis;
}edge1[50005]; 
struct Edge2{
    int to,next,w;
}edge2[100005];  
int cnt,n,m,head[MAXN],deep[MAXN],f[MAXN],fa[MAXN][21],w[MAXN][21];
bool vis[MAXN]; 
void addedge(int from, int to, int w){
    edge2[++cnt].next=head[from];
    edge2[cnt].to=to;
    edge2[cnt].w=w;
    head[from]=cnt;
    return ;
}

bool CMP(Edge1 x, Edge1 y){
    return x.dis>y.dis;
}

int find(int x){ 
    if(f[x]!=x) f[x]=find(f[x]);
    return f[x];
}

void kruskal(){
    sort(edge1+1, edge1+m+1, CMP); 
    for(int i=1; i<=n; i++)
        f[i]=i;  
    for(int i=1; i<=m; i++)
        if(find(edge1[i].x)!=find(edge1[i].y)){
            f[find(edge1[i].x)]=find(edge1[i].y);
            addedge(edge1[i].x, edge1[i].y, edge1[i].dis);
            addedge(edge1[i].y, edge1[i].x, edge1[i].dis); 
			}
    return ;
}

void dfs(int node){
    vis[node]=true;
    for(int i=head[node]; i; i=edge2[i].next){ 
        int to=edge2[i].to;
        if(vis[to]) continue;
        deep[to]=deep[node]+1; 
        fa[to][0]=node; 
        w[to][0]=edge2[i].w;  
        dfs(to);
    }
    return ;
}

int lca(int x, int y)
{
    if(find(x)!=find(y)) return -1; 
    int ans=INF;
    if(deep[x]>deep[y]) swap(x,y);  
    for(int i=20; i>=0; i--)
        if(deep[fa[y][i]]>=deep[x]){
            ans=min(ans, w[y][i]); 
            y=fa[y][i]; 
        }
    if(x==y) return ans;
  
    for(int i=20; i>=0; i--)
        if(fa[x][i]!=fa[y][i]){
            ans=min(ans, min(w[x][i], w[y][i]));
            x=fa[x][i]; 
            y=fa[y][i];
        }
    ans=min(ans, min(w[x][0], w[y][0]));
    return ans;
}

int main()
{
    int x,y,z,q;
    scanf("%d%d",&n,&m);
    for(int i=1; i<=m; i++){
        scanf("%d%d%d",&x,&y,&z);
        edge1[i].x=x;
        edge1[i].y=y;
        edge1[i].dis=z;
    }
    kruskal();
    for(int i=1; i<=n; i++)
        if(!vis[i]){
            deep[i]=1; 
            dfs(i);
            fa[i][0]=i;
            w[i][0]=INF;
        }
    for(int i=1; i<=20; i++)
        for(int j=1; j<=n; j++){
            fa[j][i]=fa[fa[j][i-1]][i-1]; 
            w[j][i]=min(w[j][i-1], w[fa[j][i-1]][i-1]);
        }
    scanf("%d",&q);
    for(int i=1; i<=q; i++){
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y)); 
    }
    return 0;
}

最大生成树+lca倍增。

K - 程序自动分析：​​​​​​​

 

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

using namespace std;

const int N = 200010;

int n, m;
int p[N];
unordered_map<int, int> S;

struct Query
{
    int x, y, e;
}query[N];

int get(int x)
{
    if (S.count(x) == 0) S[x] = ++ n;
    return S[x];
}

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T -- )
    {
        n = 0;
        S.clear();
        scanf("%d", &m);
        for (int i = 0; i < m; i ++ )
        {
            int x, y, e;
            scanf("%d%d%d", &x, &y, &e);
            query[i] = {get(x), get(y), e};
        }

        for (int i = 1; i <= n; i ++ ) p[i] = i;

        // 合并所有相等约束条件
        for (int i = 0; i < m; i ++ )
            if (query[i].e == 1)
            {
                int pa = find(query[i].x), pb = find(query[i].y);
                p[pa] = pb;
            }

        // 检查所有不等条件
        bool has_conflict = false;
        for (int i = 0; i < m; i ++ )
            if (query[i].e == 0)
            {
                int pa = find(query[i].x), pb = find(query[i].y);
                if (pa == pb)
                {
                    has_conflict = true;
                    break;
                }
            }

        if (has_conflict) puts("NO");
        else puts("YES");
    }

    return 0;
}

见注释。

L - 蔬菜：（待补）

 这个真不会捏。

后记：

  里面有些题难度已经很高了，我连题解都看不懂，以后再补吧！

 

*goliter *
关注
  • 16
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NEFU计组实验3 存储器实验.rar
06-29
NEFU2020.6.29计算机组成原理实验logisim文件，仅供参考，参考，参考 一、 实验目的 理解并掌握存储器的读、写操作过程 理解存储操作中锁存脉冲的作用 掌握存储操作中时序电路的作用 实验内容 学会对MAR寄存器的使用...
【机器学习】python构建ID3决策树+pygraphviz可视化（代码详解，附注释）
05-04
机器学习实验，python...python实现ID3算法构建决策树，并用pygraphviz进行可视化操作； 数据集使用西瓜数据集2.0； 建议配套我的博客文章使用：https://blog.csdn.net/ljw_study_in_CSDN/article/details/116375359
并查集-算法详解及例题(最小生成树问题)
Gaoithe的博客
06-01 1031
一、并查集的概念： 并查集（Union-find Sets）是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。一些常见的用途有求连通子图、求最小生成树的 Kruskal 算法和求最近公共祖先（Least Common Ancestors, LCA）等。 使用并查集时，首先会存在一组不相交的动态集合 S={S1,S2,⋯,Sk}S={S1,S2,⋯,Sk}，一般都会使用一...
nefu暑假acm集训1 构造矩阵 个人模板+例题汇总
Wzh20060111的博客
08-29 523
后记：前言：以下都是nefu暑假集训的训练题，我在此把我的模板和写的一些练习题汇总一下并分享出来，希望在能满足我复习的情况下能帮助到你。
nefu暑假集训2 ST表 个人模板+例题汇总
最新发布
Wzh20060111的博客
08-30 183
前言：比较简单的一个算法了，原理相当于是用二进制优化的区间dp了，用于求一个区间的最大或最小值。其实这类问题一般用线段树就可以直接解决，但如果查询次数过多的话可能会超时，这时就是ST表出场的时候了，因为ST表是现预处理的，所以查询的操作时间复杂度为o（1）。
并查集-最小生成树，带权并查集，种类并查集。
凯撒袁六兽的blog
07-14 489
并查集： 一：并查集的定义 二：并查集的过程以及基本操作 三：并查集的应用： 对于定义的使用——判断图是否是树 最小生成树问题 四：相应的题目 并查集的定义： 并查集是一种树型的数据结构，用于动态处理一些不相交集合（Disjoint Sets）的合并及查询问题。 并查集的过程以及基本操作： 过程： 运用并查集的过程就是先将每一个元素看成一个独立的集合，这个时候每一个集合的标识，再将不同的元素（集合）两两合并到一个集合当中，这就是并查集的合并，在合并的过程中这两个元素就连接在一起了，其中一个元素变成儿子
NEFU大一暑假集训-并查集（ABCDEFGIJ）
Tan_Yuu的博客
08-16 630
题集链接 目录：OPA 食物链思路代码B 关押罪犯思路代码C 程序自动分析思路代码D 最小生成树思路代码F 修复公路思路代码G 奶酪思路代码I City题目大意思路代码ED OP 感谢ph和zsl两位大佬的指导与讨论； A 食物链 思路 查看PDF即可~ 两种做法，下面代码中选择了扩展域； 代码 #include <stdio.h> #include<iostream> using namespace std; typedef long long ll; int fa[150004]
并查集/最小生成树-kruskal算法（2019.4.6训练）
nefu_ljw的博客
04-07 719
A题 hdu 1232 畅通工程 并查集模板题，掌握find(x)函数和join(a,b)函数的用法即可。 find(x)函数表示找x的祖先节点，使用了路径压缩算法，在找x的祖父节点的同时，还使从x结点搜索祖先结点的过程中所经过的所有结点都指向该祖先节点。 join(a,b)函数表示把a的祖先节点以及a下面的所有子节点全都指向b的祖先节点，这是由于find函数运用了路径压缩算法，使从a开始搜索时经...
并查集配套例题
NEFU AB-IN's Blog
07-05 228
find，join函数
2020年第十五届黑龙江省大学生程序设计竞赛 B. Bills of Paradise【线段树/树状数组+并查集】
nefu_ljw的博客
10-09 1319
传送门：B. Bills of Paradise 题意 给你一个函数，由它产生nnn个数a1...ana_1...a_na1​...an​，现在有qqq次操作，操作有以下四种： D x。标记大于等于xxx的第一个未标记的aia_iai​；若没有，则不操作。 F x。查询大于等于xxx的第一个未标记的aia_iai​；若没有，则输出101210^{12}1012。 R x。清除小于等于xxx的所有标记；若没有，则不操作。 C x。查询小于等于xxx的所有未标记数之和；若没有，则输出000。 思路 n=1e
离线处理，并查集，拆网
Landing_on_Mars的博客
09-05 170
将所有的数据先读入并存储起来，并且处理成最后的状态，我们从最后的状态往回处理，即先将边拆掉，再将边一条一条建回去，这样就将题目转换成了并查集擅长的形式。但由于并查集擅长的是建边，而不是题目所讲的拆边，所一这道题并不能直接使用并查集；接下来m行，每行两个整数代表该边所连接的点编号，边的编号按输入顺序从0递增；1 a b：查询a b结点是否联通，若是请输出yes，否则输出no。第一行三个整数n，m，q（1
NEFU算法设计与分析实验报告
06-28
**NEFU算法设计与分析实验报告** 在信息技术领域，算法是解决问题的核心工具，它们通过精心设计的步骤序列来处理数据和执行任务。本实验报告主要关注的是“NEFU”算法，这是一种由东北林业大学（Northeast Forestry...
NEFU计组实验2 运算器实验 .rar
06-05
NEFU2020.6.5计算机组成原理实验logisim文件，仅供参考，参考，参考 实验目的 掌握模拟过程中算术、逻辑运算单元的控制方法 理解寄存器组中寄存器数据输出的方法 实验内容 有8种运算，通过S2，S1，S0 来选择，具体...
NEFU计组实验1 寄存器实验 .rar
06-05
NEFU2020.6.5计算机组成原理实验logisim文件，仅供参考，参考，参考 实验目的： 一、 实验目的 理解并掌握存储器的读、写操作过程 理解存储操作中锁存脉冲的作用 掌握存储操作中时序电路的作用 实验内容： 学会对MAR...
趣味算法------试用 6 和 9 组成的最大数字
markingyi的博客
08-26 541
给出一个数字，反转其中一位使数字最大化，递归求解。
递归、搜索与回溯算法
无聊_人的博客
08-29 2327
所谓的递归其实就是函数自己调用自己的情况。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 2161
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
力扣（无重叠区间）
yyssas的博客
08-29 2654
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
nefu算法设计与分析
05-17
东北林业大学（NEFU）的算法设计与分析是一门涵盖算法基础知识、算法设计和分析等方面的课程。该课程主要包括以下内容： 1. 算法的时间复杂度和空间复杂度 2. 基本数据结构：数组、链表、栈、队列、树、图等 3. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序等 4. 查找算法：线性查找、二分查找等 5. 图算法：最短路径、最小生成树、拓扑排序等 6. 动态规划：背包问题、最长公共子序列、最优二叉搜索树等 7. 网络流算法：最大流、最小割等 在学习过程中，学生需要掌握算法的基本概念和设计思想，能够使用常见算法解决实际问题，并且能够对算法进行正确的分析和评估。此外，学生还要具备使用编程语言实现算法的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值