最短路[Dijkstra和堆优化的Dijkstra][Bellman-Ford和SPFA][Floyd最短路]（更新中）

文章目录

第一类：单源最短路
- 一所有边权都是正数（Dijkstra）
- - 朴素版Dijkstra（稠密图）
  - 堆优化版Dijkstra（稀疏图）
- 二存在负权边（BF和SPFA）
第二类：多源汇最短路（Floyd）

常见的最短路问题，假定边为m，顶点为n。

第一类：单源最短路

求一个点到其他所有点的最短距离，比如：从1到n的最短路
单源最短路再分两种：

一所有边权都是正数（Dijkstra）

两种算法：
朴素Dijkstra算法，时间复杂度O(n2)O(n^2)O(n2)，和边的数量无关，适合于稠密图（边数很多，m和n2n^2n2是一个规模）。
堆优化的Dijstra算法。时间复杂度O(mlogn)O(mlogn)O(mlogn)，适合于稀疏图。
其中，n是图中点的数量，m是图中边的数量

Dijkstra算法的思想是基于贪心的，每次选择最短的路。

朴素Dijkstra算法步骤：

集合S表示已确定最短距离的点

1. dist[1]=0,dist[i]= INF  //初始化
2. for i: 1~nt  ⬅不在S中的距离最近的点S  ⬅ t用t更新其他点的距离

朴素版Dijkstra（稠密图）

Acwing849. Dijkstra求最短路 I(稠密图)
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。

输入格式
第一行包含整数n和m。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式
输出一个整数，表示1号点到n号点的最短距离。

如果路径不存在，则输出-1。

数据范围
1≤n≤500,
1≤m≤105,
图中涉及边长均不超过10000。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

ac代码

#include<bits/stdc++.h>
using namespace std;
const int N=510;int m , n;
int g[N][N];bool st[N]; //该点是否确定最短路
int dist[N];//原点到各点的距离 int dijkstra(){memset(dist,0x3f3f3f,sizeof(dist)); //初始化距离无穷大dist[1] =0 ; //1号点初始化为0//迭代n次 for(int i=0;i<n;i++){//找最小值int t=-1;  //找到当前最小的值 用t来存,t=-1表示没找到 for(int j=1;j<=n;j++){if(!st[j]&&( t==-1 || dist[t] >dist[j] ))t=j;} //加到集合S中st[t]=true;//用t更新其他点的距离for(int j=1;j<=n;j++)dist[j]= min(dist[j],dist[t]+g[t][j]); } //如果不连通返回-1if(dist[n]>=0xffff) return -1;return dist[n]; }int main(){cin>>n>>m;memset(g,0x3f,sizeof g);while(m--){int a,b,c;cin>>a>>b>>c;g[a][b]=min(g[a][b],c);  //去除重边 }   int t=dijkstra();cout<<t<<endl;}

堆优化版Dijkstra（稀疏图）

acwing850. Dijkstra求最短路 II

给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。

输入格式
第一行包含整数n和m。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式
输出一个整数，表示1号点到n号点的最短距离。

如果路径不存在，则输出-1。

数据范围
1≤n,m≤1.5×1051≤n,m≤1.5×10^51≤n,m≤1.5×105,
图中涉及边长均不小于0，且不超过10000。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

分析：

这题是稀疏图，使用邻接表来存储。

ac代码

#include<bits/stdc++.h>
using namespace std;
const int Mn=1e9;const int N=1000000;typedef pair<int ,int > PII;bool st[N]; //是否确定最短路
int dist[N]; //最短距离
int n ,m;
//使用邻接表来存储图
int h[N]; // 头节点数组
int ne[N]; //next指针指向的地址，这里是结点b的地址
int e[N]; //next指针指向的具体的值，这里是结点b
int w[N]; // a到b的边的权重
int idx; //索引//加边  a后面加b，权重是c
void add(int a,int b,int c){e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}int dijkstra(){memset(dist,0x3f,sizeof dist);dist[1]=0;priority_queue<PII,vector<PII> ,greater<PII>> heap; heap.push({0,1}); //距离为0，编号为1 之所以距离放前面，是因为heap按照第一关键字排序while(heap.size()){//找最小点auto t=heap.top();heap.pop();int ver =t.second, distance = t.first;  //ver是编号，distance 是距离if(st[ver]) continue;//找到最小值st[ver]=true; //用当前点更新其他点//遍历当前 点ver的相邻的点for(int i=h[ver];i!=-1;i = ne[i]){int j=e[i]; //点if(dist[j]> distance + w[i]){dist[j]= distance +w[i];heap.push({dist[j],j});}}}if(dist[n]>=Mn) return -1;return dist[n];}int main(){cin>>n>>m;memset(h ,-1 ,sizeof h);  //头结点数组初始化为-1while(m--){int a , b, c;cin>>a>>b>>c;add(a,b,c);  //邻接表}int t=dijkstra();cout<<t<<endl;}

二存在负权边（BF和SPFA）

两种算法：假定边为m，顶点为n
Bellman-Ford算法，时间复杂度O(nm)O(nm)O(nm)，适合于边数不超过k条（此处k为限定的边数）。

算法思路：

扫描所有边(x, y, z)，这里指的是从x到y，边权为z的边，如果dist[y] > dist[x] + z, 则用dist[x] + z 更新dist[y].
重复上述步骤，直到没有更新操作发生。

而spfa算法呢，在国际上通常称为”队列优化的Bellman-Ford算法“。它是对Bellman-Ford算法的优化，一般而言，我们刷题用的多的还是spfa。

SPFA算法一般情况下比Bellman-Ford快，时间复杂度O(m)O(m)O(m)，最坏O(nm)O(nm)O(nm)，适合于负权边

spfa算法流程：

建立一个队列，最初队列中只含有起点1
取出队头结点x，扫描它的所有出边(x, y, z),如果dist[y] > dist[x] + z, 则用dist[x] + z 更新dist[y].同时，若y不在队列中，则把y入队。
重复上述步骤，直到队列为空。

851. spfa求最短路

来源：acwing

spfa代码和堆优化dijkstra很像。只不过spfa用的是队列queue。关于queue的操作，取出队头元素是front();存入元素是push().当然建图同样是邻接表。
spfa算法中st数组的含义是：某个点是否已经在队列中。

spfa算法模板代码

#include<bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N  = 1e5 + 10;
int n, m;
int h[N],ne[N],w[N],e[N], idx;
typedef pair<int,int> PII;int dist[N];
bool st[N]; // st数组存的是当前这个点是否在队列中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); // 把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(){cin >> n >> m;memset(h, -1, sizeof h);while(m --){int a, b, c;cin >> a >> b >> c;add(a, b ,c );}int t = spfa();if( t == -1) puts("impossible");else cout << t << endl;}

补充手写队列的spfa写法：

int spfa(){memset(dist, 0x3f, sizeof dist);int hh = 0, tt = 0;q[0] = 1;dist[1]  = 0;st[1] = true;while(hh <= tt){auto t = q[ hh ++];st[t] = false;for(int i = h[t]; ~i; i = ne[i]){int j = e[i];if(dist[j] > dist[t] + w[i]){dist[j] = dist[t] + w[i];                                                              if(!st[j]){q[ ++ tt] = j;st[j] = true;}}}}if(dist[n] == 0x3f3f3f3f) return -1;return dist[n];
}

第二类：多源汇最短路（Floyd）

源点：起点；汇点：终点；
假定边为m，顶点为n
任选两个点，从其中一个点到另外一个点的最短距离。即起点和终点不确定。很多不同起点到其他点的最短路
算法：Floyd 算法，时间复杂度O(n3)O(n^3)O(n3)

考察侧重点：建图。

可以用有向图的算法直接解决无向图的问题。