突然发现掘金可以改变Markdown的主题，于是这篇博客使用了github的主题，虽然内容紧凑了一些，但是代码更加清晰可见了。

最短路算法，顾名思义是在图中给定两个点，求解这两个点之间的最短距离的一种算法，在算法中比较常用。

在本文档中，n表示树或图的点数，m表示边数。

求解单源最短路

朴素Dijistra算法

适用情况

朴素Dijistra的时间复杂读为O(n^2)，适用于所有边权均为正数的稠密图中。使用邻接矩阵来存储树或图。

算法思路

每次在剩余的点中寻找距离最近的点，之后使用此点来更新所有点到原点之间的距离。

s[N]:当前已经确定的最短路中的点
dist[N]:某一个点到源点的距离

初始化距离，设定除第一个点之外的点，到源点的距离均为+∞
for i 1 ~ n:
    t = 不在s中的距离最近的点；
    将s添加到t中；
    使用t来更新其他点到源点的距离；dist[x] > dist[t] + w(x->t)，则把x的dist更新

模板题-AcWing 849. 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≤10^5,
图中涉及边长均不超过10000。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

题解

/*
 * @Author: IndexYang 
 * @Date: 2022-02-16 18:23:03 
 * @Last Modified by: IndexYang
 * @Last Modified time: 2022-02-16 18:59:08
 */
#include<iostream>
#include<cstring>
#include<algorithm>

const int N = 510;
using namespace std;
int m,n;
int g[N][N]; //用于稠密图存储的邻接矩阵
int dist[N]; //用于记录每一个点到第一个点之间的距离
bool st[N]; //用于记录该点的最短距离是否已经确定

int Dijistra(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0; //第一个点到自己的距离为0

    for(int i=0;i<n;i++){ //有n个点，迭代n次
        int t=-1; //t用于存储当前访问的点

        for(int j=1;j<=n;j++) //将不在st中的距离最近的点赋给t
            //不在s集合，且
            //如果没有更新过，则进行更新， 或者发现更短的路径，则进行更新
            if(!st[j] && (t==-1 || dist[t]>dist[j]))
                t = j;

        st[t] = true;

        for(int j=1;j<=n;j++) //找到了距离最小的点t，依次更新每一个点的最短距离
            if(st[j] == false)
                dist[j] = min(dist[j],dist[t] + g[t][j]);
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    else 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);
    }
    cout<<Dijistra()<<endl;
    return 0;
}

堆优化版Dijistra算法

适用情况

堆优化版Dijistra算法的时间复杂度为O(mlogn)，适用于所有边权均为正数的稀疏图中。使用邻接表来存储树或图。

算法思路

在堆优化中使用了优先队列来模拟小根堆，使得每次出队列的均为距离最短的点。
思路和朴素版的基本一致。

使用优先队列来模拟小根堆，前一个存距离，后一个参数存点.
priority_queue<PII, vector<PII>,greater<PII> > heap;

模板题-AcWing 850. 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×10^5,
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 10^9。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

题解

/*
 * @Author: IndexYang 
 * @Date: 2022-02-16 21:58:29 
 * @Last Modified by: IndexYang
 * @Last Modified time: 2022-02-16 22:58:14
 */
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
typedef pair<int,int> PII;

const int N = 150010;
//这里是使用邻接表的方式来存储稀疏图
int h[N],e[N],ne[N],w[N],idx;
int n,m;

int dist[N];
bool st[N]; //如果为true则表示该点已经被确定最短距离

    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}

int Dijistra(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    //使用优先队列来模拟小根堆，前一个存距离，后一个参数存点
    priority_queue<PII, vector<PII>,greater<PII> > heap;
    heap.push({0,1});

    while(heap.size()){
        //取不在集合s中的距离最短的点
        auto k = heap.top();
        heap.pop();
        //ver表示当前点的编号，distance表示当前点到第一个点的距离
        int ver = k.second,distance = k.first;

        if(st[ver]) continue;
        st[ver] = true; //标记该点已经确定
        //从该点出发遍历所有相邻的点，更新所有相邻点到起点的距离
        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] == 0x3f3f3f3f) return -1;
    else return dist[n];
}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<Dijistra()<<endl;
    return 0;
}

Bellman_Ford

适用情况

Bellman_ford的时间复杂度为O(nm)，使用的情况较少，大多数情况可以被SPFA所替代。适用于存在负权边的情况，尤其是用于有边数限制的最短路问题中。（不超过k条边走到的最短路）

算法思路

在每次迭代的过程中，都对dist[b]进行松弛操作，即使得
dist[b] = min(dist[b], dist[a] + w)

for k次:
    for 所有边(a,b,w):
        dist[b] = min(dist[b], dist[a] + w); 
        //这里如果是有边数限制的最短路，需要使用备份思想。

模板题-AcWing 853. 有边数限制的最短路

给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 11 号点到 nn 号点的最多经过 kk 条边的最短距离，如果无法从 11 号点走到 nn 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k

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

输出格式

输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过 10000。

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

输出样例：

3

题解

/*
 * @Author: IndexYang 
 * @Date: 2022-02-16 22:57:42 
 * @Last Modified by: IndexYang
 * @Last Modified time: 2022-02-16 23:14:16
 */
#include<iostream>
#include<cstring>
using namespace std;
const int N = 510,M = 10010;
int n,m,k;
int dist[N],backup[N];
struct Edge{
    int a,b,w;
}edges[M];

int bellman_ford(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    
    //迭代k次
    for(int i = 0;i<k;i++){
        //每次使用的都是上次的数据，防止串联更新
        memcpy(backup,dist,sizeof dist);
        for(int j=0;j<m;j++){
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b] = min(dist[b],backup[a] + w);
        }
    }
    //这里不能返回-1，防止路径长度为-1；则返回0x3f3f3f3f
    if(dist[n] > 0x3f3f3f3f /2) return 0x3f3f3f3f;
    else return dist[n];
}
int main(){
    cin>>n>>m>>k;
    for(int i =0;i<m;i++){
        int a,b,w;
        cin>>a>>b>>w;
        edges[i] = {a,b,w};
    }
    int t = bellman_ford();

    if(t == 0x3f3f3f3f) printf("impossible");
    else printf("%d",t);

    return 0;
}

SPFA

适用情况

SPFA的时间复杂度为O(m)，最坏为o(mn)，算法本身使是对Bellman_ford算法的优化，使用的范围比较广，主要应用于存在负权边的最短路问题中，不存在负环就可以使用。但是注意在适用于Dijistra算法的情况下，使用此算法可能导致TLE，因此切忌取巧。使用邻接表进行存储。

算法思路

SPFA本质是使用队列进行优化的Bellman_ford算法，这里使用邻接表进行存储树、图。 算法本身和广搜比较相似，使用队列进行存储。

queue <- 源点x
while(!queue.empty())
    t = q.front(),q.pop();
    更新所有t的出边 ( t->b /w)
    queue.push(b)

模板题-AcWing 851. spfa求最短路

给定一个 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

题解

/*
 * @Author: IndexYang 
 * @Date: 2022-02-17 13:27:28 
 * @Last Modified by: IndexYang
 * @Last Modified time: 2022-02-17 14:05:00
 */
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 10e5+10;
int h[N],e[N],ne[N],w[N],idx;
int n,m;
int dist[N];
bool st[N];

void add(int x,int y, int z){
    e[idx] = y;
    w[idx] = z;
    ne[idx] = h[x];
    h[x] = idx++;
}
int spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = true; //st数组的作用是存储在队列中的点

    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;
                }
            }
        }
    }
    return dist[n];
}
int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    while(m--){
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
    int t = spfa();
    if(t == 0x3f3f3f3f) printf("impossible");
    else printf("%d",t);

    return 0;
}

求解多源汇最短路

Floyd算法

适用情况

Floyd算法又称为for*3算法，因为其代码中有明显的三重循环。使用邻接矩阵来存储树。图。

算法思路

本算法思路比较简单，类似于暴力方法。主要需要注意的地方是初始化邻接矩阵时，自己到自己的距离为0，其余为+∞。
d[i, j]最终为从i到j的最短路。

for(k:1~n)
    for(i:1~n)
        for(j:1~n)
            d[i,j] = min(d[i,j], d[i,k] + d[k,j])

模板题-AcWing 854. Floyd求最短路

给定一个 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≤n^2
1≤m≤20000
图中涉及边长绝对值均不超过 10000。

输入样例：

3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出样例：

impossible
1

题解

/*
 * @Author: IndexYang 
 * @Date: 2022-02-17 18:52:39 
 * @Last Modified by: IndexYang
 * @Last Modified time: 2022-02-19 22:39:12
 */
#include<iostream>
#include<cstring>
using namespace std;
const int N = 210,INF = 1e9;
int n,m,k;
int d[N][N]; //d运行之后是i到j的最短路

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(){
    cin>>n>>m>>k;
    //初始化d这个数组，自己到自己的距离为0，则将i==j的地方初始化为0，其他初始化为无穷
    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;
    //输入权重
    while(m--){
        int a,b,w;
        cin>>a>>b>>w;
        d[a][b] = min(d[a][b],w);
    }

    floyd();

    while(k--){
        int a,b;
        cin>>a>>b;
        if(d[a][b] > INF/2) puts("impossible");
        else cout<<d[a][b]<<endl;
    }
    return 0;
}

结语

本次总结的最短路算法基本涉及所有最短路的基础问题，其中还有部分更为高深的部分还没涉及到，之后再次开帖子来聊。最短路算法主要是如何将问题抽象为最短路问题，之后使用最短路算法来进行解决。最短路算法也是算法竞赛中比较重要的一部分，因此之后还要细细打磨。