最短路学习记录

最新推荐文章于 2022-05-25 13:05:35 发布

原创最新推荐文章于 2022-05-25 13:05:35 发布 · 162 阅读

0 ·

CC 4.0 BY-SA版权

学习同时被 2 个专栏收录

20 篇文章

订阅专栏

模板

12 篇文章

订阅专栏

本文深入探讨了三种经典的最短路径算法：弗洛伊德、迪杰斯特拉和SPFA。详细解析了每种算法的原理、代码实现及优化方法，适合初学者快速掌握最短路径算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

其实。。最短路我们一个月前就学了。。但我比较弱，只掌握了弗洛伊德。。。咳咳，直到考试，才发现。。。于是开始重新学最短路

弗洛伊德

我觉得弗洛伊德~~是最快的~~ 咳咳，打的最快的，他的代码只有。。。五行
思想非常简单，带点动归的思想，，然后，，，比较简单，就直接上代码

for(int k=1;k<=n;k++)
     for(int i=1;i<=n;i++)
          for(int j=1;j<=n;j++){
               if(a[i][j]) a[i][j]=max(a[i][j],a[i][k]+a[k][j];
               else a[i][j]=a[i][k]+a[k][j];
          }

悄咪咪地说，其实对于我这种压行地人来说，两行就够了（咳咳）

FOR(k,1,n) FOR(i,1,n) FOR(j,1,n) a[i][j]?a[i][j]=max(a[i][j],a[i][k]+a[k][j]:a[i][j]=a[i][k]+a[k][j];

~~小朋友们不要学习这种压行~~咳咳
这个代码还是很好理解的

迪杰斯特拉

迪杰斯特拉是求单源最短路径的好办法，他的思想和普利姆算法很相像，使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。
于是。。。。我们来模拟一下
比如一组数据
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
（我比较弱。。。正无穷打不出来。。。INF凑合看）

	1	2	3	4
1	0	2	5	INF

这时dis[1]=0;
然后扫一遍，找最小值，发现到2有最小值，那么dis值更新一下，dis[2]=2，然后再用2继续更新

	1	2	3	4
1	0	2	4	3

这时，3的值被更新，变成了4，然后继续找最小值，更新dis[4]=3

	1	2	3	4
1	0	2	4	3

最后，再更新dis[3]=4
整个最短路就被求了出来
于是，整个的看一下，他的思路就是持续更新最小值，对每个点进行扫描，这样，他整个的复杂度就是O(n^2)
那么我们来看一下代码


#include<cstring>
#include<cstdio>
#include<algorithm>
#define FOR(i,n,m) for(int i=n;i<=m;i++)
#define inf 99999999
#define N 1010
using namespace std;
int map[N][N];//原储存矩阵
int dist[N];
int visited[N],s[N];
int n,m;

#define FOR(i,n,m) for(int i=n;i<=m;i++)
void Dijkstra(int J) { //求每个点到J的距离
	memset(visited,0,sizeof(visited));
	FOR(i,1,n) dist[i]=inf; //初始化距离
	dist[J]=0;
	visited[J]=1;
	FOR(i,1,n){
	    FOR(j,1,n){
			if(!visited[j]&&map[J][j]<inf&&dist[J]+map[J][j]<dist[j]) //有路，并且没走过，并且落脚后比原有路径更短
				dist[j]=map[J][j]+dist[J];
		}
		int min=inf;
		FOR(j,1,n)  //再遍历所有点，找已经可以走的，并且没有做过起点的。
			if(!visited[j]&&dist[j]<min) J=j,min=dist[j];//每次从最短的路走，搜出下一个落脚点
		visited[J]=1;//做过头点的标记
		if(min==inf)
			return;
	}
}


int main() {
	scanf("%d%d",&n,&m);
	FOR(i,1,m) {
		int j,k,f;
		scanf("%d%d%d",&j,&k,&f);
		if(f<map[j][k])
			map[j][k]=f;
	}
	Dijkstra(1);
	return 0;
}

那么，它该如何优化呢，我们考虑用堆，把他的复杂度降到O(nlogn）
然后具体也是差不多的，就直接来看一下代码

#include<iostream>
#include<cstdio>
#include<queue>
#define MAXN 100010
#define MAXM 200020
#define INF 2000000000
using namespace std;

struct edge {
	int to;
	int power;
	int nxt;
} a[MAXM];//邻接表储存
int head[MAXN];
int dis[MAXN];
int n,m,s;
struct node {
	int num;
	int data;
	node(int X=0,int Y=0):num(X),data(Y) {}
	bool operator < (const node& x)const {
		return data>x.data;
	}
};
priority_queue<node>Q;

void dijkstra() {
	for(int i=1; i<=n; i++) {
		dis[i]=INF;
	}
	dis[s]=0;
	Q.push(node(s,0));
	node fi;
	int t,p,w;
	while(!Q.empty()) {
		fi=Q.top();
		Q.pop();
		p=fi.num;
		if(fi.data!=dis[p])continue;
		t=head[p];
		int v;
		while(t) {
			v=a[t].to;
			if(dis[v]>dis[p]+a[t].power) {
				dis[v]=dis[p]+a[t].power;
				Q.push(node(v,dis[v]));
			}
			t=a[t].nxt;
		}
	}
}

int main() {
	scanf("%d%d%d",&n,&m,&s);
	int i,j,k;
	int u,v,w;
	for(i=1; i<=m; i++) {
		scanf("%d%d%d",&u,&v,&w);
		a[i].to=v;
		a[i].power=w;
		a[i].nxt=head[u];
		head[u]=i;
	}
	dijkstra();
	for(i=1; i<=n; i++) {
		cout<<dis[i]<<" ";
	}
	return 0;
}

(感谢某大佬的代码友情支持）

SPFA

表示个人喜欢用SPFA
SPFA非常好打，非常好理解（~~就是容易被卡~~）

void SPFA() {
	queue<int> q;
 	for(int i=1;i<=n;++i)
		dis[i]=INF,vis[i]=0;
	vis[s]=1,dis[s]=0;
	q.push(s);
	while(!q.empty()) {
		int u=q.front();
		q.pop();
		vis[u]=0;
		QXX(u) 
			if(dis[v]>dis[u]+e[i].w) {
				dis[v]=dis[u]+e[i].w;
				if(!vis[v]) q.push(v),vis[v]=1;
			}
	}
}