强连通分量Tarjan算法

最新推荐文章于 2022-05-18 19:18:44 发布
最新推荐文章于 2022-05-18 19:18:44 发布
阅读量128 收藏
点赞数
分类专栏： 算法导论(图论)C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349225/article/details/104861029
版权

参考大佬的分析：
全网最!详!细!Tarjan算法讲解 https://blog.csdn.net/hurmishine/article/details/75248876
代码实现（代码里有详细的注释！）
结构定义

const int MaxV = 100;
/*定义栈*/
typedef struct SNode{
	string *Data;	//栈数据类型
	int Top;		//栈顶位置
	int MaxSize;	//栈容量
} * Stack;

/*需要的辅助数组*/
typedef struct ANode
{
	Stack S;
	//bool *Vis; //标记数组，标记顶点是否访问, 或表示(目前)栈中有没有该元素, 这里不用这个Vis
	int *LOW;  //追溯值，根据DFS树判断，向回追溯的最小时间戳(DFS)
	int *DFN;  //时间戳，访问顶点的顺序
	int Index;
	int Nv;	//树顶点数为NV
} * AssArrary; //辅助数组集合

/*定义边*/
typedef struct ENode{
	int v1, v2;
	string va, vb;
	//int Weight;
} * Edge;

/*定义邻接点*/
struct AdjVNode{
	int AdjV;
	//int Weight;
	AdjVNode *Next;
};

/*定义邻接表头*/
typedef struct VNode{
	string Data;
	AdjVNode *EdgeFirst;
} AdjList[MaxV];

/*定义图*/
typedef struct GNode{
	int Nv, Ne;
	AdjList L;
} * LGraph;

栈的操作

/*入栈*/
void Push(Stack S, string x)
{
	if(S->Top + 1 == S->MaxSize)//栈满，入栈失败
		return;
	else
		S->Data[++S->Top] = x;
}

/*出栈*/
string Pop(Stack S)
{
	if(S->Top < 0)
		return "error";
	else
		return S->Data[S->Top--];
}

/*返回x在栈S中的位置，若不在返回-1*/
int FindS(Stack S, string x)	//查找
{
	int i;
	for (i = S->Top; i >= 0; i--)
		if (S->Data[i] == x)
			break;
	return i;
}

/*由边的字符串信息得到对应的数字编号*/
void EdgeCode(Edge E, Stack S)
{
	int t = FindS(S, E->va);
	if (t != -1)	//如果能在栈中找到
		E->v1 = t;
	else
	{
		Push(S, E->va);
		E->v1 = S->Top;
	}

	t = FindS(S, E->vb);	//另一顶点同样的操作
	if (t != -1)
		E->v2 = t;
	else
	{
		Push(S, E->vb);
		E->v2 = S->Top;
	}
}

图的操作

/*图的初始化*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode();
	G->Nv = Nv;
	return G;
}

/*在图中插入边*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}

/*输入有向图的信息*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Stack S = CreateStack(G->Nv);
	Edge E = new ENode;
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		EdgeCode(E, S);
		InsertEdge(G, E);
		G->L[E->v1].Data = E->va;
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}

/*遍历输出图的邻接表图的物理结构*/
void ShowGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		V = G->L[i].EdgeFirst;
		cout << G->L[i].Data << "->";
		while (V)
		{
			cout << G->L[V->AdjV].Data << "->";
			V = V->Next;
		}
		cout << "NULL" << endl;
	}
}

/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	}
	delete G;
}

辅助数组的初始化与删除

/*初始化需要用到的辅助数组*/
AssArrary CreateAss(int Nv)
{
	AssArrary A = new ANode;
	A->Nv = Nv; A->Index = 0;
	A->DFN = new int[Nv]();
	A->LOW = new int[Nv]();
	//A->Vis = new bool[Nv]();
	A->S = CreateStack(Nv);
	return A;
}

/*删除辅助数组*/
void DeleteAss(AssArrary A)
{
	//delete[] A->Vis;
	delete[] A->LOW;
	delete[] A->DFN;
	delete[] A->S->Data;
	delete A->S;
}

Tarjan算法，核心代码

/*Tarjan算法，核心代码*/
void Tarjan(LGraph G, int u, AssArrary A)
{
	A->DFN[u] = A->LOW[u] = ++A->Index;
	//A->Vis[u] = true;	//Vis[]表示的是是否在栈中，而不是是否访问!!!
	Push(A->S, G->L[u].Data);
	AdjVNode *V = G->L[u].EdgeFirst;
	while (V)
	{
		if(!A->DFN[V->AdjV])	//如果v点没有被访问过, DFN是时间戳，没访问过就全是0
		{
			Tarjan(G, V->AdjV, A);
			//当上面访问结束后，（重新回溯到u顶点时）
			A->LOW[u] = min(A->LOW[u], A->LOW[V->AdjV]);	//因为有向边<u, v>联系，若v以下没有回路，LOW[v]一定是小于LOW[u]的
		}													//就是该条语句只在找到回路是才发生
				//FinsS()为线性查找函数
		else if (FindS(A->S, G->L[V->AdjV].Data) >= 0)		//访问过，但栈中!! 这是就有回路了 (即DFS树上的反祖边出现了)
			A->LOW[u] = min(A->LOW[u], A->DFN[V->AdjV]); //有回路就更新u顶点的LOW，新找到的被访问过得顶点的DFN一定小于当前顶点u的DFN!!!
		V = V->Next;
	}
	if(A->LOW[u] == A->DFN[u])	//由DFS树的特点，当前DFN=LOW说明形成了一个回路(因为顶点u经过上面的变化，两部LOW减少语句都没有成功)
	{							//上面可能变化LOW两句可知，都在有环路时才发生变化; 下面输出u及u以后的点
		do
		{
			//A->Vis[A->S->Top] = false;	//表示已经出栈, 这里由于顶点编号是字符串，不用该Vis表示是否在栈中
			cout << Pop(A->S) << " ";
		} while (A->S->Data[A->S->Top + 1] != G->L[u].Data);	//如果刚才输出的是顶点u的字符, 则退出循环
		cout << endl;
	}
}

int main()
{
	LGraph G = BuildGraph();
	AssArrary A = CreateAss(G->Nv);
	cout << "图的邻接表物理结构为:" << endl;
	ShowGraph(G);
	cout << "有下面几个强连通分量:" << endl;
	for (int i = 0; i < G->Nv; i++)
		if(!A->DFN[i])
			Tarjan(G, i, A);

	DeleteAss(A);

	system("pause");
	return 0;
}

输入样例
在这里插入图片描述

input:
13 22
0 1
0 5
2 0
2 3
3 2
3 5
4 2
4 3
5 4
6 0
6 4
6 9
7 6
7 8
8 7
8 9
9 10
9 11
10 12
11 4
11 12
12 9

output:
图的邻接表物理结构为:
0->5->1->NULL
1->NULL
5->4->NULL
2->3->0->NULL
3->5->2->NULL
4->3->2->NULL
6->9->4->0->NULL
9->11->10->NULL
7->8->6->NULL
8->9->7->NULL
10->12->NULL
11->12->4->NULL
12->9->NULL
有下面几个强连通分量:
1
2 3 4 5 0
10 12 11 9
6
8 7
请按任意键继续. . .

完整代码

#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
const int MaxV = 100;

/*定义栈*/
typedef struct SNode{
	string *Data;	//栈数据类型
	int Top;		//栈顶位置
	int MaxSize;	//栈容量
} * Stack;

/*需要的辅助数组*/
typedef struct ANode
{
	Stack S;
	//bool *Vis; //标记数组，标记顶点是否访问, 或表示(目前)栈中有没有该元素, 这里不用这个Vis
	int *LOW;  //追溯值，根据DFS树判断，向回追溯的最小时间戳(DFS)
	int *DFN;  //时间戳，访问顶点的顺序
	int Index;
	int Nv;	//树顶点数为NV
} * AssArrary; //辅助数组集合

/*定义边*/
typedef struct ENode{
	int v1, v2;
	string va, vb;
	//int Weight;
} * Edge;

/*定义邻接点*/
struct AdjVNode{
	int AdjV;
	//int Weight;
	AdjVNode *Next;
};

/*定义邻接表头*/
typedef struct VNode{
	string Data;
	AdjVNode *EdgeFirst;
} AdjList[MaxV];

/*定义图*/
typedef struct GNode{
	int Nv, Ne;
	AdjList L;
} * LGraph;

/*栈的初始化*/
Stack CreateStack(int MaxSize)
{
	Stack S = new SNode;
	S->Data = new string[MaxSize];
	S->Top = -1;
	S->MaxSize = MaxSize;
	return S;
}

/*入栈*/
void Push(Stack S, string x)
{
	if(S->Top + 1 == S->MaxSize)//栈满，入栈失败
		return;
	else
		S->Data[++S->Top] = x;
}

/*出栈*/
string Pop(Stack S)
{
	if(S->Top < 0)
		return "error";
	else
		return S->Data[S->Top--];
}

/*返回x在栈S中的位置，若不在返回-1*/
int FindS(Stack S, string x)	//查找
{
	int i;
	for (i = S->Top; i >= 0; i--)
		if (S->Data[i] == x)
			break;
	return i;
}

/*由边的字符串信息得到对应的数字编号*/
void EdgeCode(Edge E, Stack S)
{
	int t = FindS(S, E->va);
	if (t != -1) //如果能在栈中找到
		E->v1 = t;
	else
	{
		Push(S, E->va);
		E->v1 = S->Top;
	}

	t = FindS(S, E->vb); //另一顶点同样的操作
	if (t != -1)
		E->v2 = t;
	else
	{
		Push(S, E->vb);
		E->v2 = S->Top;
	}
}

/*图的初始化*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode();
	G->Nv = Nv;
	return G;
}

/*在图中插入边*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}

/*输入有向图的信息*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Stack S = CreateStack(G->Nv);
	Edge E = new ENode;
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		EdgeCode(E, S);
		InsertEdge(G, E);
		G->L[E->v1].Data = E->va;
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}

/*遍历输出图的邻接表图的物理结构*/
void ShowGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		V = G->L[i].EdgeFirst;
		cout << G->L[i].Data << "->";
		while (V)
		{
			cout << G->L[V->AdjV].Data << "->";
			V = V->Next;
		}
		cout << "NULL" << endl;
	}
}

/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	}
	delete G;
}

/*初始化需要用到的辅助数组*/
AssArrary CreateAss(int Nv)
{
	AssArrary A = new ANode;
	A->Nv = Nv; A->Index = 0;
	A->DFN = new int[Nv]();
	A->LOW = new int[Nv]();
	//A->Vis = new bool[Nv]();
	A->S = CreateStack(Nv);
	return A;
}

/*删除辅助数组*/
void DeleteAss(AssArrary A)
{
	//delete[] A->Vis;
	delete[] A->LOW;
	delete[] A->DFN;
	delete[] A->S->Data;
	delete A->S;
}

/*Tarjan算法，核心代码*/
void Tarjan(LGraph G, int u, AssArrary A)
{
	A->DFN[u] = A->LOW[u] = ++A->Index;
	//A->Vis[u] = true;	//Vis[]表示的是是否在栈中，而不是是否访问!!!
	Push(A->S, G->L[u].Data);
	AdjVNode *V = G->L[u].EdgeFirst;
	while (V)
	{
		if(!A->DFN[V->AdjV])	//如果v点没有被访问过, DFN是时间戳，没访问过就全是0
		{
			Tarjan(G, V->AdjV, A);
			//当上面访问结束后，（重新回溯到u顶点时）
			A->LOW[u] = min(A->LOW[u], A->LOW[V->AdjV]);	//因为有向边<u, v>联系，若v以下没有回路，LOW[v]一定是小于LOW[u]的
		}													//就是该条语句只在找到回路是才发生
				//FinsS()为线性查找函数
		else if (FindS(A->S, G->L[V->AdjV].Data) >= 0)		//访问过，但栈中!! 这是就有回路了 (即DFS树上的反祖边出现了)
			A->LOW[u] = min(A->LOW[u], A->DFN[V->AdjV]); //有回路就更新u顶点的LOW，新找到的被访问过得顶点的DFN一定小于当前顶点u的DFN!!!
		V = V->Next;
	}
	if(A->LOW[u] == A->DFN[u])	//由DFS树的特点，当前DFN=LOW说明形成了一个回路(因为顶点u经过上面的变化，两部LOW减少语句都没有成功)
	{							//上面可能变化LOW两句可知，都在有环路时才发生变化; 下面输出u及u以后的点
		do
		{
			//A->Vis[A->S->Top] = false;	//表示已经出栈, 这里由于顶点编号是字符串，不用该Vis表示是否在栈中
			cout << Pop(A->S) << " ";
		} while (A->S->Data[A->S->Top + 1] != G->L[u].Data);	//如果刚才输出的是顶点u的字符, 则退出循环
		cout << endl;
	}
}

int main()
{
	LGraph G = BuildGraph();
	AssArrary A = CreateAss(G->Nv);
	cout << "图的邻接表物理结构为:" << endl;
	ShowGraph(G);
	cout << "有下面几个强连通分量:" << endl;
	for (int i = 0; i < G->Nv; i++)
		if(!A->DFN[i])
			Tarjan(G, i, A);

	DeleteAss(A);

	system("pause");
	return 0;
}
不导翁
关注
专栏目录
tarjan求强连通分量
Link_Ray的博客
11-23 495
强连通分量定义 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。 tarjan求强连通分量 定义以下几个变量 dfn: 时间变量，代表给结点第几个被访问。 Dfn[u]: 结...
强连通分量 Tarjan 算法入门笔记
lkb 的小屋
04-27 338
强连通分量在图论问题中得到广泛的应用，往往可以将有向图缩点，得到一个 DAG，于是避免了原图中可能有环造成后效性，可以在上面进行动态规划求解。 显然强连通分量是只针对于有向图而言的。对于一个连通的无向图，它本身就是一个连通分量。
Tarjan求有向图的强连通分量（Tarjan算法描述）
Bright
07-12 4931
强连通分量是有向图中的概念，我们先说强连通分量的定义吧：在一个图的子图中，任意两个点相互可达，也就是存在互通的路径，那么这个子图就是强连通分量（或者称为强连通分支）。如果一个有向图的任意两个点相互可达，那么这个图就称为强连通图。        我们常用的求强连通分量的算法有两个，
强连通分量Tarjan
REfusing的博客
04-29 163
参考博客：浅析强连通分量（Tarjan和kosaraju） Tarjan·关于图的连通性 & 连通分量 题目：1332 上白泽慧音 代码： #include<bits/stdc++.h> using namespace std; const int maxn = 5010; const int N = 50010; stack&lt...
强连通分量——tarjan
ecjtu_17_TY的博客
09-13 518
学自：https://blog.csdn.net/qq_34374664/article/details/77488976 强连通：在一个有向图里面，如果有两个点a和b满足a和b之间互通，则称（a，b）强连通 强连通图：一幅图中所有点之间都满足强连通，则可以称这是一幅强连通图，（无向图必是强连通图） 强连通分量：强连通图的一幅子图如果满足子图的所有点之间都是强连通，则称这幅子图为这幅强连通图...
tarjan强连通分量
weixin_50522312的博客
04-11 138
文章目录tarjan强连通分量 tarjan强连通分量 连通：无向图中，任意点i可以到任意点j 强连通：有向图中，任意点i可以到任意点j
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
求有向图的强连通分量(scc)Tarjan算法.docx
05-06
"有向图的强连通分量（scc）Tarjan算法" Tarjan算法是基于深度优先搜索的算法，用于求解有向图的强连通分量（scc）。强连通分量是指图中每两个顶点之间至少存在一条路径的子图。Tarjan算法的主要思想是通过深度...
poj1236 有线图的强连通分量 tarjan算法判断
liyanfeng1996的博客
02-17 418
poj1236 有线图的强连通分量 tarjan算法判断/* /* 总结：这道题开始做的时候思路是正确的，但是我是把它当成无线图处理了 但是这道题是有向图，有向图的连通判断是tarjan算法和kosaraju算法判断几个强连通分量 无向图就是判断判断是否连通，一般有两种方法判断无向图 1；并查集 2；搜索，bfs,dfs； 这道题判断强连通分量，然后是缩点，将一个强连通分量变成一个点，那么就变
20行代码实现，使用Tarjan算法求解强连通分量
TechFlow的博客
09-23 324
今天是算法数据结构专题的第36篇文章，我们一起来继续聊聊强连通分量分解的算法。 在上一篇文章当中我们分享了强连通分量分解的一个经典算法Kosaraju算法，它的核心原理是通过将图翻转，以及两次递归来实现。今天介绍的算法名叫Tarjan，同样是一个很奇怪的名字，奇怪就对了，这也是以人名命名的。和Kosaraju算法比起来，它除了名字更好记之外，另外一个优点是它只需要一次递归，虽然算法的复杂度是一样的，但是常数要小一些。它的知名度也更高，在竞赛当中经常出现。 先给大家提个醒，相比于Kosaraju算法，Tarj
强连通分量的Tarjan算法
weixin_45552088的博客
10-13 232
有向图的强连通分量（SCC）算法 强联通分量定义 给定有向图G(V,E)G(V,E)G(V,E)； 若u,v∈Vu,v\in Vu,v∈V,我们定义函数J[u][v]J[u][v]J[u][v],若uuu可以到达vvv，则有J[u][v]=1J[u][v]=1J[u][v]=1，否则J[u][v]=0J[u][v]=0J[u][v]=0； 对于非空点集Ci⊂VC_i\subset VCi​⊂V,且∀u,v∈Ci,J[u][v]=J[v][u]=1\forall u,v\in C_i,J[u][v]=J[v]
强联通分量——tarjan算法
luogu_bling的博客
10-15 617
tarjan算法求强连通分量数量 一、概念： 1、强连通： 在一个有向图G里，设两个点a b发现，由a有一条路可以走到b，由b又有一条路可以走到a，我们就叫这两个顶点（a，b）强连通。 2、强连通图： 如果在一个有向图G中，每两个点都强连通，我们就叫这个图为强连通图。 3、强连通分量： 在一个有向图G中，有一个子图，这个子图每2个点都满足强连通，我们就叫这个子图叫做强连通分量 举个栗子： 在上图...
ACM教程 - 强连通分量（Tarjan）
牧码的博客
10-28 1127
一、讲解一 强连通定义：在有向图G&lt;V,E&gt;中，对于点集V'∈V, 点集中的任意两点都可达，则称V'为强连通。 孤立的一个点也是一个强连通分量。 在嵌套的多个环时 : {所有环上的点}为一个强连通分量( 最小环就是每个孤立点）注意一定是满足条件的最大点集。 则上图中强连通分量有 {1}，{2}，{3}，{7}，{4,5,6}。 tarjan的过程就是dfs过程： 对图......
图论——强连通分量（Tarjan算法)
热门推荐
上总介的博客
03-10 3万+
一周前写的Tarjan代码遗失了QAQ，趁还没忘，赶紧记录一下。
Tarjan三大算法之强连通分量
fuyukai的专栏
05-07 1863
简介： 在之前的两篇博客中，我们详细介绍了Tarjan大牛发明的用来求解割点、桥和双连通分量的算法，这次我们介绍一下强连通分量。算法： 这次的Tarjan算法，可以用一次DFS把所有强连通分量找出来，依旧是用两个时间戳和栈来实现。算法的大体思路还是在深搜过程中更新时间戳，并将遍历过的结点保存在栈中，之后通过对时间戳的判断，来发现强连通分量。当我们完成对一个结点u以及其子孙的访问后，我们可以进行一
有向图的强连通分量的tarjan算法
08-27 434
此篇文章的整理仅用于学习记录，供日后复习，大部分内容来源于北大郭炜老师整理的课件。 有关tarjan算法的一个结论：求几个点的LCA等价于求dfn[]最小的节点和dfn[]最大的这两个节点的LCA. 1.POJ2186:Popular Cows 题意：给定一个有向图，求有多少顶点是由任何顶点出发都可达的。 有用的定理：有向无环图中唯一出度为0的点，一定可以有任何点出发均可达（由于无环，所以...
强连通分量——tarjan算法缩点
c__chong的博客
05-18 1409
一. 什么是强连通分量？ 强连通分量：在有向图G中，如果两个顶点u,v间（u->v）有一条从vi到vj的有向路径，同时还有一条从u到v的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。 简单点说就是：如果一个有向图中，存在一条回路，所有的结点至少被经过一次，这样的图为强连通图。 在强连图图的基础上加入一些点和路径，使得当前的图不在强连通，称原来的强连通的部分为强连通分量。 二. 强连通分
Tarjan算法-求强连通分量入门
keepcoral的博客
06-27 1043
Tarjan算法求强连通分量，强连通分量就是有向图(可以是子图)中的任意两点都能互相到达，所以我们可以用Tarjan算法去求出所有的强连通分量，相当于缩点，然后把这些缩点连接起来，就是DAG(有向无环图)，DAG一定有一个点是出度为0的，可以尝试画画图。#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt...
Tarjan算法详解：强连通分量与深度优先搜索
"Tarjan算法是一种用于图的联通性分析的高效算法，主要应用于有向图，用于查找强连通分量。该算法基于深度优先搜索（DFS）策略，通过特殊的标记和时间戳机制来识别和分离强连通组件。算法的核心在于两个关键参数：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值