图Graph

最新推荐文章于 2024-09-11 17:05:32 发布
最新推荐文章于 2024-09-11 17:05:32 发布
阅读量589 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MJ813/article/details/52439974
版权 
#pragma once

#include <assert.h>
#include <queue>
#include "Heap.hpp"
#include "UnionFindSet.hpp"

//
// 临接矩阵表示无向图&有向图
//

template<class V, class W>
class GraphMatrix
{
public:
	GraphMatrix(const V* vertexs, int size, bool isDirected)
		:_vertexSize(size)
		,_isDirected(isDirected)
	{
		// 开辟矩阵和边集
		_matrix = new W*[_vertexSize];
		_vertexs = new V[_vertexSize];

		for (int i = 0; i < _vertexSize; ++i)
		{
			// 初始化矩阵
			_matrix[i] = new W[_vertexSize];
			memset(_matrix[i], 0, sizeof(W)*_vertexSize);

			// 初始化边集
			_vertexs[i] = vertexs[i];
		}
	}

	int GetVertexIndex(const V& vtx)
	{
		for (int i = 0; i < _vertexSize; ++i)
		{
			if (_vertexs[i] == vtx)
			{
				return i;
			}
		}

		return -1;
	}

	void AddEdge(const V& src, const V& dst, const W& weight)
	{
		int srcIndex = GetVertexIndex(src); 
		int dstIndex = GetVertexIndex(dst);

		assert(srcIndex != -1);
		assert(dstIndex != -1);

		if (_isDirected)
		{
			_matrix[srcIndex][dstIndex] = weight;
		}
		else
		{
			_matrix[srcIndex][dstIndex] = weight;
			_matrix[dstIndex][srcIndex] = weight;
		}
	}

	void Display()
	{
		for (int i = 0; i < _vertexSize; ++i)
		{
			cout<<_vertexs[i]<<" ";
		}
		cout<<endl<<endl; 

		for (int i = 0; i < _vertexSize; ++i)
		{
			for (int j = 0; j < _vertexSize; ++j)
			{
				cout<<_matrix[i][j]<<" ";
			}
			cout<<endl;
		}
		cout<<endl;
	}

private:
	W**	 _matrix;		// 临接矩阵
	V*	 _vertexs;		// 顶点集			
	int	 _vertexSize;		// 顶点数
	//int	 _edgeSize;		// 边条数

	bool _isDirected;
};

// 无向图
void Test1()
{
	GraphMatrix<char, int> g("ABCDE", 5, false);
	g.AddEdge('A', 'D', 10);
	g.AddEdge('A', 'E', 20);
	g.AddEdge('B', 'C', 10);
	g.AddEdge('B', 'D', 20);
	g.AddEdge('B', 'E', 30);
	g.AddEdge('C', 'E', 40);

	g.Display();
}

// 有向图
void Test2()
{
	GraphMatrix<char, int> g("ABCDE", 5, true);
	g.AddEdge('A', 'D', 10);
	g.AddEdge('E', 'A', 20);
	g.AddEdge('B', 'C', 10);
	g.AddEdge('D', 'B', 20);
	g.AddEdge('E', 'B', 30);
	g.AddEdge('C', 'E', 40);

	g.Display();
}

//
// 临接表
//

template<class V, class W>
struct LinkEdge
{
	int _srcIndex;			// 源顶点下标
	int _dstIndex;			// 目标顶点下标
	W _weight;				// 权重
	LinkEdge<V, W>* _next;	// 指向下一个节点的指针 

	LinkEdge(int srcIndex = -1, int dstIndex = -1, const W& weight = W())
		:_srcIndex(srcIndex)
		,_dstIndex(dstIndex)
		,_weight(weight)
		,_next(NULL)
	{}
};

template<class V, class W>
struct CompareLinkEdge
{
	bool operator()(LinkEdge<V, W>* lhs, LinkEdge<V, W>* rhs)
	{
		return lhs->_weight < rhs->_weight;
	}
};

template<class V, class W>
class GraphLink
{
protected:
	vector<V> _vertexs;						// 顶点集合
	vector<LinkEdge<V,W>*> _linkTables;		// 临接表
	bool _isDirected;						// 是否是有向图
public:
	GraphLink(bool isDirected = false)
		:_isDirected(isDirected)
	{}

	GraphLink(const V* ar, int size, bool isDirected = false)
		:_isDirected(isDirected)
	{
		_vertexs.resize(size);
		_linkTables.resize(size);
		for (size_t i = 0; i < size; ++i)
		{
			_vertexs[i] = ar[i];
		}
	}

public:
	int GetVertexIndex(const V& vertex)
	{
		for (int i = 0; i < _vertexs.size(); ++i)
		{
			if(_vertexs[i] == vertex)
				return i;
		}

		return -1;
	}

	void _AddEdge(int srcIndex, int dstIndex, const W& weight)
	{
		LinkEdge<V, W>* tmp = new LinkEdge<V, W>(srcIndex, dstIndex, weight);

		tmp->_next = _linkTables[srcIndex];
		_linkTables[srcIndex] = tmp;
	}

	void AddEdge(const V& src, const V& dst, const W& weight)
	{
		int srcIndex = GetVertexIndex(src);
		int dstIndex = GetVertexIndex(dst);

		assert(srcIndex != -1);
		assert(dstIndex != -1);

		// 无向图
		if(_isDirected)
		{
			_AddEdge(srcIndex, dstIndex, weight);
		}
		else
		{
			_AddEdge(srcIndex, dstIndex, weight);
			_AddEdge(dstIndex, srcIndex, weight);
		}
	}

	void Display()
	{
		for (int i = 0; i < _vertexs.size(); ++i)
		{
			cout<<_vertexs[i]<<"["<<i<<"]->";
			LinkEdge<V, W>* begin = _linkTables[0];
			while (begin)
			{
				cout<<begin->_weight<<"["<<begin->_dstIndex<<"]""->";
				begin = begin->_next;
			}

			cout<<"NULL"<<endl;
		}

		cout<<endl;
	}

	// 获取临接表里的下一条边
	LinkEdge<V,W>* _GetNextEdge(int src, int cur)
	{
		LinkEdge<V,W>* edge = _linkTables[src];
		while (edge)
		{
			if (edge->_dstIndex == cur)
			{
				return edge->_next;
			}
			edge = edge->_next;
		}

		return NULL;
	}

	void DFS()
	{
		cout<<"DFS:";

		bool* visited = new bool[_vertexs.size()];
		memset(visited, false, sizeof(bool)*_vertexs.size());

		for (size_t i = 0; i < _vertexs.size(); ++i)
		{
			if (visited[i] == false)
			{
				// 1.访问当前节点
				cout<<_vertexs[i]<<" ";
				visited[i] = true;

				_DFS(i, visited);
			}
		}

		delete[] visited;

		cout<<endl;
	}

	void _DFS(int src, bool* visited)
	{
		// 2.获取当前临接表的第一个顶点
		LinkEdge<V,W>* edge = _linkTables[src];

		// 3.依次获取临接表后面的顶点进行深度优先遍历
		while (edge)
		{
			if (visited[edge->_dstIndex] == false)
			{
				cout<<_vertexs[edge->_dstIndex]<<" ";
				visited[edge->_dstIndex] = true;

				_DFS(edge->_dstIndex, visited);
			}

			edge = edge->_next;
		}
	}

	void BFS()
	{
		cout<<"BFS:";
		bool* visited = new bool[_vertexs.size()];
		memset(visited, false, sizeof(bool)*_vertexs.size());

		for (size_t i = 0; i < _vertexs.size(); ++i)
		{
			if (visited[i] == false)
			{
				_BFS(i, visited);
			}
		}

		delete[] visited;

		cout<<endl;
	}
	
	void _BFS(int cur, bool* visited)
	{
		cout<<_vertexs[cur]<<" ";
		visited[cur] = true;

		queue<int> q;
		q.push(cur);
		while (!q.empty())
		{
			cur = q.front();
			q.pop();

			LinkEdge<V,W>* edge = _linkTables[cur];
			while (edge)
			{
				if (visited[edge->_dstIndex] == false)
				{
					cout<<_vertexs[edge->_dstIndex]<<" ";

					visited[edge->_dstIndex] = true;
					q.push(edge->_dstIndex);
				}

				edge = edge->_next;
			}
		}
	}

	bool Kruskal(GraphLink& minSpanTree)
	{
		// 1.初始化最小生成树
		minSpanTree._vertexs = _vertexs;
		minSpanTree._linkTables.resize(_vertexs.size());
		minSpanTree._isDirected = _isDirected;

		//
		// 2.将所有的边放到一个最小堆
		// 假设有V个顶点，E条边
		// 
		Heap<LinkEdge<V,W>*, CompareLinkEdge<V,W>> minHeap;
		for (int i = 0; i < _vertexs.size(); ++i)
		{
			LinkEdge<V, W>* begin = _linkTables[i];
			while (begin)
			{
				// 无向图的边需要进行过滤
				if (begin->_srcIndex < begin->_dstIndex)
				{
					minHeap.Push(begin);
				}

				begin = begin->_next;
			}
		}
		
		// 3.使用并差集和最小堆构建最小生成树
		UnionFindSet UFSet(_vertexs.size());
		int count = _vertexs.size();
		while (--count)
		{
			if (minHeap.Empty())
			{
				return false;
			}

			LinkEdge<V,W>* edge = minHeap.Top();
			minHeap.Pop();
			int src = UFSet.FindRoot(edge->_srcIndex);
			int dst = UFSet.FindRoot(edge->_dstIndex);

			if(src != dst)
			{
				UFSet.Union(src, dst);
				minSpanTree._AddEdge(edge->_srcIndex, edge->_dstIndex, edge->_weight);
			}
		}

		return true;
	}

	bool Prim(GraphLink& minSpanTree)
	{
		// 1.初始化最小生成树
		minSpanTree._vertexs = _vertexs;
		minSpanTree._linkTables.resize(_vertexs.size());
		minSpanTree._isDirected = _isDirected;

		bool* visitedSet = new bool[_vertexs.size()];
		memset(visitedSet, false, sizeof(bool)*_vertexs.size());

		int src = 0;
		visitedSet[src] = true;
		Heap<LinkEdge<V,W>*, CompareLinkEdge<V,W>> minHeap;

		int count = 1;
		do 
		{
			// 2.取出一个顶点所有未访问过的临接边放到一个最小堆里面
			LinkEdge<V, W>* edge = _linkTables[src];
			while(edge)
			{
				if (visitedSet[edge->_dstIndex] == false)
				{
					minHeap.Push(edge);
				}

				edge = _GetNextEdge(src, edge->_dstIndex);
			}

			// 2.选出堆中最小的边加入生成树
			while(!minHeap.Empty() && count < _vertexs.size())
			{
				edge = minHeap.Top();
				minHeap.Pop();
				if (visitedSet[edge->_dstIndex] == false)
				{
					minSpanTree._AddEdge(edge->_srcIndex, edge->_dstIndex,edge->_weight);
					visitedSet[edge->_dstIndex] = true;
					src = edge->_dstIndex;
					++count;

					break;
				}  
			}
		}while (count < _vertexs.size());

		return true;
	}

	W _GetWeight(int src, int dst, const W& maxValue)
	{
		if (src == dst)
			return maxValue;

		LinkEdge<V,W>* edge = _linkTables[src];
		while (edge)
		{
			if (edge->_dstIndex == dst)
			{
				return edge->_weight;
			}

			edge = edge->_next;
		}

		return maxValue;
	}

	// 非负单源最短路径--Dijkstra(迪科斯彻)
	// 求src到其他顶点的最短路径
	void _Dijkstra(int src, W* dist, int* path, bool* vSet, int size, const W& maxValue)
	{
		//
		// 1.dist初始化src到其他顶点的的距离
		// 2.path初始化src到其他顶点的路径
		// 3.初始化顶点集合
		//
		for (int i = 0; i < size; ++i)
		{
			dist[i] = _GetWeight(src, i, maxValue);
			path[i] = src;
			vSet[i] = false;
		}

		// 将src加入集合
		vSet[src] = true;

		int count = size;
		while(count--)
		{
			//
			// 选出与src顶点连接的边中最小的边
			// src->min
			W min = maxValue;
			int minIndex = src;
			for (int j = 0; j < size; ++j)
			{
				if (vSet[j] == false && dist[j] < min)
				{
					minIndex = j;
					min = dist[j];
				}
			}

			vSet[minIndex] = true;
			for (int k = 0; k < size; ++k)
			{
				if(k == src)
					continue;

				//  
				// 更新src->k的距离
				// 如果dist(src,min)+dist(min, k)的权值小于dist(src, k)
				// 则更新dist(src,k)和path(src->min->k)
				//
				W w = _GetWeight(minIndex, k, maxValue);
				if (vSet[k] == false && dist[minIndex] + w < dist[k])
				{
					dist[k] = dist[minIndex] + w;
					path[k] = minIndex;
				}
			}
		}
	}

	void _Dijkstra_OP(int src, W* dist, int* path,
		bool* vSet, int size, const W& maxValue)
	{
		//
		// 1.dist初始化src到其他顶点的的距离
		// 2.path初始化src到其他顶点的路径
		// 3.初始化顶点集合
		//
		for (int i = 0; i < size; ++i)
		{
			dist[i] = _GetWeight(src, i, maxValue);
			path[i] = src;
			vSet[i] = false;
		}

		struct Compare
		{
			bool operator()(const pair<W, int>& lhs, const pair<W, int>& rhs)
			{
				return lhs.first < rhs.first;
			}
		};

		Heap<pair<W, int>, Compare> minHeap;
		for (int i = 0; i < size; ++i)
		{
			if (dist[i] < maxValue)
			{
				minHeap.Push(make_pair(dist[i], i));
			}
		}

		// 将src加入集合
		vSet[src] = true;

		int count = size;
		while(count--)
		{
			//
			// 选出与src顶点连接的边中最小的边
			// src->min

			if (minHeap.Empty())
				continue;

			int minIndex = minHeap.Top().second;
			minHeap.Pop();

			vSet[minIndex] = true;
			for (int k = 0; k < size; ++k)
			{
				// 
				// 如果dist(src->min)+dist(min, k)的权值小于dist(src, k)
				// 则更新dist(src,k)和path(src->min->k)
				//
				W w = _GetWeight(minIndex, k, maxValue);
				if (vSet[k] == false && dist[minIndex] + w < dist[k])
				{
					dist[k] = dist[minIndex] + w;
					path[k] = minIndex;

					minHeap.Push(make_pair(dist[k], k));
				}
			}
		}
	}

	void PrintPath(int src, W* dist, int* path, int size)
	{
		int* vPath = new int[size];
		for (int i = 0; i < size; ++i)
		{
			if (i != src)
			{
				int index = i, count = 0;
				do{
					vPath[count++] = index;
					index = path[index];
				}while (index != src);

				vPath[count++] = src;

				//cout<<"顶点："<<_linkTable[src]._vertex\
				<<"->顶点："<<_linkTable[i]._vertex<<"的路径为：";
				cout<<src<<","<<i<<"的路径为:";
				while(count)
				{
					//cout<<_linkTable[ vSet[--count] ]._vertex<<"->";
					cout<<vPath[--count]<<"->";
				}

				cout<<"路径长度为："<<dist[i]<<endl;
			}
		}
	}

	void Dijkstra(int src, const W& maxValue)
	{
		W* dist = new W[_vertexs.size()];
		int* path = new int[_vertexs.size()];
		bool* vSet = new bool[_vertexs.size()];

		//_Dijkstra(src, dist, path, vSet, _vertexs.size(), maxValue);
		_Dijkstra_OP(src, dist, path, vSet, _vertexs.size(), maxValue);

		// 打印最短路径
		PrintPath(src, dist, path, _vertexs.size());

		delete[] dist;
		delete[] path;
		delete[] vSet;
	}
};

// 无向图
void Test3()
{
	GraphLink<char, int> g("ABCDE", 5, false);
	g.AddEdge('A', 'D', 10);
	g.AddEdge('A', 'E', 20);
	g.AddEdge('B', 'C', 10);
	g.AddEdge('B', 'D', 20);
	g.AddEdge('B', 'E', 30);
	g.AddEdge('C', 'E', 40);
	g.Display();

	// 生成最小生成树
	GraphLink<char, int> minSpanTree1(false);
	g.Kruskal(minSpanTree1);

	minSpanTree1.Display();

	// 生成最小生成树
	GraphLink<char, int> minSpanTree2(false);
	g.Prim(minSpanTree2);
	minSpanTree2.Display();

	g.DFS();
	g.BFS();
}

// 有向图
void Test4()
{
	GraphLink<char, int> g("ABCDE", 5, true);
	g.AddEdge('A', 'D', 10);
	g.AddEdge('E', 'A', 20);
	g.AddEdge('B', 'C', 10);
	g.AddEdge('D', 'B', 20);
	g.AddEdge('E', 'B', 30);
	g.AddEdge('C', 'E', 40);

	g.AddEdge('A', 'C', 50);
	g.AddEdge('A', 'E', 50);

	g.Display();

	g.Dijkstra(0, 10000);
	//g.Dijkstra(1, 10000);
}

MJ813
关注
专栏目录
graph kernel
10-09
graph classification
About Graph Kernel
u011579808的博客
03-04 1万+
1.转载（有哪些指标可以描述两个图（graph）的相似度？ - 一个安静的胖子的回答 - 知乎https://www.zhihu.com/question/57269332/answer/157375170）Graph kernel实际上 kernel method 在图结构中的研究主要有两类：一是Graph embedding 算法，将图(Graph)结构嵌入到向量空间,得到图结构的向量化表示，...
图核网络-史上最详细解析 Neural Operator: Graph Kernel Network for Partial Differential Equations
最新发布
wwd666666的博客
09-11 1262
详细解析Neural Operator: Graph Kernel Network for Partial Differential Equations
图机器学习——1.3 传统方法：基于图
Kanny
11-07 1862
基于图 我们的目的是将整张图量化为一个特征，这里传统的做法是利用 Graph Kernel 来衡量两个图的相似度。 图中的Kernel我们进行如下的定义： Kernel K(G,G′)∈RK\left(G, G^{\prime}\right) \in \mathbb{R}K(G,G′)∈R 衡量数据之间的相似性。存在一个特征表示 ϕ(⋅)\phi(\cdot)ϕ(⋅) such ，使得 K(G,G′)=ϕ(G)Tϕ(G′)K\left(G, G^{\prime}\right)=\phi(G)^{\mathr
图机器学习课程笔记2
维生素C吃多了会上火
02-25 1526
图机器学习,cs224w,GNN,思维大纲
【数据结构与算法】图(Graph)【详解】
DreamSun的博客
03-25 7597
图(Graph)是由顶点的有穷非空集合V ( G ) 和顶点之间边的集合E ( G )组成，通常表示为: G = ( V , E ) ，其中，G表示个图，V 是图G中顶点的集合，E是图G中边的集合。若V = { v 1 , v 2 , . . . , v n } ，则用∣ V ∣表示图G中顶点的个数，也称图G的阶，E = { ( u , v ) ∣ u ∈ V , v ∈ V } ，用∣ E ∣表示图G中边的条数。注意:线性表可以是空表，树可以是空树，但图不可以是空图。
网络（图 graph）数据集CollegeMsg
02-10
网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图...
西门子GRAPH帮助手册
05-24
西门子 GRAPH 帮助手册 西门子 GRAPH 帮助手册是有关西门子 GRAPH 编程语言的详细指导手册，旨在帮助用户快速掌握 GRAPH 编程语言的基本知识和应用。 GRAPH 编程语言是一种图形化的编程语言，用于创建顺序控制系统...
曲线图Graph类
12-02
功能：绘制曲线图 操作步骤： 1、声明一个CGraph实例 2、调用InitGraph初始化 3、调用SetLegendText设置图例，nIndex范围1-10，本函数在使用索引值 时与SetAxisData对应关系为：1对02对1依次排列,0索引设置图例...
GraphCut进行图像分割
12-14
GraphCut算法通过构建一个加权图来实现这一目标，其中像素被视为图的节点，而边的权重则表示像素之间的相似性或连接强度。 在GraphCut算法中，首先定义前景和背景两类像素，并构建一个图模型。每个像素点作为一个...
西门子顺序功能图Graph V5.3 SP5
12-16
4. **兼容性**：此版本的Graph支持多种西门子PLC系列，如SIMATIC S7，能够无缝集成到TIA Portal（全集成自动化）环境中，与其他编程语言如Ladder Diagram（梯形图）和Structured Text（结构化文本）互为补充。...
GraphKernel:用于评估networkX图中节点之间基于网络传播的相似性度量的软件包
04-27
GraphKernel Python程序包可评估networkX图形中节点之间的几种相似性度量，并根据与源节点子集的相似性对网络节点进行排名。 该软件包经过优化，可利用矢量化的numpy和scipy表达式以获得近乎原生的性能。 它可用于在网络科学问题中快速比较不同的基于网络传播的相似性度量，例如基因优先级和疾病模块检测。 该软件包中的方法受到网络传播框架的启发，该框架在精彩的论文“网络传播：遗传关联的通用放大器”中解释过，Cowen等人。 （2017），Nat Rev遗传学。 注意：术语“内核”在这里非常宽松地用于表示节点之间的相似性/投影矩阵，即使它不遵守基本内核属性（对称性/正定性）时也是如此。 同样，命名图内核不指图之间的相似性内核，而仅指节点之间的相似性内核。 对于评论，问题和错误报告： 请参阅Jupiter笔记本GraphKernel_tutorial.ipynb中的
核方法 graph kernel
12-12
收集了一些数据挖掘中核方法的一些参考资料。是学习核方法（graph kernel）非常好的指导资料。
【图专题】三篇图神经网络中的图核函数：主要学习图的拓扑结构从而解决图分类问题...
fengdu78的博客
05-31 7683
导读：Graph kernel可以直观地理解为测量图相似度的函数。它们允许如支持向量机之类的内核化学习算法直接在图上工作，而不需要进行特征提取即可将其转换为固定长度的实值特征向量。一个简...
graph kernel 与 Wassertein distance
weixin_40239306的博客
10-10 2037
graph kernel 与 Wassertein distanceWasserstein Weisfeiler-Lehman Graph Kernels常用概念解决的问题基本思想 最近读了两篇将 OT 应用于 graph kernel 的论文，有一些收获，在此总结一下。1999年 David Haussler 等人写的论文 Convolution Kernels on Discrete Structures 是介绍核函数的定义以及机器学习中经典核函数的经典论文，可以阅读此文章了解核函数的基础知识。同时，核
数据结构--图(Graph)
qq_66478305的博客
08-14 1563
其中，表示一个图，是图G中顶点的集合，是图G中边的集合。
图核graph kernel方法Python工具包graphkernels的安装和使用
u011452172的博客
11-21 9998
图核graph kernel是一种有效的图结构相似度的近似度量方式，针对不同的图结构(labeled graphs, weighted graphs, directed graphs, etc.) 有不同的Graph kernel。 这里，我们不介绍graph kernel的算法理论，只是简单介绍下其Python工具包graphkernels的安装和使用。 graphkerne
数据结构与算法（python）：图(Graph)的基本概念及应用
热门推荐
番茄大人的博客
01-05 1万+
参考自 MOOC数据结构与算法Python版 目录一、图Graph的概念1.1 互联网1.2 社交网络：六度分隔理论二、术语表三、图抽象数据类型：ADT Graph3.1 定义3.2 ADT Graph的实现方法3.2.1 邻接矩阵Adjacency Matrix3.2.2 邻接列表Adjacency List四、ADT Graph的实现：实例4.1 Vertex类4.2 Graph 类五、图的应用5.1 词梯问题5.1.1 构建单词关系图5.1.2 采用字典建立桶 一、图Graph的概念 图Graph是
TigerGraph图数据库操作指南
"TigerGraph图数据库应用文档涵盖了TigerGraph的基本操作，如顶点（Vertex）、边（Edge）和图（Graph）的创建与管理，还包括累加器、函数、GraphStudio的使用以及图算法的应用等内容。" 在图数据库领域，TigerGraph...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值