最短路算法

最新推荐文章于 2024-07-24 14:54:00 发布
最新推荐文章于 2024-07-24 14:54:00 发布
阅读量426 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37464878/article/details/123170477
版权

1.Dijkstra算法

1.1 算法流程阐释

1.初始化：

出发点的最短路长度置为零，其余点的最短路长度置为正无穷。

2.n轮松弛：

Dij算法将点分为已经求出最短路的点的集合和未求出最短路的点的集合。最终得出结果必须使未求出最短路的点的集合为空，初始时所有点都未求出最短路，因此需要N轮松弛，就是最外层循环次数。

3.每轮松弛：在未求出最短路的点的集合中找到距离出发点最近的点：

在未求出最短路的点的集合中找到一个到出发点的距离最近的点，把它加入已求出最短路的点的集合。

4.每轮松弛：更新该点到所有未求出最短路的点的集合中的点的距离：

找到该点后遍历该点的所有临接顶点，如果邻接顶点在未求出最短路的点的集合中，那么更新它到出发点的距离。

1.2 注意事项

在《数据结构》严蔚敏版中给出的Dijkstra算法是使用邻接矩阵存图描述，背景是没有自环和重边的情况。书中写到Dijkstra算法需要n-1轮松弛，对于出发点而言，书中直接初始化了出发点能够访问到的点的最短路。这不具有普遍性，如果有重边和自环需要在初始化时注意这两个细节，额外改写。这样不如把出发点的情况也并入松弛中，总共n轮松弛，简化代码逻辑。

1.3 复杂度

时间复杂度为O(n2)。主要的原因是有n轮松弛时间复杂度是O(n)，在每轮松弛中都要在未求出最短路的点的集合中找到目标点并进行更新，这个操作是O(n)，总复杂度是O(n2)

1.4 Dijkstra求单源最短路示例:

给出一个图的描述以及一个出发点，求这个出发点到所有点的最短路(https://www.luogu.com.cn/problem/P3371)

#include <iostream>
#include <vector>
#include <climits>
#include <cmath>
using namespace std;

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
	Edge() {}
};

const int INF = INT_MAX;
vector<Edge>ar[10001];
int dis[10001];
bool vis[10001];

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	// init
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	dis[st] = 0;
	
	// dijkstra
	int target = st, size, minn = INF;
	Edge next;
	for(int i = 1; i <= n; i ++) { 
		minn = INF;
		for(int j = 1; j <= n; j ++) {
			if(!vis[j] && dis[j] < minn) {
				minn = dis[j];
				target = j;
			}
		}
		vis[target] = true;
		
		size = ar[target].size();
		for(int j = 0; j < size; j ++) { 
			next = ar[target][j];
			if(!vis[next.to])
				dis[next.to] = min(dis[next.to], dis[target] + next.cost);
		}
	}
	
	for(int i = 1; i <= n; i ++)
		cout << dis[i] << " ";
}

1.5 记录路径

在1.4的基础上添加一些内容。在1.1中的步骤四会更新最短路，在此时记录最短路发生改变的顶点的前驱即可。这里使用了新的数据结构Node来记录某个顶点的前驱。

#include <iostream>
#include <vector>
#include <climits>
#include <cmath>
using namespace std;

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
	Edge() {}
};

struct Node {
	int to;
	int pre;
};

const int INF = INT_MAX;
vector<Edge>ar[10001];
int dis[10001];
bool vis[10001];
Node nodes[10001];

void printRoute(int x, int st) {
	if(x == st)
		return;
	printRoute(nodes[x].pre, st);
	cout << nodes[x].pre << "->";
}

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	// init
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	dis[st] = 0;
	
	// dijkstra
	int target = st, size, minn = INF;
	Edge next;
	for(int i = 1; i <= n; i ++) { 
		minn = INF;
		for(int j = 1; j <= n; j ++) {
			if(!vis[j] && dis[j] < minn) {
				minn = dis[j];
				target = j;
			}
		}
		vis[target] = true;
		
		size = ar[target].size();
		for(int j = 0; j < size; j ++) { 
			next = ar[target][j];
			if(!vis[next.to]) {
				if(dis[next.to] > dis[target] + next.cost) {
					dis[next.to] = dis[target] + next.cost;
					nodes[next.to].pre = target;
				}
			}
		}
	}
	
	for(int i = 1; i <= n; i ++) {
		cout << dis[i] << endl;
		printRoute(i, st);
		cout << i << endl;
	}
}

2.stl优先队列自定义堆

#include <iostream>
#include <queue>
using namespace std;

struct Student {
	int grade;
	string name;
	Student(int grade, string name) {
		this->grade = grade;
		this->name = name;
	}
};

struct Cmp {
	bool operator()(const Student &a, const Student &b) {
        // 大顶堆排序依据（同JavaScript的sort，与c++的sort依据相反）
		return a.grade < b.grade;
	}
};

priority_queue<Student, vector<Student>, Cmp> q;

int main() {
	int n, grade;
	string name;
	cin >> n;
	for(int i = 0; i < n; i ++) {
		cin >> name >> grade;
		q.push(Student(grade, name));
	}
	
	while(!q.empty()) {
		Student tmp = q.top();
		cout << tmp.name << " " << tmp.grade << endl;
		q.pop();
	}
}

3.堆优化的Dijkstra算法

3.1 算法流程阐释

1.初始化：

出发点的最短路长度置为零，其余点的最短路长度置为正无穷。

2.m轮松弛：

Dijkstra算法让点按照1中提到的规则分布在两种不同的集合中。实际上遍历完图中的所有边，就相当于遍历完了所有点。那些没有临接边的顶点的最短路为正无穷，不用遍历。

3.每轮松弛：把当前顶点临接的未求出最短路的点的集合中的点都加入到一个小顶堆中

把当前顶点临接的未求出最短路的点的集合中的边都加入到一个小顶堆中，这里使用了一个策略使得我们不需要通过vis数组来判断一个点是否在未求出最短路的点的集合中。在松弛过程中我们将当前顶点临接的所有顶点的到源点的最短路径大于当前顶点加上该边的权值的邻接顶点加入小顶堆，反映到代码中即if(dis[next.to] > dis[target] + next.cost)，只有在未求出最短路的点的集合中的点才会满足该式子。这个操作对应无优化的Dijkstra算法中的操作是：找到target点后，更新与之临接的在未求出最短路的点的集合中的点的最短路。

4.每轮松弛：小顶堆排序：

除了Edge外我们还需要另一个结构体Node，在小顶堆中，排序依据是顶点到源点的最短路，在代码中即dis[i]。Node需要有顶点的编号以及顶点到源点的最短路长度。因此小顶堆中每个节点都存储一个Node数据结构。这样每轮松弛开始都从优先队列（我们设置成小顶堆结构）中取出队首元素，这样相当于找到了一个未求出最短路的点的集合中的到源点距离最近的点，时间复杂度是O(logn)。对应到无优化的Dijkstra，它是通过O(n)的复杂度找到这个顶点。这个操作对应无优化的Dijkstra算法中的操作是：在未求出最短路的点的集合中找到一个离源点最近的点。

3.2 注意事项

堆优化的Dijkstra还可以进一步做优化。图中的每一个有临接边的顶点都会从优先队列中出队一次，求出最短路。但是由于把顶点加入小顶堆是一个bfs操作，类似于spfa算法中的bfs。这样就可能出现一种情况，可能同一个顶点在它松弛之前被多次加入优先队列，每次加入优先队列都会触发一次堆排序，最终一定是该顶点第一次出队时Node中的dis值是最小的。当这个顶点再次出队时，结果一定不是最优的，反而还要占用一次松弛，这会耗费时间。解决方案是维护一个vis数组，判断当前顶点是否出队过。如果已经出队，那么跳过该顶点本次松弛过程。举例如下：D会两次入队，在出队时我们只对第一次出队的D进行松弛

在这里插入图片描述

3.3 复杂度

堆优化的Dijkstra算法优化点在于以O(logn)的时间复杂度找到未求出最短路的点的集合中距离源点最近的点。总复杂度是O(mlogn)，m是边数。

3.4 示例

给出一个图的描述以及一个出发点，求这个出发点到所有点的最短路(https://www.luogu.com.cn/problem/P4779

#include <iostream>
#include <vector>
#include <climits>
#include <queue>
using namespace std;
#define ll long long

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
	Edge(){}
};

struct Node {
	int to;
	int dis;
	Node(int to, int dis) {
		this->to = to;
		this->dis = dis;
	}
	Node() {}
};

struct Cmp {
	bool operator()(Node &a, Node &b) {
        // 小根堆排序依据，与JavaScript中的sort依据相同，与c++中的sort依据相反。表示a.dis大于b.dis时交换a和b
		return a.dis > b.dis;
	}
};

const int INF = INT_MAX;
vector<Edge>ar[100001];
int dis[100001];
bool vis[100001];
priority_queue<Node, vector<Node>, Cmp>q;

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	// init 
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	dis[st] = 0;
	q.push(Node(st, 0));
	
	// dijkstra
	while(!q.empty()) {
		int target = q.top().to;
		q.pop();
		if(vis[target])
			continue;
		vis[target] = true;
		int size = ar[target].size();
		Edge next;
		for(int i = 0; i < size; i ++) {
			next = ar[target][i];
			if(dis[next.to] > dis[target] + next.cost) {
				dis[next.to] = dis[target] + next.cost;
				q.push(Node(next.to, dis[next.to]));
			}
		}
	}
	
	for(int i = 1; i <= n; i ++)
		cout << dis[i] << " ";
}

3.5 记录路径

#include <iostream>
#include <vector>
#include <climits>
#include <queue>
using namespace std;
#define ll long long

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
	Edge(){}
};

struct Node {
	int to;
	int dis;
	Node(int to, int dis) {
		this->to = to;
		this->dis = dis;
	}
	Node() {}
};

struct Node2 {
	int to;
	int pre;
};

struct Cmp {
	bool operator()(Node &a, Node &b) {
		return a.dis > b.dis;
	}
};

const int INF = INT_MAX;
vector<Edge>ar[100001];
int dis[100001];
bool vis[100001];
priority_queue<Node, vector<Node>, Cmp>q;
Node2 nodes[100001];

void printRoute(int x, int st) {
	if(x == st)
		return;
	printRoute(nodes[x].pre, st);
	cout << nodes[x].pre << "->";
}

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	// init 
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	dis[st] = 0;
	q.push(Node(st, 0));
	
	// dijkstra
	while(!q.empty()) {
		int target = q.top().to;
		q.pop();
		if(vis[target])
			continue;
		vis[target] = true;
		int size = ar[target].size();
		Edge next;
		for(int i = 0; i < size; i ++) {
			next = ar[target][i];
			if(dis[next.to] > dis[target] + next.cost) {
				dis[next.to] = dis[target] + next.cost;
				nodes[next.to].to = next.to;
				nodes[next.to].pre = target;
				q.push(Node(next.to, dis[next.to]));
			}
		}
	}
	
	for(int i = 1; i <= n; i ++) {
		cout << dis[i] << endl;
		printRoute(i, st);
		cout << i << endl;
	}
}

4.SPFA算法

4.1 复杂度：

O(nm)

4.2 注意事项：

队列中的顶点一定是不同的，不允许队列中存在多个相同的顶点，这样存在无效操作。同一个顶点可以多次入队被更新。

4.3 示例：

给出一个图的描述以及一个出发点，求这个出发点到所有点的最短路(https://www.luogu.com.cn/problem/P3371)

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
using namespace std;
const int INF = INT_MAX;

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
};

vector<Edge>ar[10001];
queue<int>q;
int dis[10001];
bool vis[10001];

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	
	dis[st] = 0;
    vis[st] = true;
	q.push(st);
    
	while(!q.empty()) {
		int node = q.front();
		int size = ar[node].size();
		vis[node] = false;
		q.pop();
		for(int i = 0; i < size; i ++) {
			Edge next = ar[node][i];
			if(dis[next.to] > dis[node] + next.cost) {
				dis[next.to] = dis[node] + next.cost;
				if(!vis[next.to]) {
					vis[next.to] = true;
					q.push(next.to);
				}
			}
		}
	}
	
	for(int i = 1; i <= n; i ++)
		cout << dis[i] << " ";
}

4.4 记录路径

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
using namespace std;
const int INF = INT_MAX;

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
};

struct Node {
	int to;
	int pre;
};

vector<Edge>ar[10001];
queue<int>q;
int dis[10001];
Node nodes[10001];
bool vis[10001];

void printRoute(int x, int st) {
	if(x == st)
		return;
	printRoute(nodes[x].pre, st);
	cout << nodes[x].pre << "->";
}

int main() {
	int n, m, st, x, y, z;
	cin >> n >> m >> st;
	for(int i = 0; i < m; i ++) {
		cin >> x >> y >> z;
		ar[x].push_back(Edge(y, z));
	}
	
	for(int i = 1; i <= n; i ++)
		dis[i] = INF;
	
	dis[st] = 0;
	vis[st] = true;
    q.push(st);
    
	while(!q.empty()) {
		int node = q.front();
		int size = ar[node].size();
        vis[node] = false;
		q.pop();
		for(int i = 0; i < size; i ++) {
			Edge next = ar[node][i];
			if(dis[next.to] > dis[node] + next.cost) {
				dis[next.to] = dis[node] + next.cost;
				if(!vis[next.to]) {
					vis[next.to] = true;
                    nodes[next.to].pre = node;
					q.push(next.to);
				}
			}
		}
	}
	
	for(int i = 1; i <= n; i ++) {
		cout << dis[i] << endl;
		printRoute(i, st);
		cout << i << endl;
	}
}

4.4 负环判断

https://www.luogu.com.cn/problem/P3385

负环表示从某一点出发存在一条返回该点的回路，且总权值为负值。

负环的判断可以根据顶点入队次数来判断，如果顶点入队大于等于n次，则有负环。

注：4.4之前的SPFA没有处理负环的代码，一旦遇到负环就停不下来了。

#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

struct Edge {
	int to;
	int cost;
	Edge(int to, int cost) {
		this->to = to;
		this->cost = cost;
	}
	Edge() {}
};

vector<Edge>ar[2001];
queue<int>q;
int cnt[2001], dis[2001];
bool vis[2001]; 

int main() {
	int T, n, m, u, v, w;
	bool exist = false;
	cin >> T;
	for(int i = 0; i < T; i ++) {
		cin >> n >> m;
		for(int k = 0; k < 2001; k ++) {
			cnt[k] = 0;
			dis[k] = INT_MAX;
			ar[k].clear();
			vis[k] = false;
		}
		q = queue<int>(); 
		exist = false;
		for(int j = 0; j < m; j ++) {
			cin >> u >> v >> w;
			if(w >= 0)
				ar[u].push_back(Edge(v, w)), ar[v].push_back(Edge(u, w));
			else
				ar[u].push_back(Edge(v, w));
		}
		q.push(1);
		dis[1] = 0;
		vis[1] = true;
		cnt[1] ++;
		
		while(!q.empty()) {
			int now = q.front();
			q.pop();
			vis[now] = false;
			if(cnt[now] >= n) {
				cout << "YES" << endl;
				exist = true;
				break;
			}
			int size = ar[now].size();
			for(int j = 0; j < size; j ++) {
				Edge next = ar[now][j];
				if(dis[next.to] > dis[now] + next.cost) {
					dis[next.to] = dis[now] + next.cost;
					if(!vis[next.to]) {
						vis[next.to] = true;
						q.push(next.to);
						cnt[next.to] ++;
					}
				}	
			}
		}
		if(!exist)
			cout << "NO" << endl;
 	}
}

5.Floyd算法

5.1 注意事项：

第一层循环枚举中间点k。在比较当前路径和经过中间点的路径的大小时，要注意不要越界，下面代码对越过int上界的情况做了特判。

5.2 示例：

给出一个图的描述以及一个出发点，求这个出发点到所有点的最短路(https://www.luogu.com.cn/problem/P3371)

70分

#include <iostream>
#include <climits>
#include <cmath>
using namespace std;

const int INF = INT_MAX;
int ar[1001][1001];

int main() {
	int n, m, st, u, v, w;
	cin >> n >> m >> st;
	
	for(int i = 1; i <= n; i ++)
		for(int j = 1; j <= n; j ++)
			if(i == j)
				ar[i][j] = 0;
			else
				ar[i][j] = INF;
	
	for(int i = 0; i < m; i ++) {
		cin >> u >> v >> w;
		ar[u][v] = min(ar[u][v], w);
	}
	
	for(int k = 1; k <= n; k ++)
		for(int i = 1; i <= n; i ++)
			for(int j = 1; j <=n ;j ++) {
				if(ar[i][k] == INF || ar[k][j] == INF)
					continue;
				ar[i][j] = min(ar[i][j], ar[i][k] + ar[k][j]);
			}
	
	for(int i = 1; i <= n; i ++) 
		cout << ar[st][i] << " ";
}
Vanghua
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
最短路径算法
justlovetao的专栏
08-12 901
球最短路径的经典算法是----迪杰斯特拉算法。 迪杰斯特拉算法的实现过程和普里姆求最小生成树的算法很相似。主要是先理解算法的实现过程在利用模板处理各个题目的不同要求，达到以不变应万变的效果。   下面给出算法的理论实现：   其基本思想是，设置顶点集合S并不断地作贪心选
Dijkstra算法(求最短路)
Thewei666的博客
02-05 1734
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。
最短路 (dij 二进制）
qq_62539009的博客
04-24 318
链接：登录—专业IT笔试面试备考平台_牛客网 题目描述 给定长度为 n 的数列 a，如果 ai&aj≠0a_i \& a_j\neq 0ai​&aj​​=0（按位与），则在 i,j 之间存在一条长度为 ai+aja_i+a_jai​+aj​ 的边，求 1 至所有点的最短路。 输入描述: 第一行一个正整数 n。 接下来一行 n 个整数 a1∼ana_1\sim a_na1​∼an​。 输出描述: 输出一行 n 个整数，第 i 个为 1 到 i 的最短路长度。不能.
最短路问题
m0_63024355的博客
10-17 1356
本文用到了Dijkstra算法和Floyd算法，有了解后再看更好
浅谈五种最短路算法（c++）
2301_79587247的博客
03-17 902
最短路问题，说人话就是给定一个图，求两个点之间所有走法中，边权和最短的路的值。总的来说，最短路算法分为5个不同的种类。 floyd 概述 floyed算法是多元最短路的算法（说人话：随便两个点我都能求），主要思想就是只要算的多就一定能做出来。 思路 每次找到一个点k,在遍历所有点，找到一对i，j，d[i][j]=min(d[i][j],d[i][k]+d[k][j]); 例题 题目描述 样例输入 时间复杂度分析 由循环易知，时间复杂度是O(n^3)。（200以上的数据就不要用了）
【运筹优化】最短路算法之Dijkstra算法 + Java代码实现
知不足而奋进，望远山而前行
10-24 1420
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。
算法合集之《最短路算法及其应用》
02-26
最短路算法是图论中的一个核心问题，广泛应用于计算机科学、运筹学、网络优化等领域。本资源《最短路算法及其应用》主要探讨了如何寻找网络中两点间最短路径的方法，以及这些方法在实际问题中的应用，如交通路线规划...
动态最短路_动态最短路算法程序_
10-03
动态最短路算法是图论中的一个重要概念，用于在带权重的有向或无向图中寻找从一个起点到其他所有节点的最短路径。在实际应用中，它广泛应用于网络设计、物流优化、交通路线规划等领域。在这个场景中，我们讨论的是...
基于MATLAB的 Floyd最短路算法.zip
04-20
Floyd最短路算法是一种经典的图论算法，用于求解图中所有顶点对之间的最短路径。在MATLAB环境中实现这一算法，可以方便地处理大量数据并进行可视化。MATLAB作为一种强大的数值计算和编程环境，是研究和实现算法的...
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
07-02
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
Dijkstra算法及其优化——最短路算法
全机房最蒟蒻的博客
07-31 550
Dijkstra算法（一下简称Dij），是目前主流的求最短路的方法，自从CCF出题人公开表明SPFA它死了，并且在2018年卡了一次毒瘤数据SPFA，SPAF便退下主流最短路之位。 Dij实在每次进行扩展时，都去找相邻且离起点最近的点，这样就能达到最短路当前最优，但是并不代表未来最优，但是我们现在不考虑，那是Astar的事。 Dij算法如上右图，BFS如左图，可见，BFS不能处理带权的最短路，只是暴力的扩展，而Dij可以。 下面我们通过一道例题来理解Dij的代码实现。 热浪 输入 第1行：4个由空格隔开
最短路 dij floy spfa
gml1999的博客
11-09 209
例题 hdu1874 https://blog.csdn.net/murmured/article/details/18568657 一、Dijkstra 不可以算权值为负数的图 Dijkstra单源最短路算法，即计算从起点出发到每个点的最短路。所以Dijkstra常常作为其他算法的预处理。  使用邻接矩阵的时间复杂度为O(n^2),用优先队列的复杂度为O((m+n)logn)近似为O(m...
matlab最短路编程整理
m0_57130690的博客
10-14 1903
最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路：求一个点到其他点的最短路多源最短路：求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图：m 和 n2一个级别稀疏图：m 和 n 一个级别 参考：最短路算法总结（超详细~）_wmy0217_的博客-CSDN博客_最短路算法 Dijkstra算法的程序如下： function [d, p] = dijkstra(adj, s, t) % 使用dijkstra求最短路径 % adj ...
12.21~12.24最短路，dij,堆优化dij,spfa
m0_73553411的博客
12-24 49
有条件的最短路径一定长于无条件的最短路径。
图论中最短路算法与程序实现
农夫果园好好喝的博客
04-30 373
图论中的最短路问题（包括无向图和有向图）是一个基本且常见的问题。主要的算法有Dijkstra算法和Floyd算法。 Dijkstra算法是求出指定两点之间的最短 路，算法复杂度为0（n²） Floyd算法是求出任意两点之间的最短 路，算法复杂度为O(n3)O(n^{3})O(n3) 已知五十个点之间相互联系如下表所示： n = 50; A = zeros(n, n); for i = 1:n for j = 1:n if (i == j) A(i, j) = 0;
最短路径算法的编程与实现 C语言
热门推荐
timerring的博客
07-10 5万+
1.掌握最短路径算法的基本原理及编程实现；operating system version：Win11 CPU instruction set: x64 Integrated Development Environment：Viusal Studio 20221)建立一张图，选择一种存储结构(邻接矩阵或邻接表)初始化该图； 2)用Dijkstra算法实现点与点之间的最短路径。1) 实现图的两种表示方法； 2) 实现Dijkstra算法；1. 程序： 2.程序结果：1）程序运行，我使用的测试数据如下
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 864
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
最短路算法详解与应用
"最短路算法的PPT讲义，主要涵盖了如何详细描述和总结最短路算法。" 最短路算法是图论中的一个重要概念，用于寻找图中两个节点之间的最短路径。常见的最短路算法有Dijkstra算法、Floyd-Warshall算法和Bellman-Ford...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Vanghua

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值