倍增 ST表 & RMQ & LCA

已于 2022-11-10 10:38:05 修改
阅读量147 收藏 2
点赞数 1
分类专栏： 算法 文章标签： 1024程序员节
于 2022-10-24 14:14:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57862276/article/details/127450860
版权
本文通过三个实例展示了数据结构与算法在解决信息技术问题中的重要作用。第一部分介绍了LCA最近公共祖先的计算，利用链式前向星进行图的构建；第二部分讨论了如何利用并查集和LCA计算两点间的距离；第三部分涉及二维ST表在区间最值问题上的应用。这些案例揭示了数据结构和算法在高效解决复杂问题中的核心价值。
摘要由CSDN通过智能技术生成

1. LCA 最近公共祖先

板子(链式前向星建图)：

void dfs(int x,int fa)
{
	for(int i=fi[x];i!=-1;i=nxt[i])
	{
		int k=e[i].to;
		if(k==fa)
		  continue;
	    dep[k]=dep[x]+1;
	    f[k][0]=x;
	    for(int j=0;j<=17;j++)
	    {
	    	f[k][j]=f[f[k][j-1]][j-1];
		}
		dfs(k,x);
	}
}
int lca(int x,int y)
{
	if(dep[x]<dep[y])
	  return lca(y,x);
	for(int i=17;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])
		{
			x=f[x][i];
		}
	}
	if(x==y)
	  return x;
	for(int i=17;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])
		{
			x=f[x][i];
			y=f[y][i];
		}
	}
	return f[x][0];
}

练习：
1.poj1330
思路：板子题。

#include<bits/stdc++.h>
using namespace std;
const int N=30001;
struct node
{
	int nxt,to;
}e[N];
int pre[N];
int n;
int fi[N];
int f[N][20],dep[N];
int cnt=0;
int t;
void add(int x,int y)
{
	e[++cnt].to=y;
	e[cnt].nxt=fi[x];
	fi[x]=cnt;
	e[++cnt].to=x;
	e[cnt].nxt=fi[y];
	fi[y]=cnt;
}


void dfs(int x,int fa)
{
	for(int i=fi[x];i!=-1;i=e[i].nxt)
	{
		int j=e[i].to;
		if(j==fa)
		  continue;
		dep[j]=dep[x]+1;
		f[j][0]=x;
		for(int i=1;i<=17;i++)
		{
			f[j][i]=f[f[j][i-1]][i-1];
		}
		dfs(j,x);
	}
}


int lca(int x,int y)
{
	if(dep[y]>dep[x])
	{
		return lca(y,x);
	}
	for(int i=17;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])
		  x=f[x][i];
	}
	if(x==y)
	  return x;
	for(int i=17;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])
		{
			x=f[x][i];
			y=f[y][i];
		}
	}
	return f[x][0];
}
void solve()
{
	memset(fi,-1,sizeof(fi));
	memset(f,0,sizeof(f));
	memset(dep,0,sizeof(dep));
	memset(pre,0,sizeof(pre));
	cnt=0;
	cin>>n;
	int x,y;
	int root;
	for(int i=1;i<n;i++)
	{
		
		cin>>x>>y;
		pre[y]++;
		add(x,y);
	}
	for(int i=1;i<=n;i++)
	{
		if(pre[i]==0)
		{
			root=i;
			break;
		}
	}
	dep[root]=1;
    dfs(root,-1);
	cin>>x>>y;
	cout<<lca(x,y)<<endl;
}
int main()
{
	cin>>t;
	while(t--)
	{
		solve();
	}
	return 0;
}

2.HUD2586
思路：A,B 2个节点的距离 == A到根的距离+B到根的距离-2*lca(A,B)的距离

#include<bits/stdc++.h>
using namespace std;
int t;
const int N=4e4+11;
int n,m;
struct node
{
	int nxt,to,w;
}e[N*2];
int first[N];
int f[N][20];
int dep[N];
int pre[N];
int dis[N];
int cnt=0;
void dfs(int x,int fa)
{
	for(int i=first[x];i!=-1;i=e[i].nxt)
	{
		int j=e[i].to;
		if(j==fa)
		  continue;
		f[j][0]=x;
		for(int i=1;i<=17;i++)
		{
			f[j][i]=f[f[j][i-1]][i-1];
		}
		dep[j]=dep[x]+1;
		dis[j]=dis[x]+e[i].w;
		dfs(j,x);
	}
}
int lca(int x,int y)
{
	if(dep[x]<dep[y])
	  return lca(y,x);
	for(int i=17;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])
		{
			x=f[x][i];
		}
	}
	if(x==y)
	  return x;
	for(int i=17;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])
		{
			x=f[x][i];
			y=f[y][i];
		}
	}
	return f[x][0];
}
void init()
{
	cnt =0;
	memset(first,-1,sizeof(first));
	memset(f,0,sizeof(f));
	memset(dep,0,sizeof(dep));
	memset(dis,0,sizeof(dis));
	memset(pre,0,sizeof(pre));
}
void add(int x,int y,int z)
{
	e[++cnt].to=y;
	e[cnt].nxt=first[x];
	first[x]=cnt;
	e[cnt].w=z;	
}
void solve()
{
	int root;
	for(int i=1;i<=n;i++)
	{
		if(pre[i]==0)
		{
			root=i;
			break;
		}
	}
	dep[root]=1;
	dis[root]=0;
	
	dfs(root,-1);
	while(m--)
	{
		int x, y;
		cin>>x>>y;
		cout<<dis[x]+dis[y]-2*dis[lca(x,y)]<<endl;
	}
}
int main()
{
	cin>>t;
	while(t--)
	{
		cin>>n>>m;
		init();
		int x,y,z;
		for(int i=1;i<n;i++)
		{
			cin>>x>>y>>z;
			add(x,y,z);
			add(y,x,z);
			pre[y]++;
		}
		solve();	
	}	
 }

3.HUD2874
思路：并查集+第二题的思路

#include<bits/stdc++.h>
using namespace std;
int n,m,c;
const int N=1e5+11;
int fa[N];
struct node
{
	int w;
	int nxt,to;
}e[2*N];
int h[N*2];
int cnt;
int pre[N];
int dis[N];
int dep[N];
int f[N][20];
int root;
int find(int x)
{
	if(x==fa[x])
	  return x;
	fa[x]=find(fa[x]);
	return fa[x];	
}
void Add(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x!=y)
	  fa[y]=x;
}
void add(int x,int y,int z)
{
	e[++cnt].w=z;
	e[cnt].to=y;
	e[cnt].nxt=h[x];
	h[x]=cnt;
}
int lca(int x,int y)
{
	if(dep[y]>dep[x])
	  return lca(y,x);
	for(int i=17;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])
		{
			x=f[x][i];
		}
	}
	if(x==y)
	  return x;
	for(int i=17;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])
		{
			x=f[x][i];
			y=f[y][i];
		}
	}
	return f[x][0];
}
void dfs(int x,int fa)
{
	for(int i=h[x];i!=-1;i=e[i].nxt)
	{
		int j=e[i].to;
		if(j==fa)
		  continue;
		for(int i=1;i<=17;i++)
		{
			f[j][i]=f[f[j][i-1]][i-1];
		}
		dep[j]=dep[x]+1;
		dis[j]=dis[x]+e[i].w;
		dfs(j,x);	
	}
     	
}
void init()
{
	for(int i=1;i<=n;i++)
	{
		fa[i]=i;
	}
	memset(dis,0,sizeof(dis));
	memset(f,0,sizeof(f));
	memset(pre,0,sizeof(pre));
	memset(dep,0,sizeof(dep));
	memset(h,-1,sizeof(h));
	cnt=0;
}
void solve()
{
	int x,y,z;
	for(int i=1;i<=m;i++)
	{
		cin>>x>>y>>z;
		add(x,y,z);
		add(y,x,z);
		pre[y]++;
		Add(x,y);
	}
	for(int i=1;i<=n;i++)
	{
		if(pre[i]==0)
		{
			dep[i]=1;
			dis[i]=0;
			dfs(i,-1);
		}
	}
	while(c--)
	{
		cin>>x>>y;
		if(find(x)!=find(y))
		{
			cout<<"Not connected"<<endl;
		}
		else
		{
			cout<<dis[y]+dis[x]-2*dis[lca(x,y)]<<endl;
		}
	}
}
int main()
{
	while(cin>>n>>m>>c)
	{
		init();
		solve();
	}
	return 0;
}

2. RMQ区间最值问题

ST表

void ST()
{
	for(int i=1;i<=n;i++)
	  f[i][0]=a[i];
	int k=log(n);
	for(int i=1;i<=k;i++)
	{
		for(int j=1;j+(1<<i)<=n+1;j++)
		{
			f[j][i]=max(f[j][i-1],f[j+(1<<(i-1))][i-1])
		}
	}	
}
int ST_find(int l,int r)
{
	int k=log2((r-l+1));
	return max(f[l][k],f[r-(1<<k)+1][k]); 
}

1.poj3264
思路：f1存区间最大，f2存区间最小

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
using namespace std;
int n,q;
const int N=5e5+11;
int a[N];
int f1[N][20];
int f2[N][20];
void ST()
{
	for(int i=1;i<=n;i++)
	{
		f1[i][0]=a[i];
		f2[i][0]=a[i];
	}
	   int k=log(n)/log(2);
       for (int j = 1; (1 << j) <= n; j ++ )
       {
	   
		for (int i = 1; i + (1 << j) - 1 <= n; i ++ )
		{
		
			f1[i][j] = max(f1[i][j - 1], f1[i + (1 << (j - 1))][j - 1]);
			f2[i][j]=min(f2[i][j-1],f2[i+(1<<(j-1))][j-1]);
		 
		}
	}	
}
int ST_find1(int l,int r)
{
	int k=log(r-l+1)/log(2);
	return max(f1[l][k],f1[r-(1<<k)+1][k]);
}
int ST_find2(int l,int r)
{
	int k=log(r-l+1)/log(2);
	return min(f2[l][k],f2[r-(1<<k)+1][k]);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>q;
	for(int i=1;i<=n;i++)
	{
	    cin>>a[i];
	}
//	memset(f2,200001,sizeof(f2));
	ST();
	int l,r;
	while(q--)
	{
		cin>>l>>r;
		cout<<ST_find1(l,r)-ST_find2(l,r)<<endl;
	}
	return 0; 	  
}

2.poj 3368
思路：…ez

#include<iostream>
#include<cmath>
using namespace std;
int n,m;
const int N=1e5+11;
int e[N];
int f[N][20];
int a[N];
int find(int l,int r)
{
	int k=log(r-l+1)/log(2);
	return max(f[l][k],f[r-(1<<k)+1][k]);	
}
void st()
{
	int k=log(n)/log(2);
	for(int i=1;i<=n;i++)
	{
		f[i][0]=e[i];
	}
	for(int i=1;i<=k;i++)
	{
		for(int j=1;j+(1<<i)-1<=n;j++)
		{
			f[j][i]=max(f[j][i-1],f[j+(1<<(i-1))][i-1]);
		}
	}
}
void solve()
{
	int x;
   for(int i=1;i<=n;i++)
   	 cin>>a[i];
    for(int i=1;i<=n;i++)
    {
    	if(i==1)
    	  e[i]=1;
    	else
    	{
    		if(a[i]==a[i-1])
    		{
    			e[i]=e[i-1]+1;
			}
			else
			{
				e[i]=1;
			}
		}
	}
	st();
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	while(cin>>n && n)
	{
	      cin>>m;
	      solve();
	      int l,r;
		while(m--)
		{
		   cin>>l>>r;   
	       int t=0;
	       while(e[l]!=1 && l<=r)
	       {
	       	 l++;
	       	 t++;
		   }
		   if(l<=r)
		     t=max(t,find(l,r));
		   cout<<t<<endl;
		}		
	}	
}

3.poj2019（二维ST）
思路：将2维转为一维的

#include<iostream>
#include<cmath>
using namespace std;
int n,b,k;
const int N=257;
int a[N][N];
int f1[N][N][8][8];
int f2[N][N][8][8];
void st()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			f1[i][j][0][0]=a[i][j];
			f2[i][j][0][0]=a[i][j];
		}
	}
	int kk= log(b)/log(2);
	for(int k1=0;k1<=kk;k1++)
	{
		for(int k2=0;k2<=kk;k2++)
		{
			if(!k1 &&  !k2)
			  continue;
			for(int i=0;i+(1<<k1)-1<=n;i++)
			{
				for(int j=0;j+(1<<k2)-1<=n;j++)
				{
					
				 if(k1==0)	
				 {
				 	f1[i][j][k1][k2]=max(f1[i][j][k1][k2-1],f1[i][j+(1<<(k2-1))][k1][k2-1]);
				 	f2[i][j][k1][k2]=min(f2[i][j][k1][k2-1],f2[i][j+(1<<(k2-1))][k1][k2-1]);
				 }
				 else
				 {			 
                   f1[i][j][k1][k2]=max(f1[i][j][k1-1][k2],f1[i+(1<<(k1-1))][j][k1-1][k2]);
                   f2[i][j][k1][k2]=min(f2[i][j][k1-1][k2],f2[i+(1<<(k1-1))][j][k1-1][k2]);
//			    f1[i][j][k1][k2]=max(max(f1[i][j][k1-1][k2-1],f1[i+(1<<(k1-1))][j][k1-1][k2-1]),max(f1[i][j+(1<<(k2-1))][k1-1][k2-1],f1[i+(1<<(k1-1))][j+(1<<(k2-1))][k1-1][k2-1]));
//		     	f2[i][j][k1][k2]=min(min(f1[i][j][k1-1][k2-1],f1[i+(1<<(k1-1))][j][k1-1][k2-1]),min(f1[i][j+(1<<(k2-1))][k1-1][k2-1],f1[i+(1<<(k1-1))][j+(1<<(k2-1))][k1-1][k2-1]));
//		       
				}
			}
		}
	}
}

	
}
int find(int x,int y,int xx,int yy)
{
	int l1=log(xx-x+1)/log(2);
	int l2=log(yy-y+1)/log(2);
    int m1,m2,m3,m4;
    m1=f1[x][y][l1][l2];
    m2=f1[xx-(1<<l1)+1][y][l1][l2];
    m3=f1[x][yy-(1<<l2)+1][l1][l2];
    m4=f1[xx-(1<<l1)+1][yy-(1<<l2)+1][l1][l2];
    int maxn=max(max(m1,m2),max(m3,m4));
    
    m1=f2[x][y][l1][l2];
    m2=f2[xx-(1<<l1)+1][y][l1][l2];
    m3=f2[x][yy-(1<<l2)+1][l1][l2];
    m4=f2[xx-(1<<l1)+1][yy-(1<<l2)+1][l1][l2];
    int minn=min(min(m1,m2),min(m3,m4));
    
    return maxn-minn;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>b>>k;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		  cin>>a[i][j];
	}
	st();
//	for(int i=0;i<=3;i++)
//	{
//		print(i);
//		cout<<"----"<<endl;
//	}
//	cout<<endl<<" ----"<<endl;
	int x,y;

	while(k--)
	{
		cin>>x>>y;
		cout<<find(x,y,x+b-1,y+b-1)<<endl;	
	}
    return 0;
 }

mood: Edge runners 请添加图片描述
an appointment on the moon

dai _ tu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
倍增（ST表与LCA）
qq_51070956的博客
08-07 263
ST表是基于倍增思想解决可重复贡献问题的数据结构。其中ST表最广泛的应用就是解决RMQ(区间最值问题)： 给定一个包含n个数的数组，以及m次询问，每次询问给出一个区间[l, r],需要我门输出区间中的最小/大值。基于倍增的思想，ST表可以实现 O(NlogN) 下进行预处理，并在O(1) 时间内回答每个询问。但是,ST表并不支持修改操作。祖先：指的是一个结点向根节点遍历的路径上经过的所有结点(包括该节点本省身)。...
ST表&LCA
weixin_43918473的博客
08-21 372
A - [RMQ] Balanced Lineup POJ - 3264 题意：给n个数，求区间(l,r)最大值与最小值之差。 RMQ板子题。 在这里插入代码片
LCA:倍增算法 && RMQ算法
weixin_30647065的博客
09-23 48
第二篇博客我们今天来讲讲LCA，其实我也是刚刚学会的。效果还不错。 LCA一般有三种算法：倍增、RMQ、tarjan。 我们先来聊聊倍增，建图O(nlogn)，查询O(logn)，代码简单易懂，实际效率也不错。 我们就以code[vs]2370 小机房的树为例吧！ 2370 小机房的树 时间限制: 1 s 空间限制: 256000 K...
学习 LCA&&RMQ
gg_gogoing的专栏
02-13 1003
参考:点击打开链接 点击打开链接      点击打开链接(一些总结) 点击打开链接(不错的模板) 题目:点击打开链接 花了4天时间做完了这个专题,LCA的问题用处还是很大,同时能体会RMQ的ST算法中dp的味道.基本方法就是ST,LCA转RMQ,LCA的Tarjan,LCA倍增(这个可存储边权) 这个专题后面四道题都非常好,推荐大家做做. 细节: 1. ST方法2^i 包含自己,因此其真
暑假集训 || LCA && RMQ
weixin_30595035的博客
08-22 57
LCA定义为对于一颗树 树上两个点的最近公共祖先 一.Tarjan求LCA（离线方法 https://blog.csdn.net/lw277232240/article/details/77017517 二.倍增法求LCA void dfs(int u, int f) { for(int i = 1; i <= 18; i++) if...
LCA算法解析-Tarjan&倍增&RMQ
weixin_30861459的博客
07-29 141
原文链接http://www.cnblogs.com/zhouzhendong/p/7256007.html UPD(2018-5-13) : 细节修改以及使用了Latex代码，公式更加美观。改的过程中发现许多叙述上的问题，已经修改。然而得到这么多阅读量我真的是受宠若惊。于是我决定再补写一个在线$O(1)$查询的$RMQ$算法。 问题模型 　　对于一棵树，求两个节点的最近公共祖先（LCA）...
倍增 ST表
BrilliantWilliam的博客
01-26 1027
有关倍增算法和ST表的相关知识，适合初学者使用~
倍增 || ST-RMQ 求LCA
一只不争气的蒸汽机的博客
01-24 246
视频讲解戳这里(bj聚聚讲的非常好，一听就懂) 由luogu一道模板题讲起传送门(都9102年，这题还卡输入输出，要吸氧才能过) LCA：求两个点的最近公共祖先 倍增求LCA： 有很多博客图文并茂讲的非常清楚，倍增LCA的主要思想就是，先将u，v(保证u的深度更深)两点调整到同一水平线 情况一：u==v，那就说明最近公共祖先是u，这种情况说明u,v在同一边，祖先自然是深度较浅的那一个...
LCA&RMQ
ACdream
09-28 467
学习我final bin
8.17-8.18 倍增算法及其经典应用:RMQ+ST表、树上倍增求LCA
m0_62709362的博客
08-17 321
倍增算法及其经典应用:RMQ+ST表、树上倍增求LCA
St表欧拉序倍增搞LCA.zip_LCA_lca st表_st表
09-25
解决LCA问题通常有多种方法，例如深度优先搜索（DFS）、Morris遍历、RMQ（Range Minimum Query）等，而这里我们关注的是利用St表的方法。 St表，全称Segment Tree（线段树），是一种用于高效处理区间查询和修改的...
倍增法介绍以及应用（RMQ、LCA）
02-08
倍增法介绍以及应用（RMQ、LCA） 倍增法是一种常用的算法思想，广泛应用于解决范围查询、最近公共祖先等问题。下面，我们将详细介绍倍增法的定义、应用以及优化方法。 倍增法定义 ---------- 倍增法是指每个数是...
st表.zip_St table_Table
09-21
"St表欧拉序倍增搞LCA.zip"可能涉及到的另一个知识点是LCA（Lowest Common Ancestor，最近公共祖先）。在图论中，给定一棵树和两个节点，LCA问题就是要找出这两个节点在树中的最近公共祖先。在ST表的基础上，可以...
倍增算法入门 超详细解答+LCA+RMQ(ST表)+例题剖析
热门推荐
繁凡さん的博客
04-03 1万+
目录一、倍增算法二、倍增算法的应用：求LCA（最近公共祖先）附模板题三、倍增算法的应用：RMQ 问题（ST表）附模板题 一、倍增算法 要了解倍增之前，建议先看一下大佬的博客：【白话系列】倍增算法 看完以后相信你已经对倍增有了大致初步的了解，下面给出倍增的定义 （其实没什么用，好长一段话建议不看） 倍增 从字面的上意思看就是成倍的增长 ,这是指我们在进行递推时,如果状态空间很大,通常的线性递推无法满...
AutoTS-0.3.5-py3-none-any.whl.zip
09-01
AutoTS-0.3.5-py3-none-any.whl.zip
基于python的warrior管理系统笔记 (21).zip
最新发布
09-01
基于python的warrior管理系统笔记 (21).zip
弹性力学数值方法：变分法：变分法原理与应用.docx
09-01
弹性力学数值方法：变分法：变分法原理与应用.docx
弹性力学优化算法：蚁群算法(ACO)：弹性力学基础理论.docx
09-01
弹性力学优化算法：蚁群算法(ACO)：弹性力学基础理论.docx
544、基于单片机设计的32x64双色点阵程序、音乐频谱、多功能时钟、温度显示等（原理图、PCB图、设计说明、程序、协议）
09-01
544、基于单片机设计的32x64双色点阵程序、音乐频谱、多功能时钟、温度显示等（原理图、PCB图、设计说明、程序、协议） 音乐频谱--控制卡使用说明： 1、按键S1 亮度控制 说明：一共有10极 按一下亮度加一级 2、按键S2 16分频与64分频切换 3、按键S3 切换柱条和漂浮点颜色 说明：显示颜色有 红柱绿漂 红柱黄漂 绿柱红漂 绿柱黄漂 4、按键S4 无功能 多功能时钟--控制卡使用说明：使用前保证已经下载好对应的功能程序 1、按键S1 时钟复位 2、按键S2 调时模式移位（进行年、月、日、时、分、秒以及补偿时间 、 自动和手动切换显示信息的改变） 3、按键S3 + 4、按键S4 - 自动与手动切换显示的 改变 通过按S2进行菜单调整按到 ，按到点阵屏出现自动或者手动切换界面 ，可以通过S3进行改变手动和自动切换， 如果是自动可以设置自动的时间默认3S。
范围最小查询（RMQ）与最近公共祖先（LCA）详解
"这篇文档详细介绍了RMQ（Range Minimum Query，范围最小值查询）和LCA（Lowest Common Ancestor，最近公共祖先）问题，并探讨了它们之间的相互关系。" 介绍 RMQ问题是一个在数组或序列中寻找给定区间内最小元素的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dai _ tu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值