C++数据结构——图

最新推荐文章于 2024-07-25 10:53:48 发布
最新推荐文章于 2024-07-25 10:53:48 发布
阅读量753 收藏 8
点赞数 3
分类专栏： 数据结构 文章标签： dijikstra算法 邻接矩阵 邻接表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43768323/article/details/84339037
版权

邻接表结构

class sideNode
{
public:
	int weight;
	int datapostion;
	sideNode *next;

};
class pointNode
{
public:
	char data;
	sideNode *head;
};
class map
{
private:
	pointNode pointsArry[max];
	int visited[max];
	int numb;

建立邻接表

map()//初始化
	{
		for (int i = 0; i < max; i++)
		{
			pointsArry[i].data = ' ';
			pointsArry[i].head = NULL;
			visited[i] = 0;
		}
		numb = 0;
	}

	void setPoint()//单独设置点（不带参）
	{
		char t;
		for (int i = 0;;)
		{
			cin >> t;
			if (t == '#')return;
			pointsArry[i].data=t;
			numb++;
			i++;
		}
	}
	void setPoint(char n)//单独设置点（带参数）
	{
		for (int i = 0; i < max; i++)
		{
			if (n == pointsArry[i].data)
				return;
		}
		for (int i = 0;;)
		{
			if (pointsArry[i].data == ' ')
			{
				pointsArry[i].data = n;
				numb++;
				return;
			}
			i++;
		}
	}
	void setSide()//单独设置边
	{
		int w;
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			cin >> w;
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = w;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}

	int postion(char m)//返回m在点数组中的位置
	{
		for (int i = 0;; i++)
		{
			if (m == pointsArry[i].data)
				return i;
		}
	}
	void setMapWithWeight()//单向带权重
	{
		int w;
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			setPoint(p1);
			setPoint(p2);
			cin >> w;
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = w;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}
	void setMapWithoutWeight()//单向权重默认为1
	{
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			setPoint(p1);
			setPoint(p2);
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = 1;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}

生成邻接矩阵

vector<vector<int> >aM()//返回邻接矩阵
	{
		sideNode *u;
		vector<vector<int> >aM(numb, vector<int>(numb));	//邻接矩阵
		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				aM[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)//向邻接矩阵中添加通路（不带权）
		{
			
			u = pointsArry[i].head;
			while (u != NULL)
			{
				aM[i][u->datapostion]++;
				u = u->next;
			}
		}
		return aM;
	}

计算可达性矩阵

vector<vector<int> >B(int m)//返回度数为m的通路矩阵
	{
		vector<vector<int> >b(numb, vector<int>(numb));		//各度数的通路矩阵
		vector<vector<int> >T(numb, vector<int>(numb));

		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = 0;
				T[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = aM()[i][j];//此时b为度数为1的通路矩阵
			}
		}
		for (int x = 0; x < m; x++)//循环一次度数加1  ；p=aM^1+aM^2+aM^3+……+aM^(numb-1)
		{
			for (int i = 0; i < numb; i++)//矩阵乘法
			{
				int t, s = 0;
				for (int j = 0; j < numb; j++)
				{
					for (int k = 0; k < numb; k++)
					{
						t = b[i][k] * aM()[k][j];
						s = s + t;
					}
					if (s != 0)s = 1;
					T[i][j] = s;
					s = 0;
				}
			}
			for (int i = 0; i < numb; i++)
			{
				for (int j = 0; j < numb; j++)
				{
					b[i][j] = T[i][j];
				}
			}
		}
		return b;
	}
	vector<vector<int>> P()//返回可达性矩阵
	{
		
		vector<vector<int> >p(numb, vector<int>(numb));		//可达性矩阵
		vector<vector<int> >b(numb, vector<int>(numb));		//各度数的通路矩阵
		vector<vector<int> >T(numb, vector<int>(numb));		

		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				p[i][j] = 0;
				b[i][j] = 0;
				T[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = aM()[i][j];//此时b为度数为1的通路矩阵
				p[i][j] = aM()[i][j];
			}
		}
		for (int x=0;x<numb-1;x++)//计算可达性矩阵p；循环一次度数加1  ；p=aM^1+aM^2+aM^3+……+aM^(numb-1)
		{
			for (int i = 0; i < numb; i++)//矩阵乘法
			{
				int t, s = 0;
				for (int j = 0; j < numb; j++)
				{
					for (int k = 0; k < numb; k++)
					{
						t = b[i][k] * aM()[k][j];
						s = s + t;
					}
					if(s!=0)s=1;
					T[i][j] = s;
					s = 0;
				}
			}
			for (int i = 0; i < numb; i++)
			{
				for (int j = 0; j < numb; j++)
				{
					b[i][j] = T[i][j];
				}
			}
			for (int i = 0; i < numb; i++)//相加
			{
				for (int j = 0; j < numb; j++)
				{
					p[i][j] = p[i][j] + b[i][j];
					if (p[i][j] != 0)
					{
						p[i][j] = 1;
					}
				}
			}
		}
		return p;
	}

实现dijkstra算法

int min(int a, int b)
	{
		if (a > b)
			return b;
		else
			return a;
	}
	sideNode* minl(sideNode *p)//返回长度最短的边
	{
		int min;
		sideNode *b = NULL;
		b = p;
		min = p->weight;
		while (p != NULL)
		{
			if (p->weight < min)
			{
				min = p->weight;
				b = p;
			}
			p = p->next;
		}
		return b;
	}
	int minm(int *a)//返回到原点路径长最短的点在数组中的位置
	{
		int min = UN;
		int t = 0;
		for (int i = 0; i < numb; i++)
		{
			if (a[i] < min&&visited[i] != 1)
			{
				min = a[i];
				t = i;
			}

		}
		return t;
	}
	void dij(char t)
	{
		sideNode *temp1, *temp2, *temp3;
		temp1 = pointsArry[postion(t)].head;
		temp2 = pointsArry[minl(temp1)->datapostion].head;
		temp3 = temp2;
		int *m = new int[numb];//最短路径长数组
		int l = minl(pointsArry[postion(t)].head)->weight;//l初始值为距离原点最近的点到原点的路径长
		for (int i = 0; i < numb; i++)//初始化最短路径长数组设2048为不可达
		{
			m[i] = UN;
		}
		m[postion(t)] = 0;//t点到自身长度为0
		visited[postion(t)] = 1;//t点到自身最短路径已知
		while (temp1 != NULL)
		{
			m[temp1->datapostion] = temp1->weight;//更新最短长度数组
			temp1 = temp1->next;
		}
		visited[minl(pointsArry[postion(t)].head)->datapostion] = 1;//标记此端点已得到最短路径长
		for (;;)
		{
			int s = 0;
			for (int i = 0; i < numb; i++)
			{
				s = s + visited[i];
			}
			if (s == numb)break;//全部标记为最短后结束循环
			while (temp3 != NULL)
			{
				m[temp3->datapostion] = min(m[temp3->datapostion], l + temp3->weight);//更新最短路径长数组，
				temp3 = temp3->next;
			}
			l = m[minm(m)];//取到原点路径长最短的
			int y = minm(m);//记此端点在端点数组的位置
			visited[minm(m)] = 1;//标记此端点已得到最短路径长
			temp2 = pointsArry[y].head;//以该端点为起点再次查找
			temp3 = temp2;
		}
		cout << "该点到各点路径长为" << endl;
		for (int i = 0; i < numb; i++)
		{
			cout << pointsArry[i].data << " " << m[i] << endl;
		}
	}

完整代码

#include "pch.h"
#include <iostream>
#include<vector>
#define max 30
#define UN 1024
using namespace std;
class sideNode
{
public:
	int weight;
	int datapostion;
	sideNode *next;

};
class pointNode
{
public:
	char data;
	sideNode *head;
};
class map
{
private:
	pointNode pointsArry[max];
	int visited[max];
	int numb;
public:
	map()//初始化
	{
		for (int i = 0; i < max; i++)
		{
			pointsArry[i].data = ' ';
			pointsArry[i].head = NULL;
			visited[i] = 0;
		}
		numb = 0;
	}

	void setPoint()//单独设置点（不带参）
	{
		char t;
		for (int i = 0;;)
		{
			cin >> t;
			if (t == '#')return;
			pointsArry[i].data=t;
			numb++;
			i++;
		}
	}
	void setPoint(char n)//单独设置点（带参数）
	{
		for (int i = 0; i < max; i++)
		{
			if (n == pointsArry[i].data)
				return;
		}
		for (int i = 0;;)
		{
			if (pointsArry[i].data == ' ')
			{
				pointsArry[i].data = n;
				numb++;
				return;
			}
			i++;
		}
	}
	void setSide()//单独设置边
	{
		int w;
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			cin >> w;
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = w;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}

	int postion(char m)//返回m在点数组中的位置
	{
		for (int i = 0;; i++)
		{
			if (m == pointsArry[i].data)
				return i;
		}
	}
	void setMapWithWeight()//单向带权重
	{
		int w;
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			setPoint(p1);
			setPoint(p2);
			cin >> w;
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = w;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}
	void setMapWithoutWeight()//单向权重默认为1
	{
		char p1, p2;
		sideNode *p;
		for (;;)
		{
			cin >> p1;
			if (p1 == '#')return;
			cin >> p2;
			setPoint(p1);
			setPoint(p2);
			p = new sideNode;
			p->datapostion = postion(p2);
			p->weight = 1;
			p->next = pointsArry[postion(p1)].head;
			pointsArry[postion(p1)].head = p;
		}
	}
	int min(int a, int b)
	{
		if (a > b)
			return b;
		else
			return a;
	}
	sideNode* minl(sideNode *p)//返回长度最短的边
	{
		int min;
		sideNode *b = NULL;
		b = p;
		min = p->weight;
		while (p != NULL)
		{
			if (p->weight < min)
			{
				min = p->weight;
				b = p;
			}
			p = p->next;
		}
		return b;
	}
	int minm(int *a)//返回到原点路径长最短的点在数组中的位置
	{
		int min = UN;
		int t = 0;
		for (int i = 0; i < numb; i++)
		{
			if (a[i] < min&&visited[i] != 1)
			{
				min = a[i];
				t = i;
			}

		}
		return t;
	}
	void dij(char t)
	{
		sideNode *temp1, *temp2, *temp3;
		temp1 = pointsArry[postion(t)].head;
		temp2 = pointsArry[minl(temp1)->datapostion].head;
		temp3 = temp2;
		int *m = new int[numb];//最短路径长数组
		int l = minl(pointsArry[postion(t)].head)->weight;//l初始值为距离原点最近的点到原点的路径长
		for (int i = 0; i < numb; i++)//初始化最短路径长数组设2048为不可达
		{
			m[i] = UN;
		}
		m[postion(t)] = 0;//t点到自身长度为0
		visited[postion(t)] = 1;//t点到自身最短路径已知
		while (temp1 != NULL)
		{
			m[temp1->datapostion] = temp1->weight;//更新最短长度数组
			temp1 = temp1->next;
		}
		visited[minl(pointsArry[postion(t)].head)->datapostion] = 1;//标记此端点已得到最短路径长
		for (;;)
		{
			int s = 0;
			for (int i = 0; i < numb; i++)
			{
				s = s + visited[i];
			}
			if (s == numb)break;//全部标记为最短后结束循环
			while (temp3 != NULL)
			{
				m[temp3->datapostion] = min(m[temp3->datapostion], l + temp3->weight);//更新最短路径长数组，
				temp3 = temp3->next;
			}
			l = m[minm(m)];//取到原点路径长最短的
			int y = minm(m);//记此端点在端点数组的位置
			visited[minm(m)] = 1;//标记此端点已得到最短路径长
			temp2 = pointsArry[y].head;//以该端点为起点再次查找
			temp3 = temp2;
		}
		cout << "该点到各点路径长为" << endl;
		for (int i = 0; i < numb; i++)
		{
			cout << pointsArry[i].data << " " << m[i] << endl;
		}
	}
	vector<vector<int> >aM()//返回邻接矩阵
	{
		sideNode *u;
		vector<vector<int> >aM(numb, vector<int>(numb));	//邻接矩阵
		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				aM[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)//向邻接矩阵中添加通路（不带权）
		{
			
			u = pointsArry[i].head;
			while (u != NULL)
			{
				aM[i][u->datapostion]++;
				u = u->next;
			}
		}
		return aM;
	}
	vector<vector<int> >B(int m)//返回度数为m的通路矩阵
	{
		vector<vector<int> >b(numb, vector<int>(numb));		//各度数的通路矩阵
		vector<vector<int> >T(numb, vector<int>(numb));

		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = 0;
				T[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = aM()[i][j];//此时b为度数为1的通路矩阵
			}
		}
		for (int x = 0; x < m; x++)//循环一次度数加1  ；p=aM^1+aM^2+aM^3+……+aM^(numb-1)
		{
			for (int i = 0; i < numb; i++)//矩阵乘法
			{
				int t, s = 0;
				for (int j = 0; j < numb; j++)
				{
					for (int k = 0; k < numb; k++)
					{
						t = b[i][k] * aM()[k][j];
						s = s + t;
					}
					if (s != 0)s = 1;
					T[i][j] = s;
					s = 0;
				}
			}
			for (int i = 0; i < numb; i++)
			{
				for (int j = 0; j < numb; j++)
				{
					b[i][j] = T[i][j];
				}
			}
		}
		return b;
	}
	vector<vector<int>> P()//返回可达性矩阵
	{
		
		vector<vector<int> >p(numb, vector<int>(numb));		//可达性矩阵
		vector<vector<int> >b(numb, vector<int>(numb));		//各度数的通路矩阵
		vector<vector<int> >T(numb, vector<int>(numb));		

		for (int i = 0; i < numb; i++)//初始化
		{
			for (int j = 0; j < numb; j++)
			{
				p[i][j] = 0;
				b[i][j] = 0;
				T[i][j] = 0;
			}
		}
		for (int i = 0; i < numb; i++)
		{
			for (int j = 0; j < numb; j++)
			{
				b[i][j] = aM()[i][j];//此时b为度数为1的通路矩阵
				p[i][j] = aM()[i][j];
			}
		}
		for (int x=0;x<numb-1;x++)//计算可达性矩阵p；循环一次度数加1  ；p=aM^1+aM^2+aM^3+……+aM^(numb-1)
		{
			for (int i = 0; i < numb; i++)//矩阵乘法
			{
				int t, s = 0;
				for (int j = 0; j < numb; j++)
				{
					for (int k = 0; k < numb; k++)
					{
						t = b[i][k] * aM()[k][j];
						s = s + t;
					}
					if(s!=0)s=1;
					T[i][j] = s;
					s = 0;
				}
			}
			for (int i = 0; i < numb; i++)
			{
				for (int j = 0; j < numb; j++)
				{
					b[i][j] = T[i][j];
				}
			}
			for (int i = 0; i < numb; i++)//相加
			{
				for (int j = 0; j < numb; j++)
				{
					p[i][j] = p[i][j] + b[i][j];
					if (p[i][j] != 0)
					{
						p[i][j] = 1;
					}
				}
			}
		}
		return p;
	}
	void visitTable()//打印邻接表
	{
		sideNode *u;
		int i = 0;
		for (i = 0; i < numb; i++)
		{
			u = pointsArry[i].head;

			cout << pointsArry[i].data << "	";
			while (u != NULL)
			{
				cout << "邻接" << pointsArry[u->datapostion].data << "距离" << u->weight << endl << "	";
				u = u->next;
			}
			cout << endl;
		}
	}
	void visitMatrix(vector<vector<int>> m)//打印矩阵
	{
		cout << " ";
		for (int i = 0; i < numb; i++)
		{
			cout << pointsArry[i].data <<" " ;
		}
		cout << endl;
		for (int i = 0; i < numb; i++)
		{
			cout << pointsArry[i].data << " " ;
			for (int j = 0; j < numb; j++)
			{
				cout << m[i][j] << " ";
			}
			cout << endl;
		}
	}
};

int main()
{
	map a;
	char x;
	a.setMapWithWeight();
	a.visitTable();
	cout << "输入一个点" << endl;
	cin >> x;
	a.dij(x);
	cout << "邻接矩阵（通路数）：" << endl;
	a.visitMatrix(a.aM());
	cout << "度数为2的通路矩阵" << endl;
	a.visitMatrix(a.B(2));
	cout << "可达性矩阵：" << endl;
	a.visitMatrix(a.P());
    std::cout << "Hello World!\n"; 
}

测试

qbbbbbbb
关注
专栏目录
C++数据结构之图
DVD0423的专栏
09-14 1881
图的实现是一件很麻烦的事情，很多同学可能在学数据结构时只是理解了图的基本操作和遍历原理，但并没有动手实践过。在此，我说说我的实现过程。
数据结构--图（c++）详细讲解
02-26
数据结构--图（c++）详细讲解，合工大老师详细讲解，不懂的朋友可以下载看看
C++之数据结构
不管风吹浪打，胜似闲庭信步
03-10 1635
线性表，二叉树，结构的了解
C++常用数据结构
最新发布
m0_71124168的博客
07-25 982
用一组地址连续的存储单元依次存储线性表中每个数据元素。用一组任意的存储单元存储线性表中的数据元素。栈（stack）是一种元素满足后进先出（Last in first out， LIFO）规则的线性表。树是指由 n(n≥0)个结点组成的有穷集合 D 与 D 上的关系的集合 R构成的结构，通常我们用 T 表示。树需要满足以下 3 个条件：当 n=0 时，该结点集合为空，该树被称为空树。在任意的非空树中，有且仅有一个根结点 root。
C++数据结构：图
weixin_43908419的博客
11-28 1412
本文介绍了图这种数据结构
c++数据结构-图（详解附算法代码，一看就懂）
强国豪,林中霖
05-11 955
从图中某一顶点出发，系统的访问图中所有顶点，并且每个顶点只被访问一次，这种操作叫做图的遍历。V是顶点的有穷非空集合，E是边的集合。深度优先遍历和深度优先搜索相似，它是先访问一个点，再访问与这个点相连的所有点，当这个点所有相连的点访问完，再退回下一个点。完全图：一个 n 阶的完全无向图含有 n*(n-1)/2 条边，一个 n 阶的完全有向图含有 n*(n-1) 条边。有向图：边上有箭头，只能从箭头的引出的结点到被指向的结点，不能逆着箭头走。G[i][j] 的值，表示点 i 到点 j 的边的权值，定义如下，
C++数据结构——栈.pdf
07-11
《C++数据结构——栈》 栈是一种在计算机科学中广泛应用的数据结构，它遵循“先进后出”（First In Last Out, FILO）的原则。在栈中，元素的插入（压栈）和删除（弹栈）操作只允许在栈顶进行。栈的主要特点在于其...
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
C++数据结构.pdf
07-11
《C++数据结构》这本书主要探讨了如何在C++编程语言中有效地管理和操作数据，以实现高效的算法和程序设计。数据结构是计算机科学中的一个重要概念，它涉及到如何组织和存储数据，以便能快速访问和修改。C++作为一门...
C++数据结构 图的实现
01-19
#include<iostream> #include "Bgraph.h"//引入头文件 using namespace std; /* *前置条件：图不存在 *输 入：无 *功 能：图的初始化 *输 出：无 *后置条件：得到一个有向图 */ template <class T> BGraph<T>::BGraph(T a[ ], int n, int e) { int i,j,k,w;ArcNode *E; vertexNum=n; arcNum=e; for(i=0;i<vertexNum;i++) { adjlist[i].vex=a[i]; adjlist[i].firstarc=NULL; } for(k=0;k<arcNum;k++) { cout<<"请输入第"<<k+1<<"条弧的信息（格式为：顶点1 顶点2 权值）"; cin>>i>>j>>w; //先插入边<i,j> E=new ArcNode; E->info=w; E->adjvex=j; E->nextarc=adjlist[i].firstarc; adjlist[i].firstarc=E; //再插入边<j,i> E=new ArcNode; E->info=w; E->adjvex=i; E->nextarc=adjlist[j].firstarc; adjlist[j].firstarc=E; } }
图数据结构的C++实现
07-10
图数据结构的C++实现，包括邻接表和邻接矩阵两种实现方式以及各种常用图算法，共同继承于抽象类。
C++中的数据结构
qianniulaoren的博客
06-29 1078
C++中的数据结构介绍
C++ 数据结构
wy749929317的博客
06-14 635
这些数据结构在C++中都有广泛的应用，并且C++的STL（Standard Template Library）提供了丰富的模板类来实现这些数据结构，如。C++支持多种数据结构，这些数据结构根据它们组织数据的方式和访问数据的方式可以分为不同的类型。（红黑树实现的集合）等。（红黑树实现的映射表）、
C++数据结构
qq_39562273的博客
03-04 1715
（参考严蔚敏的数据结构）数据结构主要包含表、栈和队列、串、数组和广义表、树和二叉树以及图等结构。
C++数据结构——中序遍历二叉树
05-23
以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值