【算法】最短路径算法汇总

最新推荐文章于 2022-12-27 18:14:41 发布
最新推荐文章于 2022-12-27 18:14:41 发布
阅读量979 收藏 6
点赞数 3
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41139677/article/details/119917034
版权

最短路径算法

写在前面

单源最短路径算法顾名思义就是一个顶点到其他顶点的最短路径的距离。其中比较著名的算法有基于贪心思想的Dijkstra算法，基于动态规划思想的Floyd算法(多源最短路径)、Bellman-Ford算法。还有基于这些算法的时间复杂度优化算法等等。

松弛操作

在一个含有 n n n个顶点的图中，任意两点之间的最短路径最多包含 n − 1 n-1 n−1条边，最短路径中不可能包含回路。因为最短路径是一个不包含回路的简单路径，回路分为正权回路(回路权值之和为正)和负权回路(回路权值之和为负)。如果最短路径中包含正权回路，那么去掉这个回路，一定可以得到更短的路径；
如果最短路径中包含负权回路，那么肯定没有最短路径，因为每多走一次负权回路就可以得到更短的路径. 因此最短路径肯定是一个不包含回路的最短路径，即最多包含 n − 1 n-1 n−1条边。对于边 3 → 2 3\rightarrow2 3→2，它可以使 3 → 1 3\rightarrow1 3→1变成 3 → 2 → 1 3\rightarrow2\rightarrow1 3→2→1，从而使其距离变短，此过程称为松弛。（松弛点数，拉紧距离）即 w [ 3 → 2 ] + w [ 2 → 1 ] < w [ 3 → 1 ] w[3\rightarrow2]+w[2\rightarrow1]<w[3\rightarrow1] w[3→2]+w[2→1]<w[3→1]

三种算法的适用范围

单源最短路径有向图&无向图边权正负性时间复杂度其他
Dijkstra算法✔✔正 O ( n 2 ) O(n^2) O(n2)
Floyd算法多源✔可正可负 O ( n 3 ) O(n^3) O(n3)任意两点之间的最短路径，负权图
Bellman-Ford算法✔✔可正可负 O ( n m ) O(nm) O(nm)单源最短路径，负权图，判断负权环

算法描述

基本数据结构

struct Edge
{
	int from, to, dist;//起始点,终点,两点距离（权值）
	Edge(int u, int v, int w) :from(u), to(v), dist(w) {}//构造函数,初始化,类比class
};//定义边结构体

struct HeapNode
{
	int dist, u;//权值,起点
	bool operator < (const HeapNode &node) const
	{
		return dist > node.dist;//最小值优先
	}
};

朴素Dijkstra算法

主要利用贪心的思想不断加入距离邻近的顶点，利用松弛操作不断更新源点到各个顶点的距离。

/*朴素Dijstra算法*/
void Simple_Dijstra(int u0)//u0为源点
{
	memset(final, false, sizeof(final));
	for (int i = 1; i <= n; i++)
		D[i] = INF;
	D[u0] = 0;//源点到自身的距离为0
	final[u0] = true;
	for (int i = 0; i < G[u0].size(); i++)
	{
		Edge &e = edges[G[u0][i]];//引用,起别名
		D[e.to] = min(e.dist, D[e.to]);
	}
	for (int i = 0; i < n; i++)//求最短路径,时间复杂度为O(nm)
	{
		int v0 = 0;
		int Min = INF;
		for (int j = 0; j < n; j++)
			if (!final[j] && D[j] < Min)
			{
				Min = D[j];
				v0 = j;
			}
		final[v0] = true;//目的点
		/*更新当前最短距离D[],即松弛relax操作*/
		for (int k = 0; k < G[v0].size(); k++)
		{
			Edge &e = edges[G[v0][k]];
			if (!final[e.to] && e.dist + Min < D[e.to])
				D[e.to] = e.dist + Min;
		}
	}
}

优先队列(堆)优化的Dijstra算法

Dijstra的思想是每次在dist里面找到最小的那一条边，然后用最小的那条边去松弛其他的边，在此将dist存在priority_queue里面，每次通过优先队列得到dist最小的那条边,然后通过邻接表去松弛与这条边相连的其他的边，再将更新的dist存入优先队列，直到队列空时结束。

void Priority_queue_Dijstra(int u0)
	{  
		memset(final, false, sizeof(final));
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		priority_queue<HeapNode>pq;
		D[u0] = 0;
		pq.push(HeapNode { 0, u0 }); //源点对应的权值和from点进队列
		while (!pq.empty())//求最短路径,O(nlogn);
		{
			HeapNode node = pq.top();
			pq.pop();
			int u = node.u;
			if (final[u])continue;
			final[u] = true;
			for (int i = 0; i < G[u].size(); i++)
			{
				Edge &e = edges[G[u][i]];
				if (D[e.to] > D[u] + e.dist)
				{
					D[e.to] = D[u] + e.dist;
					pq.push(HeapNode { D[e.to],e.to });
				}
			}
		}
	}

Bellman-Ford算法

原理是对图进行最多V-1次松弛操作,得到所有可能的最短路径。优于迪科斯彻算法的方面是边的权值可以为负数、实现简单,缺点是时间复杂度过高,高达O(VE)。但算法可以进行若干种优化,提高了效率。
思路上与Dijkstra算法最大的不同是每次都是从源点u0重新出发进行"松弛"更新操作,而Dijkstra则是从源点出发向外扩逐个处理相邻的节点，不会去重复处理节点，这边也可以看出Dijkstra效率相对更高点。

判断图中是否存在负环路，但存在负环路的情况下不支持计算出各个节点的最短路径。只需要在结束(n-1)次遍历后,再执行一次遍历,若还可以更新数据则说明存在负环路(如果一个图没有负权回路，那么最短路径所包含的边最多为n-1条，即进行n-1轮松弛操作后最短路不会再发生变化。如果在n-1轮松弛后最短路仍然可以 发生变化，则这个图一定有负权回路)

  • 注意，代码中有一处注释部分，该部分其实是一个时间优化的小trick。
bool Bellman_Ford(int u0)
	{
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		D[u0] = 0;
		bool neg_loop = false;//判断有无负权环
		//bool flag = false;//判断D[]是否已经都为确定值

		//进行n-1次松弛操作O(nm)
		for (int i = 0; i < n - 1; i++)
		{
			for (int j = 0; j < edges.size(); j++)
			{
				Edge &e = edges[j];
				D[e.to] = min(D[e.from] + e.dist, D[e.to]);
				/*if (D[e.from] + e.dist < D[e.to])
				{
					D[e.to] = D[e.from] + e.dist;
					flag = true;
				}*/
			}
			//if (!flag)
			//break;//如果D[]已经全部确定,跳出循环
		}

		//检测负权回路,上面的操作保证没有负权回路的存在，
		//如果找到了更短的路径，则说明存在负权回路
		for (int i = 0; i < edges.size(); i++)
		{
			Edge &e = edges[i];
			if (D[e.from] + e.dist < D[e.to])
			{
				neg_loop = true;//存在负权环
				break;
			}
		}

		if (neg_loop)
			return false;
		else
			return true;
	}

SPFA算法——Bellman-Ford算法的队列优化

适用于权值有负值,且没有负圈的图的单源最短路径，复杂度O(kE)，k为每个节点进入Queue的次数，且一般k<=2，所以实际SPFA的复杂度一般为O(E)。期望时间复杂度：O(kE)，其中k为所有顶点进队的平均次数，可以证明m一般小于等于2n;（除非数据点专门卡SPFA，通常m都不大）

SPFA算法核心的循环的提前跳出：在实际操作中，Bellman-Ford算法经常会在未达到n-1次前就出解，n-1其实是最大值。于是可以在循环中设置判定，在某次循环不在进行松弛的时候直接退出循环，进行负权环的判定。
具体做法是用一个队列保存待松弛的点，然后对于每个出队的点依次遍历每个与他有边相邻的点(邻接表效率较高)如果该点可以松弛，并且队列中没有该点,就将其入队列，如此迭代直到队列为空。

SPFA，要从Bellman-Ford的优化说起。在n个点m条边的图中， Bellman-Ford的复杂度是n*m，依次对每条边进行松弛操作，重复这个操作n-1次后则一定得到最短路，这是因为最长的没有环路的路，也只不过是n个点n-1条边构成的，又因为每次循环，至少relax一边，所以最多n-1次就一定能得到最短路。
SPFA的意义在于，如果一个点上次没有被松弛过，那么下次就不会从这个点开始松弛。每次把被松弛过的点加入到队列中，就可以忽略掉没有被松弛过的点。算法的核心在于队列优化Bellman-Ford，利用了每个点不会更新次数太多的特点发明的此算法。
(Bellman-Ford算法中,其实每实施一轮松弛操作，就会有一些顶点已经求得其最短路，即这些顶点的最短路的"估计值"变为"确定值"。此后这些顶点的最短路的值就会一直保持不变,不再受后续轮松弛操作的影响。但是，每次还是会判断是否需要松弛，即更新，在此浪费了时间，而SPFA算法正是针对这一点进行了优化。)

	bool SPFA(int u0)
	{
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		D[u0] = 0;
		memset(final, false, sizeof(final));
		memset(enqueue, 0, sizeof(enqueue));
		queue<int>q;
		q.push(u0);
		final[u0] = true;
		while (!q.empty())
		{
			int u = q.front();
			q.pop();
			final[u] = false;
			enqueue[u]++;
			if (enqueue[u] == n)
				return false;//有负权环
			for (int i = 0; i < G[u].size(); i++)
			{
				Edge &e = edges[G[u][i]];
				if (D[e.from] + e.dist < D[e.to])
				{
					D[e.to] = D[e.from] + e.dist;
					if (!final[e.to])
					{
						final[e.to] = true;
						q.push(e.to);
					}
				}
			}
		}
		return true;
	}

完整代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;

const int maxn = 1000;//最大顶点数
const int maxm = 1000;//最大边数
const int INF = 1000000;
int n, m;
//int u[maxn], v[maxn], w[maxm];//起点,终点,权值

struct Edge
{
	int from, to, dist;//起始点,终点,两点距离（权值）
	Edge(int u, int v, int w) :from(u), to(v), dist(w) {}//构造函数,初始化,类比class
};//定义边结构体

struct HeapNode
{
	int dist, u;//权值,起点
	bool operator < (const HeapNode &node) const
	{
		return dist > node.dist;//最小值优先
	}
};

struct ShortestPath
{
	vector<Edge>edges;
	vector<int>G[maxn];//图的邻接表存储
	bool final[maxn];//final[v]=true当且仅当v∈S,即已经求得v0到v的最短路径,兼标记数组
	int D[maxn];//某点到其余的点的距离
	int enqueue[maxn];//顶点进(出)队列次数,在SPFA中用于判断是否有负权环出现

	/*初始化邻接表和边,及距离*/
	void init(int n)
	{
		for (int i = 0; i < n; i++)
			G[i].clear();
		edges.clear();
	}

	/*向图中添加边*/
	void AddEdge(int from, int to, int dist)
	{
		edges.push_back(Edge(from, to, dist));
		int m = edges.size();//m-1=边的编号
		G[from].push_back(m - 1);//G存起点from对应的边的编号,从而可以找到对应
	}	                         //的edges[]数组中点和权值的信息

	/*朴素Dijstra算法*/
	void Simple_Dijstra(int u0)//u0为源点
	{
		memset(final, false, sizeof(final));
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		D[u0] = 0;//源点到自身的距离为0
		final[u0] = true;
		for (int i = 0; i < G[u0].size(); i++)
		{
			Edge &e = edges[G[u0][i]];//引用,起别名
			D[e.to] = min(e.dist, D[e.to]);
		}
		for (int i = 0; i < n; i++)//求最短路径,时间复杂度为O(nm)
		{
			int v0 = 0;
			int Min = INF;
			for (int j = 0; j < n; j++)
				if (!final[j] && D[j] < Min)
				{
					Min = D[j];
					v0 = j;
				}
			final[v0] = true;//目的点
			/*更新当前最短距离D[],即松弛relax操作*/
			for (int k = 0; k < G[v0].size(); k++)
			{
				Edge &e = edges[G[v0][k]];
				if (!final[e.to] && e.dist + Min < D[e.to])
					D[e.to] = e.dist + Min;
			}
		}
	}

	void Priority_queue_Dijstra(int u0)
	{  
		memset(final, false, sizeof(final));
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		priority_queue<HeapNode>pq;
		D[u0] = 0;
		pq.push(HeapNode { 0, u0 }); //源点对应的权值和from点进队列
		while (!pq.empty())//求最短路径,O(nlogn);
		{
			HeapNode node = pq.top();
			pq.pop();
			int u = node.u;
			if (final[u])continue;
			final[u] = true;
			for (int i = 0; i < G[u].size(); i++)
			{
				Edge &e = edges[G[u][i]];
				if (D[e.to] > D[u] + e.dist)
				{
					D[e.to] = D[u] + e.dist;
					pq.push(HeapNode { D[e.to],e.to });
				}
			}
		}
	}

	bool Bellman_Ford(int u0)
	{
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		D[u0] = 0;
		bool neg_loop = false;//判断有无负权环
		//bool flag = false;//判断D[]是否已经都为确定值

		//进行n-1次松弛操作O(nm)
		for (int i = 0; i < n - 1; i++)
		{
			for (int j = 0; j < edges.size(); j++)
			{
				Edge &e = edges[j];
				D[e.to] = min(D[e.from] + e.dist, D[e.to]);
				/*if (D[e.from] + e.dist < D[e.to])
				{
					D[e.to] = D[e.from] + e.dist;
					flag = true;
				}*/
			}
			//if (!flag)
			//break;//如果D[]已经全部确定,跳出循环
		}

		//检测负权回路,上面的操作保证没有负权回路的存在，
		//如果找到了更短的路径，则说明存在负权回路
		for (int i = 0; i < edges.size(); i++)
		{
			Edge &e = edges[i];
			if (D[e.from] + e.dist < D[e.to])
			{
				neg_loop = true;//存在负权环
				break;
			}
		}

		if (neg_loop)
			return false;
		else
			return true;
	}
	            
	bool SPFA(int u0)
	{
		for (int i = 1; i <= n; i++)
			D[i] = INF;
		D[u0] = 0;
		memset(final, false, sizeof(final));
		memset(enqueue, 0, sizeof(enqueue));
		queue<int>q;
		q.push(u0);
		final[u0] = true;
		while (!q.empty())
		{
			int u = q.front();
			q.pop();
			final[u] = false;
			enqueue[u]++;
			if (enqueue[u] == n)
				return false;//有负权环
			for (int i = 0; i < G[u].size(); i++)
			{
				Edge &e = edges[G[u][i]];
				if (D[e.from] + e.dist < D[e.to])
				{
					D[e.to] = D[e.from] + e.dist;
					if (!final[e.to])
					{
						final[e.to] = true;
						q.push(e.to);
					}
				}
			}
		}
		return true;
	}
};
int main()
{
	freopen("testdata.in", "r", stdin);
	freopen("testdata.out", "w", stdout);
	int k;
	cin >> n >> m>> k;//输入顶点数和边数
	ShortestPath SP;
	SP.init(n);
	for (int i = 0; i < m; i++)
	{
		int u, v, w;
		cin >> u >> v >> w;//scanf("%d%d%d", &u, &v, &w);
		SP.AddEdge(u, v, w);
		SP.AddEdge(v, u, w);//无向图
	}

	SP.Simple_Dijstra(k);
	cout << "Simple Dijstra Algorithm:" << endl;
	for (int i = 0; i < n; i++)
		cout << SP.D[i + 1] << " ";//printf("%d\n",SP.D[w]);
	cout << endl;


	/*SP.Priority_queue_Dijstra(k);
	cout << "Priority_queue Optimized Dijstra Algorithm:" << endl;
	for (int i = 0; i < n; i++)
		cout << SP.D[i + 1] << " ";
	cout << endl;

	cout << "Bellman-Ford Algorithm:" << endl;
	if (SP.Bellman_Ford(k))
		for (int i = 0; i < n; i++)
			cout << SP.D[i + 1] << " ";
	else
		cout << "Graph contains negative-weight cycle!";
	cout << endl;

	cout << "SPFA Algorithm:" << endl;
	if (SP.SPFA(k))
		for (int i = 0; i < n; i++)
			cout << SP.D[i + 1] << " ";
	else
		cout << "Graph contains negative-weight cycle!";
	cout << endl;*/
	return 0;
}
Articoder
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
四种最短路径算法（Dijkstra,Floyd,Bellman-ford&&spfa）
xx_ii
08-14 4098
一.Dijkstra算法如何理解Dijkstra算法1.定义概览Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不存在负权边。 问题描述：在无向图
OSPF-开放式最短路径优先
01-05
SPF（Shortest Path First，最短路径优先）算法进行计算，每台路由器都计算出一棵以自己为根的、无环的、拥有最短路径的“树”。 OSPF 的基础术语包括区域、Router-ID 等。区域是从逻辑上将设备划分为不同的组，每...
关于最短路径几种算法的总结
Armstrong的博客
02-22 4561
一、Dijkstra 算法 迪杰斯特拉算法，可以解决无负权值的单源最短路径问题。 基本思路是对图 G(V, E) 设置集合 S ，存放已被访问的顶点，然后每次从集合 V - S 中选择与起点 s 的最短距离最小的一个顶点（记为 u ），访问并加入集合 S。之后，令顶点 u 为中介点，优化起点 s 与所有从 u 能到达的顶点 v 之间的最短距离。这样操作 n 次（ n 为顶点个数），直到集合 S...
最短路径算法
j_oop的博客
06-15 1307
应用场景： 狄克斯特拉用于解决单源最短路径问题，即从图中的某一节点出发到任一节点的最短路径。yue'shu
最短路径的四种算法
热门推荐
我の名字
07-30 1万+
最短路径四种算法 1 2 3 4 Floyd Dijkstra Bellman-Ford 队列优化的Bellman-Ford 一，只有四行的算法——Floyd-Warshall 假设求顶点ViViVi到VjVjVj的最短路径。弗洛伊德算法依次找从ViViVi到VjVjVj，中间经过结点序号不大于000的最短路径，不大于111的最短路径，…直到中间顶点序号不大于n−1n-1n−1...
求最短路径的三种算法
m0_75027890的博客
12-27 1940
求最短路径的三种算法 dijkstra算法，spfa算法，Floyd算法
基于搜索的路径规划算法
m0_46490744的博客
11-04 4361
基于搜索的路径规划算法 ——针对A* LPA*算法的理解 1.引言 对于研究系统优化和生产调度相关的课题，掌握对应的路径规划算法是必不可少的能力。移动一个简单的物体看起来是容易的，而路径搜索是复杂的。 根据是否考虑经验法则算法，可以将路径规划算法分为盲目式算法和启发式搜索算法。 解决有向正权值图类规划的Dijkstra算法，可以计算含有负权的Ford算法，系统检查图中所有节点的广度优先算法等等，都属于盲目式算法。这类算法的特点是，可以找到最优路径或最短路径，尽管搜索过程过于盲目即耗费的时间长，搜索的范围广。
dijkstra算法实现两景点间最短路径.zip
最新发布
06-20
在这个"dijskstra算法实现两景点间最短路径"的项目中，a.txt文件可能包含了算法的实现代码或具体的数据结构描述，而all文件可能是整个项目的汇总或结果展示。为了实现这个功能，我们需要： 1. **构建图**：首先，...
aco.rar_matlab路径遍历_最短路径_路径遍历_遍历最短路径
09-14
旅行商问题是一个经典的组合优化问题，其目标是寻找一个访问每个城市一次并返回起点的最短路径。在MATLAB环境中，我们可以构建一个蚁群算法模型来求解这个问题。 首先，我们要了解蚁群算法的基本原理。蚁群算法模拟...
ACATSP.rar_蚁群 路径_蚁群算法
09-15
旅行商问题是一个经典的NP完全问题，目标是找到访问给定城市列表并返回起点的最短路径，每个城市只访问一次。在实际应用中，这个问题可以映射到物流配送、网络路由优化等领域。 蚁群算法在解决TSP时，通常会用以下...
蚁群算法求解TSP最短路径规划
09-25
旅行商问题(Traveling Saleman Problem，TSP)是车辆路径调度问题(VRP)的特例，由于数学家已证明TSP问题是NP难题，因此，VRP也属于NP难题。旅行商问题（TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。
遗传算法之最短路径规划.zip
09-01
已知有两辆车，需从配送中心到8个不同地方，配送中心与目标间的距离不同，且需求也不一样，利用遗传算法求解最短路径。
数据结构与算法汇总.docx
02-08
"数据结构与算法汇总" 本篇文章将对数据结构和算法进行综合性总结，涵盖了常见的数据结构、算法思想、图算法、字符串算法、排序算法、动态规划、数论问题、排列组合等方面。 数据结构 数据结构是计算机科学中的一...
【计算机网络自顶向下方法】路由选择算法及分类
wgl307293845的博客
02-07 2460
路由选择算法 其目的是从发送方到接收方的过程中确定一条通过路由网络的好的路径（等价于路由）。通常一条好的路径指具有最低开销的路径。 最低开销路径 找出源和目的地之间具有最低开销的一条路也即是最短路径，即在源和目的地之间的具有最少链路数量的路径。 路由选择算法分类 第一种分类：根据该算法是集中式还是分散式来划分 集中式路由选择算法（centralized routing algorithm）用完整的、全局性的网络知识计算出从源到目的地之间的最低开销路...
求最短路径基本（常用）算法总结:
m0_57119771的博客
04-07 982
最短路径算法
五种最短路径算法的总结（待更新）
Syclus的博客
03-12 3650
最短路径算法： 1:Dijkstra 2:Floyd 3:Bellman-Ford 4:SPFA 5:A* 这五种最短路径算法初学的时候非常容易混淆，因为他们的松弛方法都差不多，而他们的核心却又与松弛有着很密切的关系，所以很难去辨别区别。 1:Dijkstra Dijkstra算法适用于单源最短路，也就是从一个点到终点，过程比较贪心，逻辑上是寻求最近点来逐步拓展，以达到局部最优的效果，再由局部最优一一推出全局最优 实现过程：建立dist数组存与原点的距离 1：从全部点中找离确定点（一开始...
简单图论：遍历所有最短路径
不二的博客
11-22 6874
今天遇到了两道要求遍历所有最短路径的题，我一直做不对的原因竟是我把无向图当成了有向图，郁闷的要死。 解决遍历所有最短路径，其实思路很简单，首先通过经典算法[各种算法，求出最短路径的长度，然后就只能DFS来找寻起始点、终点一样，长度为最短路径长度的路径即可，在DFS中可以使用数组来保存路径。 DFS时注意要剪枝，路径上已经走过的点不要重复走，可以用来保存。 这里要注意的是，如果边的权均为正，那...
【算法设计与分析】最短路径dijkstra算法和bellman-ford算法
青春不言败
01-03 3740
文章目录一、实验内容1、 Dijkstra算法求最短路径。2、Bellman-ford算法求最短路径二、理论准备1、 Dijkstra算法2、bellman-ford算法3、 两个算法的使用环境。三、实验环境四、实验过程1、Dijkstra算法2、bellman-ford算法五、实验结果六、实验总结 实验代码（github) 一、实验内容 1、 Dijkstra算法求最短路径。 测试用图 预期...
开放最短路径优先（OSPF）实验的要点在哪
06-01
开放最短路径优先（OSPF）是一个用于在互联网协议（IP）网络中寻找最短路径的协议。以下是OSPF实验的要点： 1. OSPF协议的工作原理：了解OSPF协议的基本工作原理，包括邻居关系建立、链路状态数据库（LSDB）同步、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值