图（4）——最短路径

最新推荐文章于 2022-11-22 21:53:23 发布
最新推荐文章于 2022-11-22 21:53:23 发布
阅读量351 收藏
点赞数
分类专栏： 基础数据结构与算法 基础数据结构与算法 文章标签： 数据结构 内存 性能 class 实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21916897/article/details/72716776
版权

最短路径

找到从一个顶点到另一个顶点的成本最小的路径。
定义 ：在一幅加权有向图中，从顶点S到顶点t的最短路径是所有从s到t的路径中的权重最小者。

最短路径的性质：

1.路径是有方向的。
2.权重不一定等价于距离。
3.并不是所有顶点都是可达的。
4.负权重会使问题更复杂。
5.最短路径一般哦都是简单的。（忽略0权重边，即没有环）
6.最短路径不一定是唯一的。
7.可能存在平行边和自环。（平行边中的权重最小者才会被选中，最短路径也不可能包含自环）

最短路径树：以S为根结点，树的每条路径都是有向图中的一条最短路径。

加权有向图的数据结构：

1.加权有向边：

代码： 
#ifndef DEDGE_H
#define DEDGE_H
#include<sstream>
#include<string>
using namespace::std;

class DEdge
{
private:
	int v;//起点
	int w;//终点
	double weight;//权重
public:
	DEdge(){}
	DEdge(int v, int w, double weight) :v(v), w(w), weight(weight){}

	bool operator<(const DEdge&itr)const
	{
		return weight < itr.weight;
	}
	bool operator>(const DEdge&itr)const
	{
		return weight > itr.weight;
	}
	bool operator==(const DEdge&itr)const
	{
		return weight == itr.weight;
	}
	bool operator!=(const DEdge&itr)const
	{
		return weight != itr.weight;
	}
	bool operator<=(const DEdge&itr)const
	{
		return !(weight > itr.weight);
	}
	bool operator>=(const DEdge&itr)const
	{
		return !(weight < itr.weight);
	}

	double getweight(){ return weight; }
	int from(){ return v; }
	int to(){ return w; }
	string tostring()
	{
		string s1, s2;
		stringstream stream;
		stream << v << "-" << w << ":";
		stream >> s1;
		stream.clear();
		stream << weight << endl;
		stream >> s2;
		return s1 + s2;
	}
};
#endif

2.加权有向图：

代码： 
#ifndef EDGEDIGTAPH_H
#define EDGEDIGRAPH_H

#include<vector>
using std::vector;
#include"DEdge.h"
#include"Bag.h"

class EdgeDigraph
{
private:
	int V;//顶点的总数
	int E;//边的总数
	vector<Bag<DEdge>> adj;//；邻接表
public:
	EdgeDigraph(int V) :V(V), E(0), adj(V){}
	EdgeDigraph(int V, int E) :V(V), E(0), adj(V)
	{
		int v, w;
		double weight;
		for (int i = 0; i < E; i++)
		{
			cout << "输入第" << i << "条边的两个顶点和权重:" << endl;
			cin >> v >> w >> weight;
			DEdge e(v, w, weight);
			addEdge(e);
		}
	}
	int getV(){ return V; }
	int getE(){ return E; }
	void addEdge(DEdge e)
	{
		adj[e.from()].add(e);
		E++;
	}
	Bag<DEdge> getadj(int V){ return adj[V]; }
	Bag<DEdge> edges()
	{
		Bag<DEdge> b;
		for (int v = 0; v < V; v++)
			for (auto e : adj[v])
				b.add(e);
		return b;
	}
};
#endif


测试用例： 
#include<iostream>
#include"EdgeDigraph.h"
using namespace std;
int main()
{
	int n, m;
	cout << "输入图的顶点数和边数:" << endl;
	cin >> n >> m;
	EdgeDigraph G(n, m);
	Bag<DEdge> b=G.edges();
	for (auto w : b)
		cout << w.tostring() << endl;
	cout << endl;
	system("pause");
	return 0;
}


最短路径算法：

1.最短路径需要的工具

1）edgeTo[ ]：最短路径树中的边；（每个结点都储存他来时的路径）
2）distTo[ ]：到达起点的距离（权重和）；
3）约定：s为起点，edgeTo[s]=NULL,disTo[s]=0,且起点到不可达顶点为DBL_MAX;
4）松弛：放松边v->w意味着检查从s到w的最短路径是否是先从s到v，然后再由v到w。
点的松弛： 
void relax(EdgeDigraph G, int v)
	{
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.getweight())//e这条边，是不是已知到w的边中最短的
			{
				distTo[w] = distTo[v] + e.getweight();
				edgeTo[w] = e;
			}
		}
	}


2.Dijkstra算法：（类似Prim）

与算法prim大至相似，只是prim每次都添加的都是离树最近的非树顶点，Dijkstra每次添加的都是里起点最近的非树顶点。他们都不需要marked[ ]数组，因为条件!marked[w]等价于distTo[w]为无穷大。
代码： 
#ifndef DIJKSTRASP_H
#define DIJKSTRASP_H

#include<vector>
using std::vector;
#include"EdgeDigraph.h"
#include"DEdge.h"
#include"IndexMinPQ.h"
#include"stack.h"

class DijkstraSP
{
private:
	vector<DEdge> edgeTo;//最短路径树的边
	vector<double> distTo;//到底起点的距离
	IndexMinPQ<double> pq;
	int s;//起点
	void relax(EdgeDigraph G, int v)
	{
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.getweight())//e这条边，是不是已知到w的边中最短的
			{
				distTo[w] = distTo[v] + e.getweight();
				edgeTo[w] = e;
				if (pq.contains(w))pq.change(w, distTo[w]);
				else pq.insert(w, distTo[w]);
			}
		}
	}
public:
	DijkstraSP(EdgeDigraph G, int s) :edgeTo(G.getV()),
		distTo(G.getV(), DBL_MAX), pq(G.getV()), s(s)
	{
		distTo[s] = 0.0;
		pq.insert(s, 0.0);
		while (!pq.Empty())
			relax(G, pq.delMin());
	}
	double getdistTo(int v){ return distTo[v]; }//查询顶点到v的最小距离
	bool hasPathTo(int v){ return distTo[v] < DBL_MAX; }//顶点与v是否可达
	stack<DEdge> pathTo(int v)//输出到v的路径
	{
		stack<DEdge> path;
		if (!hasPathTo(v)||v==s)return path; 
		DEdge e;
		for ( e = edgeTo[v]; e.from() != s; e = edgeTo[e.from()])
			path.push(e);
		path.push(e);
		return path;
	}
};
#endif


测试用例： 
#include<iostream>
using namespace std;
#include"DijkstraSP.h"

int main()
{
	int n, m;
	cout << "输入图的顶点数和边数:" << endl;
	cin >> n >> m;
	EdgeDigraph G(n, m);
	DijkstraSP Sp(G, 0);
	for (int t = 0; t < G.getV(); t++)
	{
		stack<DEdge> b = Sp.pathTo(t);
		cout << 0 << " to " << t << "(" << Sp.getdistTo(t) << "): " << endl;
		for (auto w : b)
			cout << w.tostring() << endl;
		cout << endl;
	}
	system("pause");
	return 0;
}


3.无环加权有向图的最短路径算法

他是对于拓扑排序的扩展，有以下几个特点：
1）能够在线性时间内解决单点最短路径问题；
2）能够处理负权重问题；
3）能够解决相关问题，（最长路径）
具体步骤就是：先拓扑排序顶点，然后再按照顺序放松顶点。
在拓扑排序中需要使用到DepthFirstOther和DirectedCycle算法，因为边的数据结构有改动所以需要两个代码也需要变动： 
#ifndef DC_H
#define DC_H

#include<vector>
using std::vector;

#include"stack.h"
class DirectedCycle
{
private:
	vector<bool> marked;
	vector<DEdge> edgeTo;//来时的路径
	stack<DEdge> cycle;//有向环中的边
	vector<bool> onstack;//递归调用所有栈上的顶点
public:
	DirectedCycle(EdgeDigraph G) :
		marked(G.getV()), edgeTo(G.getV()), onstack(G.getV())
	{
		for (int v = 0; v < G.getV(); v++)
			if (!marked[v])dfs(G, v);
	}
	void dfs(EdgeDigraph G,int v)
	{
		onstack[v] = true;
		marked[v] = true;
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (hasCycle())return;
			else if (!marked[w])
			{
				edgeTo[w] = e;//记录来时的路径
				dfs(G, w);
			}
			else if (onstack[w])//在次出现该结点，说明有该结点的环
			{//逆序追踪到上一次出现该结点的地点
				while (e.from() != w)
				{
					cycle.push(e);
					e = edgeTo[e.from()];
				}
				cycle.push(e);
			}
		}
		onstack[v] = false;
	}
	bool hasCycle(){ return !cycle.isEmpty(); }
	stack<DEdge> getcycle(){return cycle;}
};
#endif
#ifndef DFO_H
#define DFO_H

#include<vector>
using std::vector;


#include"stack.h"
#include"queue.h"

class DepthFirstOther
{
private:
	vector<bool> marked;
	queue<int> pre;//先序
	queue<int> post;//后序
	stack<int> reversepost;//逆后序
public:
	DepthFirstOther(EdgeDigraph G) :marked(G.getV())
	{
		for (int v = 0; v < G.getV(); v++)
			if(!marked[v])dfs(G, v);
	}
	void dfs(EdgeDigraph G, int v)
	{
		pre.enqueue(v);
		marked[v] = true;
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (!marked[w])dfs(G, w);
		}
		post.enqueue(v);
		reversepost.push(v);
	}
	queue<int> getpre(){ return pre; }
	queue<int> getpost(){ return post; }
	stack<int> getreversepsot(){ return reversepost; }
};
#endif
代码： 
#ifndef ACYCLICSP_H
#define ACYCLICSP_H

#include<vector>
using std::vector;

#include"Topological.h"

class AcyclicSP
{
private:
	vector<DEdge> edgeTo;//来时的路径
	vector<double> distTo;//到起点的距离
	int s;//起点
	void relax(EdgeDigraph G, int v)
	{
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.getweight())
			{
				distTo[w] = distTo[v] + e.getweight();
				edgeTo[w] = e;
			}
		}
	}
public:
	AcyclicSP(EdgeDigraph G, int s) :edgeTo(G.getV()), distTo(G.getV(),DBL_MAX), s(s)
	{
		distTo[s] = 0.0;//初始化
		Topological top(G);
		for (int v : top.getorder())
			relax(G, v);
	}
	double getdistTo(int v){ return distTo[v]; }
	bool hasPathTo(int v){ return distTo[v] < DBL_MAX; }
	stack<DEdge> pathTo(int v)//输出到v的路径
	{
		stack<DEdge> path;
		if (!hasPathTo(v) || v == s)return path;
		DEdge e;
		for (e = edgeTo[v]; e.from() != s; e = edgeTo[e.from()])
			path.push(e);
		path.push(e);
		return path;
	}
};
#endif


测试用例： 
#include<iostream>
using namespace std;
#include"EdgeDigraph.h"
#include"Acyclicsp.h"
//#include"DijkstraSP.h"
int main()
{
	int n, m;
	cout << "输入图的顶点数和边数:" << endl;
	cin >> n >> m;
	EdgeDigraph G(n, m);
	AcyclicSP Sp(G, 0);
	for (int t = 0; t < G.getV(); t++)
	{
		stack<DEdge> b = Sp.pathTo(t);
		cout << 0 << " to " << t << "(" << Sp.getdistTo(t) << "): " << endl;
		for (auto w : b)
			cout << w.tostring() << endl;
		cout << endl;
	}
	system("pause");
	return 0;
}
而求最长路径就十分简单了，只需要把代码中DBL_MAX改为DBL_MIN，以及relax()中不等式的方向改变即可。

4.基于队列的Bellman-Ford算法（不存在负权重环）

一般加权有向图中的最短路径问题，也就是可能含有负权重和环的图。
负权重环：是一个总权重为负的有向环。
当且仅当加权有向图中至少存在一条从s到v的有向路径且所有从s到v的有向路径上的任意顶点都是不存在于任何负权重环中时，s到v的最短路径才是存在的。
也就是说我们需要在Dijkstra算法的基础上确定是否负权重环。

需要的数据结构：
1）一条用来保存即将被放松的顶点的队列queue；
2）一个由顶点索引的bool数组onQ[ ]，用来指示顶点是否已经在队列中。

代码： 
#ifndef BfSP_H
#define BFSP_H

#include<vector>
using std::vector;
#include"DEdge.h"
#include"queue.h"
#include"stack.h"
#include"DirectedCycle.h"

class BellmanFordSP
{
private:
	vector<double> distTo;//到起点的距离
	vector<DEdge> edgeTo;//来时的路径
	vector<bool> onQ;//顶点是否存在于队列中
	queue<int> queue;//正在被放松的顶点
	int cost;//relax()的调用次数
	stack<DEdge> cycle;//负权重环
	int s;//起点
public:
	BellmanFordSP(EdgeDigraph G, int s) :distTo(G.getV(),DBL_MAX), 
		edgeTo(G.getV()), onQ(G.getV()), s(s),cost(1)
	{
		distTo[s] = 0.0;
		queue.enqueue(s);
		onQ[s] = true;
		while (!queue.Empty() && !hasNegativeCycle())//放松队列不为空且没有负权重环
		{
			int v = queue.dequeue();
			onQ[v] = false;
			relax(G, v);
		}
	}
	double getdistTo(int v){ return distTo[v]; }
	bool hasPathTo(int v){ return distTo[v] < DBL_MAX; }
	stack<DEdge> pathTo(int v)//输出到v的路径
	{
		stack<DEdge> path;
		if (!hasPathTo(v) || v == s)return path;
		DEdge e;
		for (e = edgeTo[v]; e.from() != s; e = edgeTo[e.from()])
			path.push(e);
		path.push(e);
		return path;
	}
private:
	void relax(EdgeDigraph G, int v)//放松
	{
		for (auto e : G.getadj(v))
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.getweight())
			{
				distTo[w] = distTo[v] + e.getweight();
				edgeTo[w] = e;
				cout << edgeTo[w].tostring() << endl;
				if (!onQ[w])
				{
					queue.enqueue(w);
					onQ[w] = true;
				}
				if (cost++ %G.getV() == 0)findNegativeCycle();//当cost走过一轮后，查看路径中是否有负权重环
			}
		}
	}
	void findNegativeCycle()//检测路径中是否有负权重环
	{
		cout << "1" << endl;
		int V = edgeTo.size();
		EdgeDigraph spt(V);
		for (int v = 0; v < V; v++)
			if (v != s)spt.addEdge(edgeTo[v]);
		DirectedCycle cy(spt);//检测存储路径中是否有环
		double ws=0;
		cout << "3" << endl;
		for (auto e : cy.getcycle())
			ws += e.getweight();//计算环的权重
		if (ws < 0)cycle = cy.getcycle();
		cout << "4" << endl;
	}
public:
	bool hasNegativeCycle(){ return !cycle.isEmpty(); }
	stack<DEdge> negativeCycle(){ return cycle; }
};
#endif

测试用例： 
#include<iostream>
using namespace std;
#include"EdgeDigraph.h"
#include"BellmanFordSP.h"
int main()
{
	int n, m;
	cout << "输入图的顶点数和边数:" << endl;
	cin >> n >> m;
	EdgeDigraph G(n, m);
	BellmanFordSP Sp(G, 0);
	if (Sp.hasNegativeCycle())cout << "存在负权重环" << endl;
	cout << "不存在负权重环" << endl;
	for (int t = 0; t < G.getV(); t++)
	{
		stack<DEdge> b = Sp.pathTo(t);
		cout << 0 << " to " << t << "(" << Sp.getdistTo(t) << "): " << endl;
		for (auto w : b)
			cout << w.tostring() << endl;
		cout << endl;
	}
	system("pause");
	return 0;
}

比较三种算法

最短路径算法的性能特点：
算法局限比较次数（一般）比较次数（最坏）所需空间优势
Dijkstra（即时）边的权重必须为正ElogVElogVV最坏情况下性能也较好
拓扑排序只适用于无环加权图E+VE+VV是无环图的最优算法
Bellman-Fond不能存在负权重环E+VVEV适用领域广泛
叙狼烟
关注
专栏目录
图（五）：最短路径
jiangxt211的专栏
03-06 500
定义：在一幅加权有向图中，从顶点s到顶点t的最短路径是所有从s到t的路径中权重最小者。 （单源最短路径、单终点最短路径、单对顶点最短路径、每对顶点最短路径）引理：最短路径的子路径是最短路径。 当且仅当加权有向图中至少存在一条从s到v的有向图路径且所有从s到v的有向路径上的任意顶点都不存在于任何负权重环中时，s到v的最短路径才是存在的。 松弛（relaxation）操作 Bellman-Ford...
最短路径
能能
11-14 1222
最短路径 定义：在一幅加权有向图中，从顶点 s 到顶点 t 的最短路径是所有从 s 到 t 的路径中的权重最小者。 单点最短路径： 给定一幅加权有向图和一个起点s，回答 “从s到给定的目标顶点v是否存在一条有向路径？如果有，找出最短（总权重最小）的那条路径。” 最短路径的性质 路径是有向的。 权重不一定等价于距离。 并不是所有顶点都是可达的。（为了简化问题，假定图是强连通的，即每个顶点从另外任意...
poj-1024(唯一最短路径)（转）
dmt26374的博客
05-21 249
题意： /*** (1)求各点到源点的最小步数（DFS）* (2)求各点到终点的最小步数（DFS）* (3)如果点不是给定路径上的点，那么：该点到源点的最小步数＋该点到终点的最小步数<=给定路径的步数，否则给定路径不是唯一最短的* (4)如果两相邻点a、b之间存在墙，那么：a到源点的最小步数＋1＋b到终点的最小步数<=给定路径的步数*...
最短路不唯一，枚举与计数
SongyangJi
02-19 412
文章目录最短路唯一的路径记录最短路不唯一枚举所有的最短路计数 最短路唯一的路径记录 核心就是维护一个 f[]数组，用来记录f[v]=u,也就是v的上一个节点是u。 最后既可以递归打印，也可以存进vector,最后循环输出。 /* for(int y=1;y<=n;y++){ d[y]=min(d[y],d[x]+a[x][y]); //必须是a[x...
最短路径(加权有向图)
一名小白的博客
08-28 4748
最短路径 1. 最短路径定义以及性质 定义： 在一副加权有向图中，从顶点s到顶点t的最短路径是所有从顶点s到顶点t的路径中总权重最小的那条路径。 性质： 路径具有方向性。 权重不一定等于距离。权重可以是距离、时间、花费等内容，权重最小指的是成本最低。 只考虑连通图。一副图中并不是所有的顶点都是可达的，如果s和t不可达，那么它们之间也就不存在最短路径，所以只考虑连通图。 最短路径不一定是唯一的。从一个顶点到达另外一个顶点的权重最小的路径可能会有很多条，所以只需要找出一条即可。 最短路径树： 给定一副加权
图算法——求最短路径（Dijkstra算法）
热门推荐
在夜里行走的博客
11-22 9万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
无人驾驶汽车系统入门——最短路径搜索之A*算法
02-24
最短路径搜索是通过算法找到一张图从起点（start）到终点（goal）之间的最短路径（path），为了简化，我们这里使用方格图（该图可以简单地用二维数组来表示），如下动图所示，其中代表起点，代表终点。广度优先算法...
贪心算法——最短路径算法.rar
05-02
在有向图或无向图中，该算法能找出从起点到其余所有节点的最短路径。它的工作原理是基于贪心策略：每次选择当前未访问节点中距离起点最近的一个，并更新与之相邻节点的距离。 Dijkstra算法的基本步骤如下： 1. ...
将军饮马——最短路径问题教学设计.doc
11-20
【将军饮马——最短路径问题教学设计】 教学设计的核心在于教授如何解决“最短路径问题”，这是一个在生产和生活中常见的优化问题。初中阶段，学生已掌握基础的几何知识，如“两点之间，线段最短”和“垂线段最短”...
遗传算法——最短路径问题
04-30
在这个特定的案例中，我们关注的是应用遗传算法解决9个城市之间的最短路径问题。这个问题是一个典型的图论问题，通常用在物流、交通规划或网络设计等领域。 首先，我们需要理解“基因库”在这个问题中的含义。基因...
单源最短路径
Mr_Avin的博客
03-01 1825
在最短路径问题中，给定一个带权重的有向图G=(V,E)和权重函数w：E→R，该权重函数将每条边映射到实数值的权重上。图中一条路径p=[v0,v1,•••,vk]的权重w(p)是构成该路径的所有边的权重之和。定义从结点u到结点v的最短路径权重δ=(u,v)，从结点u到结点v的最短路径则定义为任何一条权重w(p)= δ=(u,v)的从u到v的路径p。
最短路径树
细雨欣然
07-17 1608
【问题描述】 　　所谓最短路径树，就是从s出发，沿着树上的边走到任意点i，那么经过的这些边的权值和就是s到i的最短路径。Dijkstra算法或SPFA算法不仅可计算从起点s到各点的最短路径长度，同时也可得到以s为根的最短路径树。方法是在进行松弛操作时，如果d[i] + c < d[j] 时，除了更新d[j]之外，还要设置fa[j]=i。这样把fa[j]看成j的父亲指针，则所有点形成了一棵树（因为每
最短路径，最短路径树和最小生成树
annie_ooo的博客
06-07 1万+
       首先介绍这三个概念，很多人都听过最短路径了，但是最短路径树却很少听过，关于最短路径树的介绍也不太多。而最短路径树和最小生成树更是完全不同的两个概念。       最短路径就是从一个指定的顶点出发，计算从该顶点出发到其他所有顶点的最短路径。通常用Dijkstra算法，Floyd算法求解。      最短路径树SPT（Short Path Tree）是网络的源点到所有结点的最短路径构成的...
从最小支撑树和最短路径树学习图的优先级搜索
不能说的秘密的博客
12-17 2839
前面笔者介绍了图的广度优先搜索算法和图的深度优先搜索。这两种搜索虽然各有特点，但基本结构却几乎相同。都需要通过迭代逐一发现各顶点，将其归纳到遍历树中做相应的处理。两种算法的唯一差别在于，如何选取下一个节点的问题。如果将选取下一节点的策略抽象为获取优先级最高的节点，则对于BFS或是DFS则可统一处理，他们的区别仅在于更新节点的优先级的策略不同而已。根据优先级来遍历，称为优先级搜索。
数据结构迭代器的构造
叙以流火述烽烟丶
05-19 1247
数据结构迭代器的构造 一般情况下链表的遍历是通过指针的移动来寻找下一个结点，并输出数据的。 但是在数据结构的设定中，结点都是被设为private的，也就是说我们无法在链表以外对链表元素进行逐个处理的，也就是说在对图中链表元素进行分类处理是很不方便的，所以为了比面这种情况，我们将为链表构造迭代器，用来处理链表元素。 实现： 链表迭代器的实现，便是用指针模拟正常的循环，所以我们需要： 1.构
图（2）——有向图
叙以流火述烽烟丶
05-20 1187
有向图
字符串（1）——字符串排序
叙以流火述烽烟丶
05-27 1129
字符串排序 无数的重要领域都是基于字符串处理的。 字母表
图（1）——无向图
叙以流火述烽烟丶
05-17 988
无向图 术语表 图：由一组顶点个一组能够将两个顶点相连的边组成。 自环：一条连接一个顶点和其自身的边。 平行边：连接同一对顶点的两条边称为平行边。 多重图：含有平行边。 简单图：没有平行边和自环。 相邻：两个顶点通过一条边相连，并称这条边依附这两个顶点。 顶点的度数：依附于他的边的数量。 子图：一幅图的所有边的一个子集（以及所依附的所有顶点）组成的图。 路径：由边顺序连接的一系
迪杰斯特拉算法——最短路径算法python
最新发布
10-27
迪杰斯特拉算法是一种解决有向图中最短路径问题的算法。下面是使用Python实现迪杰斯特拉算法的步骤： 1. 创建一个空的字典dist，用于存储每个顶点到源点的距离，初始值为无穷大。 2. 将源点的距离设置为0，并将源点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值