图-弗洛伊德（FloydWarshall）算法详解（含全部代码）_弗洛伊德算法代码(1)

于 2024-04-20 01:03:14 发布
阅读量270 收藏 9
点赞数 3
分类专栏： 2024年程序员学习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83974173/article/details/137982294
版权

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）
img

正文

  • Adjancent(Graph G,VexType v,VexType w) 判断是否存在弧(v,w)函数 参数：图G，某弧两端点v和w 作用：判断是否存在弧(v,w)
  • BFS(Graph G, int start) 广度遍历函数 参数：图G,开始结点下标start 作用：宽度遍历
  • DFS(Graph G, int start) 深度遍历函数（递归形式）参数：图G,开始结点下标start 作用：深度遍历
  • Dijkstra(Graph G, int v)  最短路径 - Dijkstra算法 参数：图G、源点v
  • Bellman_Ford(Graph G, int v)  最短路径 - Bellman_Ford算法  参数：图G、源点v 作用：计算不含负圈图的最短路径 返回是否有圈
  • Floyd_Wallshall(Graph G)    最短路径 - Floyd_Wallshall算法  参数：图G 作用：计算不含负圈图的最短路径 返回是否有圈

功能实现函数

  • CreateGraph(Graph &G) 创建图功能实现函数 参数：图G  InsertNode 作用：创建图
  • BFSTraverse(Graph G)  广度遍历功能实现函数 参数：图G 作用：宽度遍历
  • DFSTraverse(Graph G)  深度遍历功能实现函数 参数：图G 作用：深度遍历
  • Shortest_Dijkstra(Graph &G) 调用最短路径-Dijkstra算法 参数：图G、源点v
  • Shortest_Bellman_Ford(Graph &G) 调用最短路径- - Bellman_Ford算法  参数：图G
  • Shortest_Floyd_Wallshall(Graph &G) 调用最短路径- - Floyd_Wallshall算法  参数：图G

测试使用图

测试使用图

算法讲解

初始化

表格行为i,列为j。D及P后小括号内的值为迭代次数。

D矩阵主对角线为0，其余与邻接矩阵相同。

P矩阵存-1，在输出最短路径时作为递归出口。

迭代

D矩阵的状态转移方程：D(m)[i][j]=min{D(m-1)[i][j],D(m-1)[i][k]+D[k][j]},0<<k<<n-1,其中,m为迭代次数，n为节点个数。

思路：添加一个点Vk,找到Vk的入弧Vi->Vk，再找到Vk的出弧,Vk->Vj，比较D[i][j]与D[i][k]+D[k][j]的大小。

若D矩阵有更新，则对应P矩阵的值为更新处最短路径第一条弧的终点。

D(1)

04-3∞
-30-7∞
∞1003
5660

P(1)

-1-1-1-1
-1-1-1-1
-1-1-1-1
-1-1-1-1

D(2)

04-3∞
-30-7∞
∞1003
5620

加入点V0，V0的入弧有V1->V0与V3->V0，出弧有V0->V1与V0->V2。

经比较D(1)[3][2]>D(1)[3][0]+D(1)[0][2]，6>5-3=2，所以，将6更新为2。

P(2)

-1-1-1-1
-1-1-1-1
-1-1-1-1
-1-10-1

P(2)[3][2]由P(1)[3][2]改为0，因为最短路径为V3->V0->V2，第一条弧的终点为V0。

D(3)

04-3∞
-30-7∞
71003
36-10

加入点V1，V1入弧有V0->V1，V2->V1以及V3->V1，出弧有V1->V2,V1->V0。

经比较,D(2)[2][0]>D(2)[2][1]+D(2)[1][0]，∞>10-3=7，所以，将∞更新为7。

D(2)[3][0]>D(1)[3][1]+D(2)[1][0]，5>6-3=3，所以，将5更新为3。

D(2)[3][2]>D(1)[3][1]+D(2)[1][2]，2>6-7=-1，所以，将2更新为-1。

P(3)

-1-1-1-1
-1-1-1-1
1-1-1-1
1-11-1

P(3)[2][0]改为1，因为最短路径为V2->V1->V0，第一条弧的终点为V1。

P(3)[3][0]改为1，因为最短路径为V3->V1->V0，第一条弧的终点为V1。

P(3)[3][2]改为1，因为最短路径为V3->V1->V2，第一条弧的终点为V1。

下面的由读者根据原理及矩阵自己补充，加深印象。

D(4)

04-30
-30-7-4
71003
36-10

P(4)

-1-1-12
-1-1-12
1-1-1-1
1-11-1

D(5)

04-30
-30-7-4
6903
36-10

P(5)

-1-1-12
-1-1-12
33-1-1
1-11-1

注意：弗洛伊德算法的最短路径在输出时不是倒着的，我们记录的是第一条弧的终点。例如，p[2][0]=3，P[3][0]=1,P[1][0]=-1，

则V[2]到V[0]的最短路径为2->3->1->0，值为6。也就是看P矩阵的列，这是与前面两篇最短路径算法不同的地方，需注意。

弗洛伊德算法代码

//最短路径 - Floyd_Wallshall算法  参数：图G 作用：计算不含负圈图的最短路径 返回是否有圈
bool Floyd_Wallshall(Graph G)
{
	//初始化
	for (int i = 0; i<G.vexnum; i++)
		for (int j = 0; j < G.vexnum; j++)
		{
			if (i == j)F_D[i][j] = 0;
			else F_D[i][j] = G.Edge[i][j];
			P[i][j] = -1;
		}
	//初始化结束，开始迭代
	for(int k=0;k<G.vexnum;k++)
		for (int i = 0; i<G.vexnum; i++)
			for (int j = 0; j<G.vexnum; j++)
				if (F_D[i][j] > F_D[i][k] + F_D[k][j])
				{
					F_D[i][j] = F_D[i][k] + F_D[k][j];
					P[i][j] = k;
				}
	bool flag = true;
	for (int i = 0; i < G.vexnum; i++)
		for (int j = 0; j < G.vexnum; j++)
			if (i==j&&F_D[i][j] < 0)
			{
				flag = false;
				break;
			}
	return flag;
}

全部代码

/*
Project: 图-最短路径-Bellman-Ford算法（可含有负权弧）
Date:    2019/10/24
Author:  Frank Yu
基本操作函数:
InitGraph(Graph &G)             初始化函数 参数：图G 作用：初始化图的顶点表，邻接矩阵等
InsertNode(Graph &G,VexType v) 插入点函数 参数：图G,顶点v 作用：在图G中插入顶点v,即改变顶点表
InsertEdge(Graph &G,VexType v,VexType w) 插入弧函数 参数：图G,某弧两端点v和w 作用：在图G两点v,w之间加入弧，即改变邻接矩阵
Adjancent(Graph G,VexType v,VexType w) 判断是否存在弧(v,w)函数 参数：图G，某弧两端点v和w 作用：判断是否存在弧(v,w)
BFS(Graph G, int start) 广度遍历函数 参数：图G,开始结点下标start 作用：宽度遍历
DFS(Graph G, int start) 深度遍历函数（递归形式）参数：图G,开始结点下标start 作用：深度遍历
Dijkstra(Graph G, int v)  最短路径 - Dijkstra算法 参数：图G、源点v
Bellman_Ford(Graph G, int v)  最短路径 - Bellman_Ford算法  参数：图G、源点v 作用：计算不含负圈图的最短路径 返回是否有圈
Floyd_Wallshall(Graph G)    最短路径 - Floyd_Wallshall算法  参数：图G 作用：计算不含负圈图的最短路径 返回是否有圈
功能实现函数：
CreateGraph(Graph &G) 创建图功能实现函数 参数：图G  InsertNode 作用：创建图
BFSTraverse(Graph G)  广度遍历功能实现函数 参数：图G 作用：宽度遍历
DFSTraverse(Graph G)  深度遍历功能实现函数 参数：图G 作用：深度遍历
Shortest_Dijkstra(Graph &G) 调用最短路径-Dijkstra算法 参数：图G、源点v
Shortest_Bellman_Ford(Graph &G) 调用最短路径- - Bellman_Ford算法  参数：图G
Shortest_Floyd_Wallshall(Graph &G) 调用最短路径- - Floyd_Wallshall算法  参数：图G
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<string>
#include<set>
#include<list>
#include<queue>
#include<vector>
#include<map>
#include<iterator>
#include<algorithm>
#include<iostream>
#define MaxVerNum 100 //顶点最大数目值
#define VexType char //顶点数据类型
#define EdgeType int //弧数据类型,有向图时邻接矩阵不对称，有权值时表示权值，没有时1连0不连
#define INF 0x3f3f3f3f//作为最大值
using namespace std;
//图的数据结构
typedef struct Graph
{
	VexType Vex[MaxVerNum];//顶点表
	EdgeType Edge[MaxVerNum][MaxVerNum];//弧表
	int vexnum, arcnum;//顶点数、弧数
}Graph;
//迪杰斯特拉算法全局变量
bool S[MaxVerNum]; //顶点集
int D[MaxVerNum];  //到各个顶点的最短路径
int F_D[MaxVerNum][MaxVerNum];//Floyd的D矩阵 记录最短路径
int Pr[MaxVerNum]; //记录前驱
//*********************************************基本操作函数*****************************************//
//初始化函数 参数：图G 作用：初始化图的顶点表，邻接矩阵等
int P[MaxVerNum][MaxVerNum];//最短路径记录矩阵
void InitGraph(Graph &G)
{
	memset(G.Vex, '#', sizeof(G.Vex));//初始化顶点表
									  //初始化弧表
	for (int i = 0; i < MaxVerNum; i++)
		for (int j = 0; j < MaxVerNum; j++)
			G.Edge[i][j] = INF;
	G.arcnum = G.vexnum = 0;          //初始化顶点数、弧数
}
//插入点函数 参数：图G,顶点v 作用：在图G中插入顶点v,即改变顶点表
bool InsertNode(Graph &G, VexType v)
{
	if (G.vexnum < MaxVerNum)
	{
		G.Vex[G.vexnum++] = v;
		return true;
	}
	return false;
}
//插入弧函数 参数：图G,某弧两端点v和w 作用：在图G两点v,w之间加入弧，即改变邻接矩阵
bool InsertEdge(Graph &G, VexType v, VexType w, int weight)
{
	int p1, p2;//v,w两点下标
	p1 = p2 = -1;//初始化
	for (int i = 0; i<G.vexnum; i++)//寻找顶点下标
	{
		if (G.Vex[i] == v)p1 = i;
		if (G.Vex[i] == w)p2 = i;
	}
	if (-1 != p1&&-1 != p2)//两点均可在图中找到
	{
		G.Edge[p1][p2] = weight;//有向图邻接矩阵不对称
		G.arcnum++;
		return true;
	}
	return false;
}
//判断是否存在弧(v,w)函数 参数：图G，某弧两端点v和w 作用：判断是否存在弧(v,w) 
bool Adjancent(Graph G, VexType v, VexType w)
{
	int p1, p2;//v,w两点下标
	p1 = p2 = -1;//初始化
	for (int i = 0; i<G.vexnum; i++)//寻找顶点下标
	{
		if (G.Vex[i] == v)p1 = i;
		if (G.Vex[i] == w)p2 = i;
	}
	if (-1 != p1&&-1 != p2)//两点均可在图中找到
	{
		if (G.Edge[p1][p2] == 1)//存在弧
		{
			return true;
		}
		return false;
	}
	return false;
}
bool visited[MaxVerNum];//访问标记数组，用于遍历时的标记
//广度遍历函数 参数：图G,开始结点下标start 作用：宽度遍历
void BFS(Graph G, int start)
{
	queue<int> Q;//辅助队列
	cout << G.Vex[start];//访问结点
	visited[start] = true;
	Q.push(start);//入队
	while (!Q.empty())//队列非空
	{
		int v = Q.front();//得到队头元素
		Q.pop();//出队
		for (int j = 0; j<G.vexnum; j++)//邻接点
		{
			if (G.Edge[v][j] < INF && !visited[j])//是邻接点且未访问
			{
				cout << "->";
				cout << G.Vex[j];//访问结点
				visited[j] = true;
				Q.push(j);//入队
			}
		}
	}//while
	cout << endl;
}
//深度遍历函数（递归形式）参数：图G,开始结点下标start 作用：深度遍历
void DFS(Graph G, int start)
{
	cout << G.Vex[start];//访问
	visited[start] = true;
	for (int j = 0; j < G.vexnum; j++)
	{
		if (G.Edge[start][j] <INF && !visited[j])//是邻接点且未访问
		{
			cout << "->";
			DFS(G, j);//递归深度遍历
		}
	}
}
//最短路径 - Dijkstra算法 参数：图G、源点v3
void Dijkstra(Graph G, int v)
{
	//初始化
	int n = G.vexnum;//n为图的顶点个数
	for (int i = 0; i < n; i++)
	{
		S[i] = false;
		D[i] = G.Edge[v][i];
		if (D[i] < INF)Pr[i] = v; //v与i连接，v为前驱
		else Pr[i] = -1;
	}
	S[v] = true;
	D[v] = 0;
	//初始化结束,求最短路径，并加入S集
	for (int i = 1; i < n; i++)
	{
		int min = INF;
		int temp;
		for (int w = 0; w < n; w++)
			if (!S[w] && D[w] < min) //某点temp未加入s集，且为当前最短路径
			{
				temp = w;
				min = D[w];
			}
		S[temp] = true;
		//更新从源点出发至其余点的最短路径 通过temp
		for (int w = 0; w < n; w++)
			if (!S[w] && D[temp] + G.Edge[temp][w] < D[w])
			{
				D[w] = D[temp] + G.Edge[temp][w];
				Pr[w] = temp;
			}
	}
}
//最短路径 - Bellman_Ford算法  参数：图G、源点v 作用：计算不含负圈图的最短路径 返回是否有圈
bool Bellman_Ford(Graph G, int v)
{
	//初始化
	int n = G.vexnum;//n为图的顶点个数
	for (int i = 0; i < n; i++)
	{
		D[i] = G.Edge[v][i];
		if (D[i] < INF)Pr[i] = v; //v与i连接，v为前驱
		else Pr[i] = -1;
	}
	D[v] = 0;
	//初始化结束，开始双重循环
	for (int i = 2; i<G.vexnum - 1; i++)
		for (int j = 0; j<G.vexnum; j++) //j为源点
			for (int k = 0; k<G.vexnum; k++) //k为终点
				if (D[k] > D[j] + G.Edge[j][k])
				{
					D[k] = D[j] + G.Edge[j][k];
					Pr[k] = j;
				}
	//判断是否含有负圈
	bool flag = true;
	for (int j = 0; j<G.vexnum - 1; j++) //j为源点
		for (int k = 0; k<G.vexnum - 1; k++) //k为终点
			if (D[k] > D[j] + G.Edge[j][k])
			{
				flag = false;
				break;
			}
	return flag;
}
//最短路径 - Floyd_Wallshall算法  参数：图G 作用：计算不含负圈图的最短路径 返回是否有圈
bool Floyd_Wallshall(Graph G)


## 写在最后

**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**


需要完整版PDF学习资源私我





**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）**
![img](https://img-blog.csdnimg.cn/img_convert/ff08778a55fe7e0e4d7853284b9d4700.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**


**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**


需要完整版PDF学习资源私我





**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）**
[外链图片转存中...(img-F3D9rroN-1713546183431)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_83974173
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Floyd-Warshall 算法概述
m0_65152384的博客
11-17 243
Floyd-Warshall 算法
图-弗洛伊德（FloydWarshall）算法详解（含全部代码）
关注网络安全、云原生安全
10-25 9338
目录 适用条件 基本操作函数 功能实现函数 测试使用图 算法讲解 初始化 迭代 弗洛伊德算法代码 全部代码 实验结果 最短路径算法比较 适用条件 图中可以有负权，但不能有负圈（圈中弧或边的权值之和小于0） 基本操作函数 InitGraph(Graph &G) 初始化函数 参数：图G 作用：初始化图的顶点表，邻接矩阵等 InsertNo...
弗洛伊德（Floyd)算法详解
热门推荐
weixin_60737527的博客
03-27 8万+
弗洛伊德（Floyd)算法详解
Floyd-Warshall算法，简称Floyd算法
aizhao3648的博客
04-21 278
Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。 使用条件&范围通常可以在任何图中使用，包括有向图、带负权边的图。 Floyd-Warshall 算法用来找出每对点之间的最短距离。它需要用邻接矩阵来储存边，这个算法通过考虑最佳子路径来得到最佳路径。 1.注意单独一条边的路径也不一定是最佳路径。2.从任意一条单边路...
Floyd-Warshall算法（Floyd-Warshall algorithm）
songyux6的专栏
03-24 4543
Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理带权有向图或负权的最短路径问题    解决此问题有两种方法： 其一是分别以图中每个顶点为源点共调用n次算法； 其二是采用Floyd算法。    两种算法的时间复杂度均为O(n3)，但后者形式上比较简单。 Floyd算法的基本思想：  （1）
C#，弗洛伊德-瑞文斯特（Floyd-Rivest）算法与源代码
最新发布
03-24
C#，弗洛伊德-瑞文斯特（Floyd-Rivest）算法与源代码. Floyd-Rivest 算法是一种选择算法，用于在不同元素的数组中找到第k个最小元素。它类似于快速选择算法，但在实际运行中有更好的运行时间。 和 QuickSelect 一样...
图.zip_matlab 图算法_弗洛伊德算法
07-15
MATLAB 最短路径 弗洛伊德算法
c语言源代码基于弗洛伊德算法的走迷宫找出路程序
01-18
给定一个二维迷宫，输入入口坐标和出口坐标，打印出最优路径
MFCApplication1_地铁计费_c/C++_弗洛伊德算法_
09-30
使用弗洛伊德算法实现对北京所有地铁线任意两站之间票价的计算，涉及到最短路径问题。
Floyd最短路径算法_Floyd算法_write8lf_matlab_弗洛伊德算法_最短路径_源码
10-02
弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题。该程序包括函数，主函数，以及打印出最短路径。
弗洛伊德算法 源代码
08-25
弗洛伊德算法 源代码 求出一对顶点之间的嘴短路径
图的弗洛伊德算法
09-18
本代码是数据结构（c语言）中图的弗洛伊德算法的实现
传递闭包（Warshall算法）
04-09
传递闭包（Warshall算法） 传递闭包（Warshall算法） 传递闭包（Warshall算法）
floyd源代码程序
09-19
MATLAB最短路线规划，可以应用于大多数非线性规划问题，具有普遍性
弗洛伊德算法Floyd个人看法（凭个人理解进行纠错）以及Floyd完整代码
qq_63125992的博客
11-27 444
弗洛伊德算法 Floyd个人看法（凭个人理解进行纠错）以及Floyd完整代码
floyd 算法模板详解(适合新手)
qq_61935738的博客
08-29 883
floyd 算法模板详解(适合新手)
最短路径：弗洛伊德算法代码编写及解释
双鱼座boyy的博客
05-24 838
弗洛伊德算法求的是每一对顶点之间（n->n）的最短路径，而迪杰斯特拉算法求得是某一点到其它顶点（1->n）的最短路径 所以第一种方法就是将迪杰斯特拉算法循环n次。 第二种就是直接运用弗洛伊德算法： 原图： 一，大致过程演示解释 这里只说所有顶点经过A点得到的最短路径（可以先看后面关于方法的解释，再来理解这段话） 首先A点经过A得到最短路径，显然可知都不变。 然后B点经过A点得到最短路径，即将B点与其它点的连线与BA和A到其他点连线相比较， （eg：求AC之间最短路径，将A.
傻子也能看懂的弗洛伊德算法（转）
Harington的博客
08-24 2万+
文章出处：（啊哈，算法） 暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费以及方便计划旅程，小哼希望在出发之前知道任意两个城市之前的最短路程。 上图中有4个城市8条公路，公路上的数字表示这条公路的长短。请注意这些公路是单向的。我们现在需要求任意两个城市之间的最短路程，也就是求任意两个点之间的最短路径。这个问...
数据结构之---C语言实现最短路径之Floyd（弗洛伊德）算法
杨鑫newlife的专栏
08-21 9315
数据结构之---C语言实现最短路径之Floyd（弗洛伊德）算法
弗洛伊德算法校园导航系统java代码
01-12
弗洛伊德算法是一种用于寻找给定图中所有顶点对之间最短路径的算法。在校园导航系统中，我们可以使用弗洛伊德算法来计算出任意两个地点之间的最短路径，并根据需要提供导航方向。 以下是一个使用Java语言实现的校园...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值