终于是学完了，这个最短路我学了好几天，当然也学了别的算法啦，也是非常的累啊。
话不多说下面看看最短路问题吧。
最短路问题是有向图，要求的是图中一个点到起点的距离，其中我们要输入点和点之间的距离，来求最短路。
下面分为几类题目：
单源汇最短路-->一个起点
1.边权为正数（dijkstra）
dijkstra算法的原理其实是拿第一个点与相连接的点进行距离上的比较，让距离最近的点作为下一个比较的第一个点，由于是边权为正数，所以不用去考虑负数和负环路。但是为啥我要分为两种类型，不是因为优化就是比朴素好，因为他们的存储数据不同，要存储的方式也是不同的，所以方法也是不同的。
方法：
dis[1]=0,dis[i]=0x3f正无穷
for(int i=1~n) 当前已经确定最短距离的点（当然用邻接表存储的for(int i=h[st];i!=-1;i=ne[i])）
t<-不在s中的距离最近的点
s<-t
用t更新其他点的距离
(1)朴素 O(n^2) n点数m边数-->边数较多-->稠密图-->邻接矩阵
看题：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n≤500,
1≤m≤10^5,
图中涉及边长均不超过10000。
看这个
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3代码实现：
#include<bits/stdc++.h>
using namespace std;
const int N=510;
int n,m;
int g[N][N];
int dis[N];
bool st[N];
int Dijkstra(){
memset(dis,0x3f,sizeof dis);
dis[1]=0;
for(int i=0;i<n;i++){
int t=-1;
for(int j=1;j<=n;j++)//j-x当前的点
if(!st[j]&&(t==-1||dis[t]>dis[j]))
t=j;
// if(t==n)break;
st[t]=true;
for(int j=1;j<=n;j++)
dis[j]=min(dis[j],dis[t]+g[t][j]);
}
if(dis[n]==0x3f3f3f3f)return -1;
return dis[n];
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
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);
}
cout<<Dijkstra()<<endl;
}(2)堆优化版 O(mlogn)-->边少-->稀疏图-->邻接表
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n,m≤1.5×10^5,
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 10^9。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3代码实现（因为是队列嘛，咱们也可以使用模拟队列）：
#include<bits/stdc++.h>
#include<cstring>//memset函数的头文件
#include<iostream>
#include<algorithm>
#include<queue>
#define xx first
#define yy second
using namespace std;
const int N = 150010;
typedef pair<int, int>PII;//前者是距离 堆中按照前者距离排序 后者是点序号
priority_queue<PII, vector<PII>, greater<PII>>heap;//小根堆
int h[N], w[N], e[N], ne[N], idx;//稀疏图用邻接表储存 w[N]存权重
int dist[N];//起点点到终点的(当前)最短距离
bool vis[N];//标记起点到某个点的最短距离是否确定
int st,ed;//起点到终点
int n, m;
//数组模拟邻接表的插入函数
void add(int a, int b, int c){//存在一条从点a到点b的有向边 距离为c
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int Dijkstra(int st, int ed){
//初始设定起点点到其他所有点距离为正无穷
memset(dist, 0x3f, sizeof dist);
//起点到起点距离为0 加入堆
dist[st] = 0;
//第一参数是距离
//第二参数是终点编号
heap.push({ 0,st });
while (heap.size()){
auto t = heap.top();
heap.pop();//取出后一定要弹出
int ver = t.yy, distance = t.xx;//ver取得该点的下标
if (vis[ver])continue;//已经确定了就跳过
//要做就先确定下来
//出队时确定加入S集合
vis[ver] = true;
//把确定下来的那个点能拓展到的新点 加入堆
for (int i = h[ver];~i;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[ed] == 0x3f3f3f3f)return -1;//不连通
return dist[ed];
}
int main(){
memset(h, -1, sizeof h);//初始化邻接表表头
scanf("%d%d", &n, &m);
while (m--){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d\n", Dijkstra(1, n));
}2.存在负边权
贝尔曼的原理嘛，是一个叫做三角不等式的松弛操作实现的，但是由于是双重循环把所有的边都遍历了一遍，所以时间复杂度为O(nm)，而相对于下面的SPFA算法嘛，一般都比较常用spfa。
(1)Bellman-ford O(nm)
你看这个可以在1->2->3->4->2走无穷次，导致最终结果为负无穷
但是他可以走有限条边，即使是万能的spfa也不行，因为这就是遍历的一步。
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
点的编号为 1∼n。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
数据范围
1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3代码实现：
#include<bits/stdc++.h>
#include<cstring>
#include<iomanip>
#include<iostream>
using namespace std;
const int N=510,M=1e4+10;
int n,m,k;
int dis[N],backup[N];
struct tu
{
int a,b,w;
}edge[M];
void Bellman_ford(){
memset(dis,0x3f,sizeof dis);
dis[1]=0;
for(int i=0;i<k;i++){
memcpy(backup,dis,sizeof dis);
for(int j=0;j<m;j++){
int a=edge[j].a,b=edge[j].b,w=edge[j].w;
dis[b]=min(dis[b],backup[a]+w);
}
}
}
int main(){
scanf("%d%d%d",&n,&m,&k);
for(int i=0;i<m;i++){
int a,b,w;
cin>>a>>b>>w;
// edge[i].a=a,edge[i].b=b,edge[i].w=w;
edge[i]={a,b,w};
}
Bellman_ford();
if(dis[n]>0x3f3f3f3f/2)cout<<"impossible";
else cout<<dis[n];
}(2)SPFA O(m)，最坏O(nm)-->贪心
前提是：
不含负环，但是同样适用于dijkstra题目
这个算法虽然不能适用于求负环的最短路，但是他可以判断是不是含有负环，详细看注释掉的部分。
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 impossible。
数据范围
1≤n,m≤10^5,
图中涉及边长绝对值均不超过 10000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2代码实现：
#include<cstring>//memset函数的头文件
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 100010;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool vis[N];
int n, m;
// int cnt[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);
vis[1]=true;
while(q.size()){
int t=q.front();
q.pop();
vis[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];
// cnt[j]=cnt[t]+1;
// if(cnt[j]>=n)return true;//判断是不是存在负环
if(!vis[j]){
q.push(j);
vis[j]=true;
}
}
}
}
return dist[n];
// return false;
}
signed main(){
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while(m -- ){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
}
int t=spfa();
if(t==0x3f3f3f3f) puts("impossible");
else printf("%d",t);
// if(spfa())puts("Yes");
// else puts("No");
}多源汇最短路 Floyd O(n^3)-->dp
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。
输出格式
共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。
数据范围
1≤n≤200,
1≤k≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过 10000。
输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1代码实现：
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=200+10,INF=1e9;
int m,n,Q;
int d[N][N];
void floyd(){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
for(int k=1;k<=n;k++){
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
}
signed main(){
scanf("%d%d%d",&n,&m,&Q);
//init
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(i==j)d[i][j]=0;
else d[i][j]=INF;
//input
while(m--){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
d[a][b]=min(d[a][b],c);
}
floyd();
while(Q--){
int a,b;
scanf("%d%d",&a,&b);
if(d[a][b]>INF/2)
puts("impossible");
else
printf("%d",d[a][b]);
}
}
以上就是求最短路的所有方法啦。