图的遍历和Prim最小生成树(万字总结)

最新推荐文章于 2022-08-06 21:15:21 发布
最新推荐文章于 2022-08-06 21:15:21 发布
阅读量445 收藏 6
点赞数 4
文章标签： 深度优先 图搜索算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51340322/article/details/118908348
版权

图的遍历和Prim最小生成树

文章目录


通常来说图有邻接矩阵(即二维数组)和邻接表(即多重链表)表示，如图：

邻接矩阵：

邻接矩阵

邻接表：

邻接表

一、邻接矩阵表示法

1.1图的深度优先遍历

1.1.1 递归

例如下图：表示出发点从A开始的递归树

DFS

深度优先搜索DFS，在树和图中其实本质是一样的，可以说树是一种特殊的图，在二叉树(链式存储结构)中，每个结点含有两个指针，分别指向左、右孩子，当然如果没有左右孩子结点则将该指针域置空。遍历时仅需考虑两种情况：1.往左走进入左子树 2.往右走进入右子树，知道指针域为空，则回溯。而在图中，一个结点可能会连接巨多结点，而每一个结点的出度又不尽相同，所以需要提前在建图的时候把所有顶点存入，那么在接下来的遍历中，依次判断与其他顶点的关系，如果是相连的，就可以从走到该节点，如此往复。当然，遍历要求要做到每个节点不重不漏的访问，那么则需要标记数组的记录，对于非连通图，需要依次枚举各个顶点以确保不重不漏。

完整代码如下：

  1. 从某点开始进行深度优先遍历
#include <bits/stdc++.h>

using namespace std;

const int MVNum = 500;

bool visited[MVNum];//标记数组，初始化为未访问false

typedef struct 
{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum, arcnum;

}AMGraph;

int Locatevex(AMGraph &G, char ch)
{
	for (int i = 1; i <= G.vexnum; ++ i) {
		if (G.vexs[i] == ch) return i;
	}
	return 0;
}

void CreateUDN(AMGraph &G)
{
    //cout << "请输入点数目和边数：" << endl; 
    cin >> G.vexnum >> G.arcnum;//输入顶点数目和边数，空格隔开
    
    // cout << "请依次输入各个顶点 ：" << endl;
    for (int i = 1; i <= G.vexnum; ++ i) 
        cin >> G.vexs[i];//依次输入各个顶点
    
    for (int i = 1; i <= G.vexnum; ++ i) 
        for (int j = 1; j <= G.vexnum; ++ j) 
            G.arcs[i][j] = 0;//对边初始化 
    //  cout << "请输入两顶点，建立边关系 ：" << endl;   
    for (int i = 1; i <= G.arcnum; ++ i) 
    {
        char v1, v2; 
        cin >> v1 >> v2;//输入两顶点，建立边关系 
        //寻找两个顶点在存入顶点数组中的位置
        int x1 = Locatevex(G, v1);
        int x2 = Locatevex(G, v2);
        G.arcs[x1][x2] = G.arcs[x2][x1] = 1;
    }
    return;
}

void DFS(AMGraph &G, int x)
{   
    //访问输出该顶点，标记为已访问
    cout << G.vexs[x] << ' ';
    visited[x] = true;

    for (int j = 1; j <= G.vexnum; ++ j)
    {   //如果与下一个点有联系且没有访问，则访问下一个点
        if (G.arcs[x][j] && !visited[j]) DFS(G, G.vex[j]);
    }
    return;
}

int main()
{
    AMGraph G;

    CreateUDN(G);

/*  打印建立的二维矩阵 
    for (int i = 1; i <= G.vexnum; ++ i) {
        for (int j = 1; j <= G.vexnum; ++ j) cout << G.arcs[i][j] << ' ';
        cout << endl;
    }
*/ 
    char v; cin >> v;//若为非连通图，则删此行，改DFS为DFS_ALL
    DFS(G, v);
    system("pause");

    return 0;
}

运行结果如下：

n1

  1. 对于非连通图，加上这个函数，主函数直接调用即可
void DFS_ALL(AMGraph &G)
{
    for (int i = 1; i <= G.vexnum; ++ i)
       if (!visited[i]) DFS(G, i);
}

运行结果如下：

n2

1.1.2 非递归
  1. 从某点开始进行深度优先遍历
//直接把上面的DFS函数改了即可，需要引用头文件stack
//#include <stack>或引用万能头文件#include <bits/stdc++.h>
void DFS(AMGraph &G, char v)
{
	stack <char> S;
	S.push(v);
    while (!S.empty())
    {
        char c = S.top(); S.pop();//取出栈顶元素 
        int x = Locatevex(G, c);//对该元素定位 
        if (!visited[x]) {
        	cout << c << " "; visited[x] = true;//输出该元素 
	        for (int j = 1; j <= G.vexnum; ++ j) {
	        	if (G.arcs[x][j] && !visited[j]) {
	        		//将该元素所有相关联的点入栈 
                    S.push(G.vexs[j]);
				}
		    }
		}
        
    }
    return;
}

运行结果如下：

n3

  1. 对于非连通图，DFS_ALL函数完全同上

运行结果如下：

b1

1.2、图的广度优先遍历

例如下图：

BFS

类似于树的层序遍历，在图中也是一层一层地访问。代码方面直接将DFS非递归中栈改成队列即可，BFS函数如下：(从某点开始)

//需要引用头文件#include <queue>
//或引用万能头文件#include <bits/stdc++.h>
void BFS(AMGraph &G, char v)
{
	queue <char> Q;
	Q.push(v);
    while (!Q.empty())
    {
        char c = Q.front(); Q.pop();//取出队头元素 
        int x = Locatevex(G, c);//对该元素定位 
        if (!visited[x]) {
        	cout << c << " "; visited[x] = true;//输出该元素 
	        for (int j = 1; j <= G.vexnum; ++ j) {
	        	if (G.arcs[x][j] && !visited[j]) {
	        		Q.push(G.vexs[j]);
                    //将该元素所有相关联的点入队
				}
			}
		}
    }
    return;
}

运行结果：

b2

1.3、Prim最小生成树

完整代码如下：

#include <bits/stdc++.h>

using namespace std;

const int MVNum = 500, MaxInt = 0x7fffffff;

typedef struct 
{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum, arcnum;

}AMGraph;

struct Node 
{
	char adjvex;
	int lowcost;
}closedge[MVNum];

int Locatevex(AMGraph G, char ch)
{
	for (int i = 1; i <= G.vexnum; ++ i) {
		if (G.vexs[i] == ch) return i;
	}
	return 0;
}

void CreatUDN(AMGraph &G)
{
	cout << "请输入点数目和边数：" << endl; 
    cin >> G.vexnum >> G.arcnum;
    char v1, v2; int w;
    cout << "请依次输入各个顶点编号 ：" << endl; 
    for (int i = 1; i <= G.vexnum; ++ i) cin >> G.vexs[i];
    for (int i = 1; i <= G.vexnum; ++ i) 
        for (int j = 1; j <= G.vexnum; ++ j) G.arcs[i][j] = MaxInt;//初始化无穷大 
    cout << "请输入两顶点，建立边关系 ：" << endl;  
    for (int i = 1; i <= G.arcnum; ++ i) {
        cin >> v1 >> v2 >> w;
        int x1 = Locatevex(G, v1);
        int x2 = Locatevex(G, v2);
        G.arcs[x1][x2] = G.arcs[x2][x1] = w;
    }
    return;
}

int Min(AMGraph &G)
{
    int res = MaxInt, x = 0;
    for (int i = 1; i <= G.vexnum; ++ i) {
        if (closedge[i].lowcost) {
            if (closedge[i].lowcost < res) {
                res = closedge[i].lowcost; x = i;
            }    
        }
    }
    return x;
}

void MiniSpanTree_Prim(AMGraph &G)
{
    int t = 0; char v;
    cout << "请输入出发点：" << endl; 
    cin >> v;
    int k = Locatevex(G, v); 
    for (int j = 1; j <= G.vexnum; ++ j) 
        if (j != k) {
        	 closedge[j].adjvex = v;
			 closedge[j].lowcost =  G.arcs[k][j];
		}

    closedge[k].lowcost = 0;

    for (int i = 1; i < G.vexnum; ++ i)
    {
        k = Min(G);

        char u0 = closedge[k].adjvex;
        char v0 = G.vexs[k];
        
        cout << u0 << ' ' << v0 << endl;

        closedge[k].lowcost = 0;
        for (int j = 1; j <= G.vexnum; ++ j) {
            if (G.arcs[k][j] < closedge[j].lowcost) {
            	closedge[j].adjvex = G.vexs[k];
            	closedge[j].lowcost = G.arcs[k][j];
			}
		}
    }
    
    return;
}

int main()
{
    AMGraph G;
    CreatUDN(G);
    
    MiniSpanTree_Prim(G);
    
    system("pause");

    return 0;
}
/*测试用例：
6 10
ABCDEF
A B 6
A D 5
A C 1
B C 5
B E 3
C D 5
C E 6
C F 4
D F 2
E F 6
*/

运行结果如下：

x1

二、邻接表表示法

2.1图的深度优先遍历

2.1.1 递归

  1. 从某点开始进行深度优先遍历
#include <bits/stdc++.h>

using namespace std;

const int MVNum = 500;
bool visited[MVNum];

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode * nextarc; 
}ArcNode;

typedef struct VNode
{
	char data;
	ArcNode * firstarc;
}VNode, AdjList[MVNum];

typedef struct
{
	AdjList vertices;
	int vexnum, arcnum;
}ALGraph;

int LocateVex(ALGraph G, char v)
{
	for (int i = 1; i <= G.vexnum; ++ i) {
		if (G.vertices[i].data == v) {
			return i;
		}
	}
	return 0;
}

void CreateUDG(ALGraph &G)
{
	cout << "请输入点数目和边数：" << endl; 
    cin >> G.vexnum >> G.arcnum;//输入顶点数目和边数，空格隔开 
    cout << "请依次输入各个顶点 ：" << endl; 
    for (int i = 1; i <= G.vexnum; ++ i) {
	    cin >> G.vertices[i].data;//依次输入各个顶点
	    G.vertices[i].firstarc = NULL;
    }
    char v1, v2;
    for (int k = 0; k < G.arcnum; ++ k) {
    	cin >> v1 >> v2;
    	int i = LocateVex(G, v1);
    	int j = LocateVex(G, v2);
    	ArcNode* p1 = new ArcNode;
    	p1->adjvex = j;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;
		
		ArcNode* p2 = new ArcNode;
    	p2->adjvex = i;
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;
	}
	return;
}

void DFS(ALGraph &G, char v)
{
	cout << v << ' ';
	int x = LocateVex(G, v);
	visited[x] = true;
	
	ArcNode* p = G.vertices[x].firstarc;
	while (p)
	{
		int k = p->adjvex;
		if (!visited[k]) DFS(G, G.vertices[k].data);
		p = p->nextarc;
	}
} 

int main()
{
	ALGraph G;
	CreateUDG(G);
	
    char v; cin >> v;//若为非连通图，则删此行，改DFS为DFS_ALL
    DFS(G, v);
	
	return 0;
}

运行结果如下：

b4

  1. 对于非连通图，DFS_ALL函数如下：
void DFS_ALL(ALGraph &G)
{
	for (int i = 1; i <= G.vexnum; ++ i) {
		if (!visited[i]) {
			DFS(G, G.vertices[i].data);
		}
	}
	return;
}

运行结果如下：

b3

2.1.2 非递归
  1. 从某点开始进行深度优先遍历
void DFS(ALGraph &G, char v)
{	
    stack <char> S;
	S.push(v);
	while (!S.empty()) 
	{
		char ch = S.top(); S.pop();
		int x = LocateVex(G, ch);
		
		if (!visited[x])
		{
			cout << ch << ' ';
		    visited[x] = true;
			ArcNode* p = G.vertices[x].firstarc;
			while (p)
			{
				int k = p->adjvex;
				if (!visited[k])
                    S.push(G.vertices[k].data);
				p = p->nextarc;
			}
		}
	}	
}

运行结果如下：

b5

  1. 对于非连通图，DFS_ALL函数完全同上

运行结果如下：

b6

2.2、图的广度优先遍历

将DFS非递归中栈改成队列即可，BFS函数如下：(从某点开始)

void BFS(ALGraph &G, char v)
{	
    queue <char> Q;
	Q.push(v);
	while (!Q.empty()) 
	{
		char ch = Q.front(); Q.pop();
		int x = LocateVex(G, ch);
		
		if (!visited[x])
		{
			cout << ch << ' ';
		    visited[x] = true;
			ArcNode* p = G.vertices[x].firstarc;
			while (p)
			{
				int k = p->adjvex;
				if (!visited[k])
                    Q.push(G.vertices[k].data);
				p = p->nextarc;
			}
		}
	}	
}

b7

2.3、Prim最小生成树

完整代码如下：

#include <bits/stdc++.h>

using namespace std;

const int MVNum = 500, MaxInt = 0x7fffffff;

typedef struct ArcNode
{
	int adjvex, weight;
	struct ArcNode * nextarc; 
}ArcNode;

typedef struct VNode
{
	char data;
	ArcNode * firstarc;
}VNode, AdjList[MVNum];

typedef struct
{
	AdjList vertices;
	int vexnum, arcnum;
}ALGraph;

struct Node 
{
	char adjvex;
	int lowcost;
}closedge[MVNum];

int LocateVex(ALGraph G, char ch)
{
	for (int i = 1; i <= G.vexnum; ++ i) {
		if (G.vertices[i].data == ch) return i;
	}
	return 0;
}

void CreateUDG(ALGraph &G)
{
	cout << "请输入点数目和边数：" << endl; 
    cin >> G.vexnum >> G.arcnum;//输入顶点数目和边数，空格隔开 
    cout << "请依次输入各个顶点 ：" << endl; 
    for (int i = 1; i <= G.vexnum; ++ i) {
	    cin >> G.vertices[i].data;//依次输入各个顶点
	    G.vertices[i].firstarc = NULL;
    }
    char v1, v2; int w;
    for (int k = 0; k < G.arcnum; ++ k) {
    	cin >> v1 >> v2 >> w;
    	int i = LocateVex(G, v1);
    	int j = LocateVex(G, v2);
    	ArcNode* p1 = new ArcNode;
    	p1->adjvex = j; p1->weight = w;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1; 
		
		ArcNode* p2 = new ArcNode;
    	p2->adjvex = i; p2->weight = w;
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;
	}
	return;
}

int Min(ALGraph &G)
{
    int res = MaxInt, x = 0;
    for (int i = 1; i <= G.vexnum; ++ i) {
        if (closedge[i].lowcost) {
            if (closedge[i].lowcost < res) {
                res = closedge[i].lowcost; x = i;
            }    
        }
    }
    return x;
}

void MiniSpanTree_Prim(ALGraph &G)
{
    int t = 0; char v;
    cout << "请输入出发点：" << endl; 
    cin >> v;
    int k = LocateVex(G, v); 
    for (int i = 1; i <= G.vexnum; ++ i) {
    	closedge[i].lowcost = MaxInt;
	}
    ArcNode *p = G.vertices[k].firstarc;
    while (p) {
    	closedge[p->adjvex].adjvex = v;
    	closedge[p->adjvex].lowcost = p->weight;
    	p = p->nextarc;
	}
    closedge[k].lowcost = 0;
    for (int i = 1; i < G.vexnum; ++ i)
    {
        k = Min(G);

        char u0 = closedge[k].adjvex;
        char v0 = G.vertices[k].data;
        
        cout << u0 << ' ' << v0 << endl;
        closedge[k].lowcost = 0;
        ArcNode *q = G.vertices[k].firstarc;
        while (q) {
        	if (q->weight < closedge[q->adjvex].lowcost)
        	{
        		closedge[q->adjvex].adjvex = G.vertices[k].data;
        		closedge[q->adjvex].lowcost = q->weight;
			}
			q = q->nextarc;
		}
    }
    
    return;
}

int main()
{
    ALGraph G;
    CreateUDG(G);
    
    MiniSpanTree_Prim(G);
    
    system("pause");

    return 0;
}
/*测试用例：
6 10
ABCDEF
A B 6
A D 5
A C 1
B C 5
B E 3
C D 5
C E 6
C F 4
D F 2
E F 6
*/

运行结果如下：

x2

THEEND…

@Aurora,
关注
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
[数据结构]--图(图的遍历,最小生成树,最短路径算法)
lgxzzz的博客
05-16 675
前言 在这里,如果大家对图或者数据结构还不太熟悉,想找一个动态的生成过程来参考,这是一个不错的网站. 知识框架 图的定义 在线性结构中，数据元素之间满足唯一的线性关系，每个数据元素(除第一个和最后一个外)只有一个直接前趋和一个直接后继； 在树形结构中，数据元素之间有着明显的层次关系，并且每个数据元素只与上一层中的一个元素(双亲节点)及下一层的多个元素(孩子节点)相关； 而在图形结构中，节点之间的...
【图】图的遍历以及最小生成树
菜鸟成长记
07-31 2982
图的遍历图的遍历图和树的遍历类似，那就是从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这个过程就叫做图的遍历。对于图的遍历来说，如何避免因回路陷入死循环，就需要科学地设计遍历方案，通过有两种遍历次序方案：深度优先遍历和广度优先遍历。1、深度优先遍历 DFS深度优先遍历（Depth_First_Search）,也称为深度优先搜索，简称DFS。沿着树的深度遍历树的节点，尽可能深的搜索树
图的遍历和最小生成树
bingweiyuan的博客
08-06 325
图的遍历
数据结构和算法系列17 图
weixin_30572613的博客
09-23 211
这一篇我们要总结的是图(Graph)，图可能比我们之前学习的线性结构和树形结构都要复杂，不过没有关系，我们一点一点地来总结，那么关于图我想从以下几点进行总结： 1，图的定义？ 2，图相关的概念和术语？ 3，图的创建和遍历？ 4，最小生成树和最短路径？ 5，算法实现？ 一，图的定义 什么是图呢？ 图是一种复杂的非线性结构。 在线性结构中，数据元素之间满足唯一的线性关系，每...
数据结构：图（图的遍历、最小生成树、最短路径）
燕双嘤
12-06 5611
1，图的遍历 和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中所有顶点各作一次访问。若给定的图是连通图，则从图中任一顶点出发顺着边可以访问到该图中所有的顶点，但是，在图中有回路，从图中某一顶点出发访问图中其它顶点时，可能又会回到出发点，而图中可能还剩余有顶点没有访问到，因此，图的遍历较树的遍历更复杂。我们可以设置一个全局型标志数组visited来标志某个顶点是否被访问过，未访问的值为0，访问过的值为1。根据搜索路径的方向不同，图的遍历有两种方法：深度优先搜索遍历（DFS）和广度优先搜索
代码 最小生成树Prim算法代码
06-04
代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小...
JS使用Prim算法和Kruskal算法实现最小生成树
10-17
Prim算法是由Vojtěch Jarník提出，后由Robert Prim推广的贪心算法，其核心思想是从图中某个顶点开始，逐步增加边和顶点，直到构建出最小生成树。在实现时，Prim算法使用一个优先队列来选取当前未包含在生成树中的...
图的遍历和最小生成树求解
09-24
采取随机生成顶点数和边数构造无向图，并对图进行深度优先搜索和广度优先搜索，并采用PRIM算法和狄杰斯特拉算法求图的最小生成树。
最小生成树算法之Prim算法
09-03
最小生成树算法是图论中的一个经典问题，其目标是在给定的加权无向连通图中找到一棵包括所有顶点的树，使得树中所有边的权重之和最小。Prim算法是一种解决这一问题的有效方法，尤其适用于稠密图。 1. **最小生成树...
图的操作（遍历，最小生成树等操作）
12-12
数据结构上的图的操作代码
无向图，邻接链表存储，prim算法实现最小生成树，深度优先搜索，广度优先搜索。
啥都不会的博客
09-04 957
仅实现算法过程，对输入未监测 //#include&lt;iostream&gt; #include&lt;SqQueue.h&gt; #include&lt;climits&gt; //using namespace std; const int MaxVectices = 100; typedef int VerT; typedef int DisT; //----------------...
数据结构之图的遍历和最小生成树
成长日记的博客
03-14 591
图的遍历有两种方式 深度优先搜索：先选定一个点，从选定的点向下遍历直到与已经遍历的点形成环或者是没有点可以遍历，再对选定的点没有被遍历的点进行相同的操作 广度优先搜索：按层从左至右遍历 最小生成树算法：普里姆（Prim）算法、克鲁斯卡尔（Kruskal）算法 普里姆（Prim）算法： 第一步找到点A，与A相连的所有边进入待选边集合选出最小的进入边集合 第二步选定...
图的遍历及最小生成树（prim，kruskal）的实现
luoluozlb
08-13 1758
关于图的介绍网上很多，这里就不介绍了，直接上代码： 最小生成树算法可以看看：http://www.cnblogs.com/biyeymyhjob/archive/2012/07/30/2615542.html#include <iostream> #include <iomanip> #include <climits> #include <queue> using namespace std;#
图：图的遍历和最小生成树
weixin_36049506的博客
03-09 651
文章目录图的遍历深度优先搜索广度优先搜索（连通网的）最小生成树算法一：普里姆算法（加点法）算法二：克鲁斯卡尔算法（加边法） 图的遍历 深度优先搜索 sg1和sg2有交叉？没有交叉就是树了 　 　 　根据访问路径可以构造一棵深度优先生成树 广度优先搜索 （连通网的）最小生成树 问题： 假设要在n个城市之间建立通讯联络网，则连通n个城市只需要修建n-1条线路，如何在最节省经...
最小生成树和图的遍历
百年一梦
09-27 4090
Prim算法 1.概览 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗
图的遍历与最小生成树
热门推荐
HHHHHHep的博客
12-20 1万+
2-1     解析 ： 根据矩阵直接选边即可。 2-1 给定有权无向图的邻接矩阵如下，其最小生成树的总权重是：(3分) 2220158 作者: 陈越 单位: 浙江大学 2-2 给定有权无向图的邻接矩阵如下，其最小生成树的总权重是：(3分) 2022815 作者: 陈越 单位: 浙
【数据结构】图的遍历及最小生成树
Cheng_913的博客
05-02 1876
上一篇博客中讲了图的基本概念及如何存储，下面学习图的遍历及最小生成树的问题。 图的遍历 广度优先搜索(Breadth First Search, BFS) 举一个例子： 　　假设我们都从顶点A开始遍历，左侧为有向图，它的广度优先搜索结果为：A D B E C；右侧为无向图，它的广度优先搜索结果为：A E D B C。 广度优先搜索类似于树的层序遍历，在实现的时候，需要借助队列...
C++实现Kruskal与Prim最小生成树算法
本资源包含两个常用的算法实现，即Kruskal算法和Prim算法，用于在C++环境中构建最小生成树。这两种算法都是解决工程造价最小化问题的有效工具，例如在城市交通网络规划中，通过找到最低成本的连接方式来构建网络。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值