本文介绍了五种经典的最短路径算法，包括Floyd、朴素Dijkstra、堆优化Dijkstra、Bellman-Ford及SPFA算法。每种算法都配有详细的解释、应用场景及示例代码，帮助读者理解并掌握这些算法。
最短路问题，就是给定一个图，求两个点之间所有走法中，边权和最短的路的值。总的来说，最短路算法分为5个不同的种类。
floyd
概述
floyed算法是多元最短路的算法（说人话：随便两个点我都能求），主要思想就是只要算的多就一定能做出来。
思路
每次找到一个点k,在遍历所有点，找到一对i，j，d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
例题
题目描述
样例输入
时间复杂度分析
由循环易知，时间复杂度是O(n^3)。（200以上的数据就不要用了）
代码
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>PII;
const int N=210,INF=1e9;
int m,n,k;
int d[N][N];
bool st[N];
void floyd(){
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
}
int main(){
int i,j;
scanf("%d %d %d",&n,&m,&k);//n是点数，m是边数，k是询问数
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
if(i==j)d[i][j]=0;
else d[i][j]=INF;//赋值
}
}
for(i=0;i<m;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
d[a][b]=min(d[a][b],c);//处理重边
}
floyd();
for(i=0;i<k;i++){
int a,b;
scanf("%d %d",&a,&b);
if(d[a][b]>INF/2)puts("impossible");
else printf("%d\n",d[a][b]);
}
return 0;
}
朴素Dijkstra
概述
Dijkstra算法是单元最短路的算法，特别稳定，不容易被卡。
思路
核心就是把所有点分成两组，一求出最小值的一组和还没求出最小值的一组。
开一个dist数组表示1到其余点的最短路，st数组记录被没被选择过（是否还可能被更新）。
循环（n-1）次，每次打擂台，找到1到所有点的距离最小的且没被标记过的点，把这个点标记一下，修改所有和这个点直接相连的点到1的距离。
例题
题目描述
样例输入
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m,map[N][N],dist[N];
bool st[N];
int dijkstra()
{
int i,j,t;
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (i = 0; i < n - 1; i ++ )
{
t = -1;
for (j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
st[t] = true;
for (j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + map[t][j]);
}
if (dist[n]==0x3f3f3f3f) return -1;//有没有最短路
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(map, 0x3f, sizeof map);
while (m -- )
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
map[x][y] = min(map[x][y],z);//处理重边
}
printf("%d\n", dijkstra());
return 0;
}
证明
我看到很多文章都没有给出证明，本蒟蒻就简单证明一下。
假设对于一个被标记过的v点，存在一个点t还并未被标记过，且dist[v]>map[t][v]+dist[t]。
因为map[t][v]>0
所以dist[t]<dist[v]
由“打擂台”可知，t一定在v被标记之前被标记过，与假设不符。
故不存在满足要求的t点
即被标记过的点都是以求出最短路，不能修改的。
证毕
堆优化朴素Dijkstra
优化思路
打擂台算法是O(n)的，每次扫一遍很浪费时间。我们可以使用一个数据结构，每次快速得到其中最小的元素——堆（优先队列）。当然用set也行，这里不推荐。
例题
题目描述
样例输入
代码
#include <bits/stdc++.h>
using namespace std;
const int N = 150010;
int n, m;
int h[N],e[N],ne[N],w[N],idx;
bool st[N];
int dist[N];
void add(int a, int b, int c)//邻接表存图
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx++;
}
int dijkstra()
{
int i,j;
memset(dist, 0x3f3f3f3f, sizeof(dist));
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > qu;
//pair默认以第一个元素为第一关键字排序
qu.push(make_pair(0,1));
dist[1] = 0;
while(!qu.empty())
{
pair<int,int> t = qu.top();
qu.pop();
int node = t.second;
if(st[node]) continue;
st[node] = true;
for(i = h[node]; i != -1; i = ne[i])
{
j = e[i];
dist[j] = min(dist[j], w[i] + dist[node]);
qu.push(make_pair(dist[j], j));
}
}
if(dist[n]==0x3f3f3f3f) return -1;
else return dist[n];
}
int main()
{
memset(h, -1, sizeof h);
scanf("%d %d",&n,&m);
int a, b, c;
while(m--)
{
scanf("%d %d %d",&a,&b,&c);
add(a, b, c);
}
cout << dijkstra() << endl;
return 0;
}
bellman-ford
概述
bellman-ford算法又是一个暴力出奇迹的算法，而且存图可以特别随意，想怎么存就怎么存。
最牛*的是，它可以，也只有他可以解决做过边数有限制的最短路问题。
思路
遍历一遍所有边，在遍历所有点，能用这个点松弛这条边就松弛。(松弛就是min操作）
例题
题目描述
样例输入
时间复杂度分析
由循环易知，时间复杂度是O(nm)。
代码
#include<bits/stdc++.h>
using namespace std;
const int N=500+10,M=10010;
int m,n,k;
int dist[N],bakup[N];
struct Edge{
int a,b,w;
}edges[M];
int bellman_ford(){
memset(dist,0x3f,sizeof(dist));
dist[1]=0;
for(int i=0;i<k;i++){
memcpy(bakup,dist,sizeof(dist));
for(int j=0;j<m;j++){
int a=edges[j].a;
int b=edges[j].b;
int w=edges[j].w;
dist[b]=min(dist[b],bakup[a]+w);
}
}
if(dist[n]>0x3f3f3f/2)return -1;
return dist[n];
}
int main(){
int i,j;
scanf("%d %d %d",&n,&m,&k);
for(i=0;i<m;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
edges[i]={a,b,c};
}
int t=bellman_ford();
if(t==-1)puts("impossible");
else printf("%d\n",t);
return 0;
}
spfa
优化思路
按边的数量松弛，要是都没有边可修改了怎么办，循环还在继续，相当浪费时间。我们用一个队列来维护，只有他还能被松弛再松弛，没有个松弛的了就结束。
例题
题目描述
样例输入
时间复杂度分析
spfa算法大多数情况下很优秀，速度也最快，但要是题中用spfa也行，用Dijkstra也行，最好用Dijkstra。spfa会被卡！会被卡的很惨！会被卡成O(mn)! 会被卡成bellman-ford！
代码
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>PII;
const int N=100010;
int m,n,k;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];
void add(int a,int b,int c){
e[idx]=b;
w[idx]=c;
ne[idx]=h[a];
h[a]=idx++ ;
}
int spfa(){
memset(dist,0x3f,sizeof(dist));
dist[1]=0;
queue <int>q;
q.push(1);
st[1]=true;
while(q.size()){
int t=q.front();
q.pop();
st[t]=false;
for(int i=h[t];i!=-1;i=ne[i]){
int j=e[i];
if(dist[j]>dist[t]+w[i]){
dist[j]=dist[t]+w[i];
if(!st[j]){
q.push(j);
st[j]=true;
}
}
}
}
if(dist[n]==0x3f3f3f3f)return -1;
return dist[n];
}
int main(){
int i,j;
scanf("%d %d",&n,&m);
memset(h,-1,sizeof(h));
for(i=0;i<m;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
add(a,b,c);
}
int t=spfa();
if(t==-1)puts("impossible");
else printf("%d\n",t);
return 0;
}
spfa判断负环
概述
要知道，负环和最短路是一对冤家，有负环无最短路，有最短路无负环。
spfa算法就可以判断负环。
思路
正常情况下，即使spfa被卡，时间复杂度也是o(nm)，不会更多，也就是说，只要超过了这个极限，就一定有负环。
通俗的说，循环m次还能松弛，这个图中就一定有负环。
例题
题目描述
样例输入
代码
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>PII;
const int N=100010;
int m,n,k;
int h[N],w[N],e[N],ne[N],idx;
int dist[N],cnt[N];
bool st[N];
void add(int a,int b,int c){
e[idx]=b;
w[idx]=c;
ne[idx]=h[a];
h[a]=idx++ ;
}
int spfa(){
queue <int>q;
for(int i=1;i<=n;i++){
st[i]=true;
q.push(i);
}
st[1]=true;
while(q.size()){
int t=q.front();
q.pop();
st[t]=false;
for(int i=h[t];i!=-1;i=ne[i]){
int j=e[i];
if(dist[j]>dist[t]+w[i]){
cnt[j]=cnt[t]+1;
dist[j]=dist[t]+w[i];
if(cnt[j]>=n)return true;
if(!st[j]){
q.push(j);
st[j]=true;
}
}
}
}
return false;
}
int main(){
int i,j;
scanf("%d %d",&n,&m);
memset(h,-1,sizeof(h));
for(i=0;i<m;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
add(a,b,c);
}
int t=spfa();
if(t)puts("YES");
else printf("NO\n");
return 0;
}
总结
这是我的第一篇文章，如有纰漏也请各位大佬指正
辛苦创作不易，还望看官点赞收藏打赏，后续还会更新新的内容。
扫一扫
332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
