最小生成树Prim算法 +索引优先队列

已于 2022-04-08 21:06:08 修改
阅读量303 收藏 1
点赞数 1
分类专栏： 算法导论(图论)C/C++ 文章标签： 数据结构
于 2020-03-18 10:50:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349225/article/details/104901452
版权

算法步骤 （实际应用中不用Prim算稀疏图）
算法步骤
邻接矩阵图

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

/*邻接矩阵存储图*/
typedef struct MGNode
{
	int Nv, Ne;
	int V[MaxV][MaxV];
	string Data[MaxV];
} * MGraph;
/*图的初始化*/
MGraph CreateMGraph(int Nv)
{
	MGraph G = new MGNode();
	G->Nv = Nv;
	for (int i = 0; i < G->Nv; i++)
		for (int j = 0; j < G->Nv; j++)
			G->V[i][j] = INF;
	return G;
}
/*边的插入*/
void InsertEdge(MGraph G, Edge E) //无向图要插入两次
{
	G->V[E->v1][E->v2] = E->Weight;
	G->V[E->v2][E->v1] = E->Weight;
}
/*建造一个图*/
MGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	MGraph G = CreateMGraph(Nv);
	cin >> G->Ne;
	Edge E = new ENode;
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->v1 >> E->v2 >> E->Weight;
		InsertEdge(G, E);
	}
	delete E;
	return G;
}

索引最小堆

typedef struct AssNode{
	int dist[MaxV];
	int reverse[MaxV];
} * AssArray;
//Index[i] = j;
//reverse[j] = i;
//reverse[Index[i]] = i;	//赋值

typedef struct IndexHNode{
	int *Index;		//堆真正存的数据是索引，但比较时用索引对应的dist[Index]
	AssArray Ass;
	int Size;
	int Capacity;
} * IndexHeap;
void SwapIndex(IndexHeap H, int i)	//修改反索引数组
{
	H->Ass->reverse[H->Index[i]] = i;
}

IndexHeap CreateHeap(int MaxSize)
{
	IndexHeap H = new IndexHNode;
	H->Size = 0; H->Capacity = MaxSize;
	H->Index = new int[MaxSize + 1](); H->Index[0] = 0;	//哨兵dist[index[0]] = 0
	H->Ass = new AssNode;
	return H;
}

/*插入顶点编号为v的顶点, 插入一个Index*/
void InsertIndex(IndexHeap H, int v) //从堆内访问dist必须通过dist[Index]
{
	int x = H->Ass->dist[v];
	int child;
	for ( child = ++H->Size; x < H->Ass->dist[H->Index[child / 2]]; child /= 2)	//目的是确定x位置
	{
		H->Index[child] = H->Index[child / 2];
		SwapIndex(H, child);
	}

	H->Index[child] = v;
	SwapIndex(H, child);
}
/*删除并返回最小边的索引*/
int DeleteIndex(IndexHeap H)
{
	int v = H->Index[1];
	int x = H->Ass->dist[H->Index[H->Size--]];
	int parent, child;
	for ( parent = 1; parent * 2 <= H->Size; parent = child)
	{
		child = parent * 2;
		if(H->Ass->dist[H->Index[child + 1]] < H->Ass->dist[H->Index[child]] && child != H->Size)
			child++;
		if(x > H->Ass->dist[H->Index[child]])
		{
			H->Index[parent] = H->Index[child];
			SwapIndex(H, parent);
		}
		else
			break;
	}
	H->Index[parent] = H->Index[H->Size + 1];
	SwapIndex(H, parent);
	return v;
}
/*修改dist[v]减少为x, 并调整堆*/
void Fix_up(IndexHeap H, int v, int x)
{
	H->Ass->dist[v] = x;
	int child;
	//切记!!!!!!!!!!!!!!!!!!!   这里使用reverse来访问堆!!!!而不是直接用v!!!(被坑傻过!!!)
	for (child = H->Ass->reverse[v]; x < H->Ass->dist[H->Index[child / 2]]; child /= 2)
	{
		H->Index[child] = H->Index[child / 2];
		SwapIndex(H, child);
	}
	H->Index[child] = v;
	SwapIndex(H, child);
}

Prim算法

int Prim(MGraph G, IndexHeap H)
{
	int MinTree = 0;
	for (int i = 1; i < G->Nv; i++)
		H->Ass->dist[i] = G->V[0][i];
	H->Ass->dist[0] = 0;			//表示0顶点已经是树中一部分

	for (int i = 1; i < G->Nv; i++)	//除0以外，所有顶点加入索引堆，表示还不是生成树内的顶点
		InsertIndex(H, i);

	while (H->Size != 0)	//队列中都是未加入生成树的顶点
	{

		int v = DeleteIndex(H);	//dist[v]最小，v加入生成树

		MinTree += H->Ass->dist[v];	//统计权重
		H->Ass->dist[v] = 0;	//标记该顶点已加入生成树

		for (int i = 0; i < G->Nv; i++)
			if(H->Ass->dist[i] != 0 && G->V[v][i] < INF)
				if(G->V[v][i] < H->Ass->dist[i])
					Fix_up(H, i, G->V[v][i]);	//找到最小dist后，在索引优先队列中更新dist
					
	}
	return MinTree;
}

int main()
{
	MGraph G = BuildGraph();
	IndexHeap H = CreateHeap(G->Nv);
	cout << Prim(G, H) << endl;

	system("pause");
	return 0;
}

input:
10 17
0 2 5
0 1 8
1 4 5
1 2 5
1 5 4
4 5 4
2 3 8
2 6 4
5 6 4
5 8 2
3 6 7
6 8 3
3 7 5
6 7 5
6 9 6
8 9 7
7 9 6
output:
38

生成树的具体边，可以加一个parent数组，然后每次找到一条边都插入一个新的图中，我就不写了。。。
完整代码

#include <iostream>
#include <climits>
#include <cstring>
using namespace std;
const int MaxV = 100;
const int INF = 10000;
/*定义边*/
typedef struct ENode{
	int v1, v2;
	int Weight;
} * Edge;

/*邻接矩阵存储图*/
typedef struct MGNode
{
	int Nv, Ne;
	int V[MaxV][MaxV];
	string Data[MaxV];
} * MGraph;
/*图的初始化*/
MGraph CreateMGraph(int Nv)
{
	MGraph G = new MGNode();
	G->Nv = Nv;
	for (int i = 0; i < G->Nv; i++)
		for (int j = 0; j < G->Nv; j++)
			G->V[i][j] = INF;
	return G;
}
/*边的插入*/
void InsertEdge(MGraph G, Edge E) //无向图要插入两次
{
	G->V[E->v1][E->v2] = E->Weight;
	G->V[E->v2][E->v1] = E->Weight;
}
/*建造一个图*/
MGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	MGraph G = CreateMGraph(Nv);
	cin >> G->Ne;
	Edge E = new ENode;
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->v1 >> E->v2 >> E->Weight;
		InsertEdge(G, E);
	}
	delete E;
	return G;
}

typedef struct AssNode{
	int dist[MaxV];
	int reverse[MaxV];
} * AssArray;
//Index[i] = j;
//reverse[j] = i;
//reverse[Index[i]] = i;	//赋值

typedef struct IndexHNode{
	int *Index;		//堆真正存的数据是索引，但比较时用索引对应的dist[Index]
	AssArray Ass;
	int Size;
	int Capacity;
} * IndexHeap;
void SwapIndex(IndexHeap H, int i)	//修改反索引数组
{
	H->Ass->reverse[H->Index[i]] = i;
}

IndexHeap CreateHeap(int MaxSize)
{
	IndexHeap H = new IndexHNode;
	H->Size = 0; H->Capacity = MaxSize;
	H->Index = new int[MaxSize + 1](); H->Index[0] = 0;	//哨兵dist[index[0]] = 0
	H->Ass = new AssNode;
	return H;
}

/*插入顶点编号为v的顶点, 插入一个Index*/
void InsertIndex(IndexHeap H, int v) //从堆内访问dist必须通过dist[Index]
{
	int x = H->Ass->dist[v];
	int child;
	for ( child = ++H->Size; x < H->Ass->dist[H->Index[child / 2]]; child /= 2)	//目的是确定x位置
	{
		H->Index[child] = H->Index[child / 2];
		SwapIndex(H, child);
	}

	H->Index[child] = v;
	SwapIndex(H, child);
}
/*删除并返回最小边的索引*/
int DeleteIndex(IndexHeap H)
{
	int v = H->Index[1];
	int x = H->Ass->dist[H->Index[H->Size--]];
	int parent, child;
	for ( parent = 1; parent * 2 <= H->Size; parent = child)
	{
		child = parent * 2;
		if(H->Ass->dist[H->Index[child + 1]] < H->Ass->dist[H->Index[child]] && child != H->Size)
			child++;
		if(x > H->Ass->dist[H->Index[child]])
		{
			H->Index[parent] = H->Index[child];
			SwapIndex(H, parent);
		}
		else
			break;
	}
	H->Index[parent] = H->Index[H->Size + 1];
	SwapIndex(H, parent);
	return v;
}
/*修改dist[v]减少为x, 并调整堆*/
void Fix_up(IndexHeap H, int v, int x)
{
	H->Ass->dist[v] = x;
	int child;
	//切记!!!!!!!!!!!!!!!!!!!   这里使用reverse来访问堆!!!!而不是直接用v!!!(被坑傻过!!!)
	for (child = H->Ass->reverse[v]; x < H->Ass->dist[H->Index[child / 2]]; child /= 2)
	{
		H->Index[child] = H->Index[child / 2];
		SwapIndex(H, child);
	}
	H->Index[child] = v;
	SwapIndex(H, child);
}

int Prim(MGraph G, IndexHeap H)
{
	int MinTree = 0;
	for (int i = 1; i < G->Nv; i++)
		H->Ass->dist[i] = G->V[0][i];
	H->Ass->dist[0] = 0;			//表示0顶点已经是树中一部分

	for (int i = 1; i < G->Nv; i++)	//除0以外，所有顶点加入索引堆，表示还不是生成树内的顶点
		InsertIndex(H, i);

	while (H->Size != 0)	//队列中都是未加入生成树的顶点
	{

		int v = DeleteIndex(H);	//dist[v]最小，v加入生成树

		MinTree += H->Ass->dist[v];	//统计权重
		H->Ass->dist[v] = 0;	//标记该顶点已加入生成树

		for (int i = 0; i < G->Nv; i++)
			if(H->Ass->dist[i] != 0 && G->V[v][i] < INF)
				if(G->V[v][i] < H->Ass->dist[i])
					Fix_up(H, i, G->V[v][i]);	//找到最小dist后，在索引优先队列中更新dist

	}
	return MinTree;
}

int main()
{
	MGraph G = BuildGraph();
	IndexHeap H = CreateHeap(G->Nv);
	cout << Prim(G, H) << endl;

	system("pause");
	return 0;
}

下面是不采用优先队列的暴力算法

#include <iostream>
#include <cstring>
#include <climits>
using namespace std;
const int MaxV = 100;
/*边的定义*/
typedef struct ENode
{
	int v1, v2;
	int Weight;
} * Edge;
/*邻接矩阵存储图*/
typedef struct MGNode
{
	int Nv, Ne;
	int F[MaxV][MaxV];
	string Data[MaxV];
} * MGraph;
/*图的初始化*/
MGraph CreateMGraph(int Nv)
{
	MGraph G = new MGNode();
	G->Nv = Nv;
	for (int i = 0; i < G->Nv; i++)
		for (int j = 0; j < G->Nv; j++)
			G->F[i][j] = INT_MAX;
	return G;
}
/*边的插入*/
void InsertEdge(MGraph G, Edge E) //无向图要插入两次
{
	G->F[E->v1][E->v2] = E->Weight;
	G->F[E->v2][E->v1] = E->Weight;
}
/*建造一个图*/
MGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	MGraph G = CreateMGraph(Nv);
	cin >> G->Ne;
	Edge E = new ENode;
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->v1 >> E->v2 >> E->Weight;
		InsertEdge(G, E);
	}
	delete E;
	return G;
}

/*邻接表图存生成的MST*/
struct AdjVNode
{
	int AdjV;
	int Weight;
	AdjVNode *Next;
};
typedef struct VNode
{
	AdjVNode *EdgeFirst;
	string Data;
} AdjList[MaxV];
typedef struct LGNode
{
	int Nv, Ne;
	AdjList L;
} * LGraph;
/*MST树初始化*/
LGraph CreateLGraph(int Nv)
{
	LGraph MST = new LGNode();
	MST->Nv = Nv;
	return MST;
}
/*MST边的插入*/
void InsertEdgeMST(LGraph MST, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Weight = E->Weight;
	V->Next = MST->L[E->v1].EdgeFirst;
	MST->L[E->v1].EdgeFirst = V;
	//无向图，插入两条边
	V = new AdjVNode;
	V->AdjV = E->v1;
	V->Weight = E->Weight;
	V->Next = MST->L[E->v2].EdgeFirst;
	MST->L[E->v2].EdgeFirst = V;
}



int FindMinDist(MGraph G, int dist[])
{
	int MinDist = INT_MAX;
	int MinV;
	for (int i = 0; i < G->Nv; i++)
		if(dist[i] != 0 && dist[i] < MinDist)
		{
			MinDist = dist[i];
			MinV = i;
		}
	if(MinDist < INT_MAX)
		return MinV;
	else
		return -1;
}
int Prim(MGraph G, LGraph MST)
{
	int dist[MaxV], TotalWeight = 0;
	int parent[MaxV], V, W;
	int VCount = 0;
	Edge E = new ENode;
	memset(parent, 0, sizeof(parent));
	for (int i = 1; i < G->Nv; i++)
		dist[i] = G->F[0][i];

	dist[0] = 0;
	VCount++;
	parent[0] = -1;
	while (1)
	{
		V = FindMinDist(G, dist);
		if(V == -1)
			break;

		E->v1 = parent[V];
		E->v2 = V;
		E->Weight = dist[V];
		InsertEdgeMST(MST, E);
		TotalWeight += dist[V];
		dist[V] = 0;
		VCount++;

		for (int i = 0; i < G->Nv; i++)
		{
			if(dist[i] != 0 && G->F[V][i] < INT_MAX)
				if(G->F[V][i] < dist[i])
				{
					dist[i] = G->F[V][i];
					parent[i] = V;
				}
		}

	}
	if(VCount < G->Nv)
		TotalWeight = -1;
	return TotalWeight;
}

int main()
{
	MGraph G = BuildGraph();
	LGraph MST = CreateLGraph(G->Nv);
	cout << Prim(G, MST) << endl;
	AdjVNode *V;
	for (int i = 0; i < MST->Nv; i++)
	{
		V = MST->L[i].EdgeFirst;
		cout << i << "->";
		while (V)
		{
			cout << V->AdjV << "->";
			V = V->Next;
		}
		cout << "NULL" << endl;

	}

	system("pause");
	return 0;
}

结果
在这里插入图片描述

不导翁
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树Prim算法朴素版 C语言实现
12-03
最小生成树Prim算法是图论中的一个重要概念，用于在加权无向图中找到连接所有顶点的边的集合，使得这些边的总权重最小。Prim算法朴素版是一种基于贪心策略的算法，其基本思想是从一个初始顶点开始，逐步扩展生成树，...
Prim算法、优先队列【贪心算法】
软件程序媛的博客
04-30 2542
Prim算法、优先队列【贪心算法】 贪心算法的本质是：一个问题的局部最优解，也是该问题的全局最优解。 最小生成树的最优子结构性质：假设一个无向图包含两部分A,B，其中A为最小生成树部分，B为剩余部分，则存在以下性质：该无向图中一个顶点在A部分，另一个顶点在B部分的边中，权值最小的边一定属于整个无向图的最小生成树，即部分最小权值是整个最小生成树的局部最有解，该性质符合贪心算法的特点。 Prim算法 基于最小生成树的该性质，使用prim算法来求解最小生成树。 贪心算法属性：一个局部全优解，也是全局全优解 思想：
最小生成树 - Prim
大漠知秋的加油站
07-07 1084
什么是最小生成树？假设有 个点，通过 条边将它们相连接，就叫做生成树，而最小就是这 条边的权重相加最小，综合起来就是最小生成树。下面一张图：按照最小生成树的规则，最终可以找到这样一条线：、、、、、、 7 条边把所有的点进行相连，形成了这张图的最小生成树。在这里也能看出来，想要找最小生成树，这个图必须是一个连通图，也就是没有其他的连通分量。那通过什么样的方式可以求得总共有哪些边可以组成最小生成树？要想解决这个问题，就需要先了解一下什么是。把一张图分成两部分就叫做切分，如下：把一张图分成两部分之后，连接
【模板】最小生成树（Prim算法——优先队列实现形式）：适用于稀疏图
最新发布
m0_60738889的博客
06-29 1385
如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出orz。
CCF-CSP 201812-4-数据中心 (Python) 最小堆 优先队列 Prim最小生成树 满分实现
m0_50078259的博客
03-08 192
最小堆（堆中每个节点的值都小于等于其子节点的值。）是一种数据结构，它是一棵二叉树，其中每个节点的值都小于或等于其子节点的值。当我们向优先队列中添加元素时，我们可以将其插入到最小堆中，并在需要时执行堆化操作以保持堆的性质。：是一种常用的求解最小生成树的算法，它的基本思想是从一个初始节点开始，依次加入与当前生成树相邻的最短边，直到所有节点都被加入为止。，每次从堆中取出一条最小边并更新访问节点集合，直到所有节点都被访问或者堆为空为止。来维护候选边集，以便快速地找到当前生成树所连接的所有节点中，与其距离最短的边。
Prim 普利姆算法-Priority Queue 方法
Jasonchen1224的博客
01-27 300
Prim 普利姆算法 最小生成树
数据结构_栈_队列_prim算法_
10-04
在“prim算法.c”中，Prim算法通常采用贪心策略，每次从当前已连接的顶点中选取一个与未连接顶点之间权值最小的边，逐渐扩展最小生成树。这个算法在网络设计、路由优化等领域有广泛应用。 链表作为一种基础的数据...
基于C语言的最小生成树算法
11-16
最小生成树算法是图论中的一个经典问题，用于寻找带权重的无向图中边的子集，使得这些边连接了图中的所有顶点，并且这些边的总权重尽可能小。在本例中，我们将专注于使用C语言实现Prim算法来解决这个问题。 Prim...
LUT算法与数据结构-- 停车场管理和构造使n个城市连接的最小生成树
12-10
常见的求解最小生成树的算法有Prim算法和Kruskal算法。在城市网络规划中，每条道路可视为一个有向边，其权重代表建设成本或距离。Prim算法从一个初始节点开始，逐步添加边至当前树，每次选择连接到树中节点且权重...
最小生成树
06-19
5. **最小生成树算法**：使用 Prim 算法来计算最小生成树。Prim 算法的基本思想是从任意一个顶点开始，不断选择可以加入最小生成树的新边，直到所有顶点都被加入。在 `MiniSpanTree_PRIM` 函数中，定义了一个 `...
最小生成树之prim算法（优先队列优化）
HJY
07-13 7598
prim算法适合稠密图，即边数较多而点较少的情况，时间复杂度为n^2，堆优化的情况下，如果点数为m，边数为n，可以达到nlongm，我还是习惯用优先队列写这个算法，思想很简单，就是每次寻找一条由已加入集合的点和与它们相邻的没加入集合的点的权值最小边（有点绕理解下），进行n-1次就找出来了，也是贪心的思想，实现就是随便找一个初始节点，然后建一个最小堆（边小的先pop出来），把该节点的vis值置为1，遍历该节点相邻的节点，如果没有被vis标记过，就加入边到堆中，扫完了以后处理堆中数据，如果弹出的边被标记过就po
Prim算法实现 -- 结合优先级队列
Pain is inevitable but suffering is optional.
09-05 284
【代码】Prim算法实现 -- 结合优先级队列。
最小生成树——prim最小堆（优先队列）优化算法
Df_cjc的博客
07-29 3555
基本prim最小生成树 1·任意定点构树————标记数组标记入树 2·初始化更新维护dis数组 3·选出dis中最近的点j加入树中，并以j为起点松弛 4.重复第3步选出n-1个点 堆优化prim最小生成树 准备：dis数组，p优先队列,vis数组记录每个定点在最小堆中的位置 1.初始化优先队列，以定义的起点为起点的所有的边入队 2.弹出一条边，判断vis，如果边的终点访问了换边，直至...
java prim优先队列,面试必知必会|堆和优先队列
weixin_36434922的博客
03-13 190
面试必知必会|堆和优先队列后端技术指南针 后端技术指南针通过本文将了解到以下内容：优先队列的概念优先队列的实现优先队列的应用1.优先队列的概念优先队列是计算机科学中的一类抽象数据类型。优先队列中的每个元素都有各自的优先级，优先级最高的元素最先得到服务；优先级相同的元素按照其在优先队列中的顺序得到服务。优先队列至少需要支持下述操作：a.插入带优先级的元素b.取出具有最高优先级的元素c.查看最高优先...
最小生成树：优先队列优化 prim（普里姆）
spicychicken的博客
08-01 1899
优先队列优化 prim（普里姆） ∙\bullet∙其实迪杰斯特拉和普里姆算法的思想是一样的，只是表示距离的数组d[i]d[i]d[i]含义不一样；在迪杰斯特拉中d[i]d[i]d[i]表示：起点到第iii个点的最短距离；在普里姆中d[i]d[i]d[i]表示：假设每次在d[]d[]d[]数组里找到最小的点是nownownow，那么d[i]d[i]d[i]就表示v(now,i)v(now,i)v(...
Prim 算法的实现
qq_31805127的博客
06-03 1256
最小生成树除了prim还有kruskal算法。Prim算法的实现，用到了优先队列。仅供参考的c++代码：#include &lt;iostream&gt; #include &lt;string&gt; #include &lt;stack&gt; #include &lt;fstream&gt; #include &lt;sstream&gt; #include &lt;ctime&gt; #i...
C语言经典算法之普里姆（prim）算法
weixin_56154577的博客
02-06 3638
在C语言中实现普利姆（Prim）算法通常涉及数据结构的选择（如邻接矩阵或邻接表）、优先队列来存储待处理边以及变量来追踪已加入最小生成树的顶点。
最小生成树之Prim算法 优先队列版本
NeWnIx
04-06 6904
http://www.cppblog.com/tanky-woo/archive/2013/02/18/126940.html 这个博客对prim讲解的很好   如果用传统的做法每次都要将集合内的元素遍历一遍，再与集合外的元素判断是否相连，再找出最小权值，然后把带有最小权值的那个终点记录下来，插入到集合内。 下次循环再从集合的第一个元素开始遍历，这样会浪费很多时间，于是乎，我想能不能把之前...
Prim算法与Dijkstra算法(优先队列实现的时间复杂度分析)
m0_72979740的博客
10-23 610
堆实现的优先队列在维护最小值时的时间复杂度是O(logV)，而数组实现的优先队列需要遍历整个数组来查找最小值，时间复杂度是O(V)因为优先队列用的就是一个堆，push和pop就是上浮和下沉，与树的高度成正比。而Dijkstrta贪心选择的是未visit结点到源的最短路径值dist[]Prim贪心选择的是未visit结点到MST那一堆里面最小的点。Prim与Dijkstra的区别就在于《贪心策略的不同》并且由于它们都是贪心的，都有算法正确性证明的板块。m=|E|,边的数量。
Prim最小生成树算法实现及图操作
在实现Prim算法时，通常会用到优先队列（如堆）来高效地找到当前未访问顶点到已生成树的最短边。然而，文档中没有明确提及这部分内容，可能是在实际代码实现时进行了补充。 Prim算法的实现是通过迭代或递归的方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值