C++图论 最短路问题总结

目录

最短路问题

图的存储 

一、单源最短路

① 朴素Dijkstra O(n^2)

练习题

代码 

② 堆优化Dijkstra O(mlogn)

练习题

代码

③ Bellman_ford O(nm)

练习题

代码

④ Spfa O(n) - O(nm)

练习题

​代码

二、多源最短路

Floyd O(n^3)

练习题

代码

---

最短路问题

图的存储 

稠密图(边数很大，点数很少)用邻接矩阵存储，邻接矩阵即开辟一个二维数组，g[a][b]代表a到b有一条边

稀疏图(边数与点数差不多)用邻接表存储，邻接表为链表数组，代码如下：

const int N = 1e5+5;
int h[N], e[N], ne[N], idx;

一、单源最短路

单源指的是只能从一个结点出发

① 朴素Dijkstra O(n^2)

稠密图(邻接矩阵存储)常用：此时点数较小，n*n不会超时间限制,时间复杂度为

步骤：

1. 初始化距离数组和邻接矩阵，dist[1] = 0，dist[i] = 0x3f3f3f3f，g[i] [j] = 0x3f3f3f3f

2. for外循环n(或者n-1)次遍历，再一层for循环遍历距离数组获取不在S数组里的离源点最短的点t

3. 用t更新其他的点，把t加到S集合中

练习题

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

代码 

#include
#include
#include
using namespace std;
const int N=505;
// g是邻接矩阵，因为题目数据是结点数500，边数10000，为稠密图，所以用邻接矩阵存储
//dist存放的是所有点到源点的最短距离
int g[N][N], dist[N];
//st数组是state，表示该点是否已经确定为最短路径点
bool st[N];
int n,m;
int dijkstra() {
    memset(dist, 0x3f, sizeof dist );
    dist[1] = 0;
    //第n个结点的到源点的最短路需要经过n步完成，也即确定前面n-1个点的最短路径，第n个结点才会是最短路径
    for(int i = 0; i < n ; i ++) {
        int t = -1; //dijkstra算法应用于无负权值的图
        //遍历每个点，找出目前为止离源点最近且还没确定最短路径的点
        for(int j = 1; j <= n; j ++) {
            //t等于-1确保至少第一个还没确定的点会被选中，dist[t] > dist[j]是更新t为未确定的最短的点
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        }
        /*这一步其实做了一些无用功，因为这一步实际上是遍历t所有可以到达的点并更新，但是t一般
        不会连接其余所有的点，但是g被我们初始化为最大，又是取min，所以没有影响。
        且在t前面已经有一些点被确定最短了，这些点也就不会被更新了。
        */
        for(int j = 1; j <= n; j ++)    
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        st[t] = true;
    }
    // 如果n仍然为0x3f3f3f3f代表着没有到n的最短路径。
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}
int main() {
    cin >> n >> m;
    int a, b, c;
    memset(g, 0x3f, sizeof g); //每个点之间的权值初始化为最大
    while(m--) {
        scanf("%d%d%d",&a,&b,&c);
        g[a][b] = min(g[a][b], c); //有重边取最小权值
    }
    cout << dijkstra() << endl;
    return 0;
}

② 堆优化Dijkstra O(mlogn)

稀疏图(邻接表存储)常用：此时点数较大，如果用朴素Dijkstra会超时，利用小根堆优化找dist数组中最小的未加入S集合的点，时间复杂度为

步骤

1. 初始化距离数组和邻接表，dist[1] = 0，dist[i] = 0x3f3f3f3f，h[i] = -1

2. 初始化小根堆，将{0， 1}放入堆，每次取出堆顶元素

3. 如果被确定就跳过，否则加入S集合并更新其他点，被更新的点也要加入堆中进行下一次更新

练习题

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

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

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

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

数据范围

1≤n,m≤
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

代码

#include
#include
#include
#include
using namespace std;
typedef pair PII;
const int N=1e6+5;
//稀疏图用邻接表存储，w为权重数组
int e[N],ne[N],w[N],dist[N],h[N],idx,n, m;
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 dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue, greater > p;
    //first代表距离，second代表点
    p.push({0, 1});
    while(p.size()) {
        //这一步相当于之前for循环遍历拿出dist中距离源点的最短距离的点
        auto t = p.top();
        //弹出
        p.pop();
        //ver为点， distance为到源点的距离
        int ver = t.second, distance = t.first;
        //如果这个点已经确定了那就跳过
        if(st[ver]) continue;
        st[ver] = true;
        //更新与该点相连的其它点的dist
        for(int i = h[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            if(dist[j] > dist[ver] + w[i]) {
                dist[j] = dist[ver] + w[i];
                p.push({dist[j], j});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}
int main() {
    int a, b ,c;
    cin >> n >> m;
    // 初始化链表数组头节点
    memset(h, -1, sizeof h);
    while(m--) {
        scanf("%d%d%d", &a, &b, &c);
        add(a,b,c);
    }
    cout << dijkstra() << endl;
    return 0;
}

​

注意：以上两种只适用于正权图

​

③ Bellman_ford O(nm)

Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
(通俗的来讲就是：假设 1 号点到 n 号点是可达的，每一个点同时向指向的方向出发，更新相邻的点的最短距离，通过循环 n-1 次操作，若图中不存在负环，则 1 号点一定会到达 n 号点，若图中存在负环，则在 n-1 次松弛后一定还会更新)

dijkstra为什么不能应用于负权值的边
首先我们要知道为什么dijkstra算法不能应用于有负权边得图中，因为dijkstra算法更新的时候是每次外循环都直接确定一个点为最短路径，一棒子打死，后面如果有负权边走到该点并且距离源点得距离才是最远的也更新不了了

存储结构
Bellman_ford用结构体简单存储即可，存下的是点对点以及权值，也即每条边以及其权值

稀疏图常用，直接使用结构体存储边的两端点和权值,时间复杂度为

步骤

1. 初始化距离数组，dist[1] = 0，dist[i] = 0x3f3f3f3f

2. for外循环k次，备份dist的备份数组backup

3. 内循环遍历所有的边，松弛dist[x.b] = min(dist[x.b], backup[x.a]+x.w);

4. 判断是否有无最短路径到达n，一般是dist[n] > 0x3f3f3f3f / 2，具体看题目对于边的大小范围

为什么要备份呢，因为可能出现串联，也就是在一次更新中，前面已经更新的数据影响了后面的数据 

 此时的3会因为前面的2已经变化为1而更新成2，所以我们用上一次迭代的dist数组也就是backup来更新

练习题

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

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

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

输入格式

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

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

点的编号为 1∼n。

输出格式

输出一个整数，表示从 1 号点到 nn 号点的最多经过 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
#include
#include
using namespace std;
const int N=505, M=1e5+5;
int dist[N], backup[N], n,m,k;
struct Edge {
    int a, b, w;
}edge[M]; //边集，用结构体存储
void bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < k; i ++ ) {
        //有可能出现串联，所以需要先备份一份
        memcpy(backup, dist, sizeof dist);
        //通过遍历边数组不断更新每个点的最短值，不同于dijkstra算法的一板子拍死，每次都更新全部
        //以上一次更新k-1条边的backup数组为基础来更新，每次都取最小值，因此可以找出有无到达的最短值
        for(int j = 0; j < m; j ++ ) {
            int a = edge[j].a, b = edge[j].b, w = edge[j].w;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    return ;
}
int main() {
    int a,b,w;
    cin >> n >> m >> k;
    for(int i=0;i= 0x3f3f3f3f / 2) cout << "impossible" << endl;
    else cout << dist[n] << endl;
    return 0;
}

④ Spfa O(n) - O(nm)

spfa是基于Bellman_ford优化的，在松弛的时候并不是每条边都需要更新，因此我们利用队列优化，将真正需要更新的点放入队列中，bellman_ford算法中，只有backup[a]被更新过，dist[b]才需要进行更新，所以当一个点被更新时就放入队列。简而言之：我更新过谁，我就把谁放入队列，时间复杂度为

步骤

1. 是否初始化dist都可以，dist[1] = 0，dist[i] = 0x3f3f3f3f

2. 每次取出队首元素进行更新，用st数组标记点是否在队列中，如果在的话无需重复添加

3. 如果需要辨别是否有负权环的存在，使用cnt数组记录每个点的入队次数，>=n次则证明存在

练习题

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

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

数据保证不存在负权回路。

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

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

数据范围

1≤n,m≤
图中涉及边长绝对值均不超过 10000。

输入样例：

3 3
1 2 5
2 3 -3
1 3 4

输出样例：

2

​代码

#include
#include
#include
#include
using namespace std;
typedef pair PII;
const int N=1e6+5;
//稀疏图用邻接表存储，w为权重数组
int e[N],ne[N],w[N],dist[N],h[N],idx,n, m;
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 p;
    p.push(1);
    st[1] = true;  //st数组标记的是点是否再队列中，重复放置没有任何意义
    while(p.size()) {
        auto t = p.front();  //取出队头元素进行更新
        p.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]) {   //如果j变化了且队列中没有j这个点，那么就将点放进去
                    p.push(j);
                    st[j] = true;
                }
            }
        }
    }
}
int main() {
    int a, b ,c;
    cin >> n >> m;
    // 初始化链表数组头节点
    memset(h, -1, sizeof h);
    while(m--) {
        scanf("%d%d%d", &a, &b, &c);
        add(a,b,c);
    }
    spfa();
    if(dist[n] == 0x3f3f3f3f )    cout << "impossible" << endl;
    else cout << dist[n] << endl;
    return 0;
}

bellman_ford与spfa对于dist[n]的判断为什么不同？
因为队列里都是由起点更新到的点，不存在bellman-ford算法中未更新的点同样被边更新的情况。

注意：以上两种可适用于负权图，对于dist[n]的判定也是因为负权边的存在，所以具体看题目的范围进行判断

​

二、多源最短路

多源指的是能从任意一个结点出发

Floyd O(n^3)

Floyd用于处理多源汇最短路问题，即多个源点，需要直接得出点到点的最短路，时间复杂度为

步骤

1. 初始化邻接矩阵，i == j，g[i] [j] = 0, else g[i] [j] = 0x3f3f3f3f

2. 三重for循环 i,j,k 动态规划更新 g[j] [k] = min(g[j] [k], g[j] [i] + g[i] [k]);

练习题

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

输入样例：

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

输出样例：

impossible
1

代码

#include
#include
using namespace std;
//INF如果用INT_MAX(21亿)的话用加法时会溢出
const int N = 205, INF = 1e9;
int g[N][N];
int n, m, k;
void floyd() {
    //动态规划，三重循环后ij位置是i到j的最短路径权值
    for(int i = 1 ; i <= n ; i ++ ) {
        for(int j = 1 ; j <= n; j ++ ) {
            for(int k = 1 ; k <= n; k ++ ) {
                /*
                f[1][j][k]就代表了，在考虑了1节点作为中间经过的节点时，从j到k的最短路径的长度。

                形式化说明如下：
                f[k][i][j]可以从两种情况转移而来：
                【1】从f[k−1][i][j]转移而来，表示i到j的最短路径不经过k这个节点
                【2】从f[k−1][i][k]+f[k−1][k][j]转移而来，表示i到j的最短路径经过k这个节点

                总结就是：f[k][i][j]=min(f[k−1][i][j],f[k−1][i][k]+f[k−1][k][j])
                从总结上来看，发现f[k]只可能与f[k−1]有关。
                */
                g[j][k] = min(g[j][k], g[j][i] + g[i][k]);
            }
        }
    }
}
int main() {
    cin >> n >> m >> k;
    int a, b, c;
    //多源点需要初始化每个点到自己为0，其它点为无穷大，dijkstra算法不用这样的原因是只有一个源点
    //直接初始化dist[1] = 0即可
    for(int i = 1; i <= n; i ++ ) {
        for(int j = 1 ; j <= n; j ++ ){
            if(i == j) g[i][j] = 0 ;
            else g[i][j] = INF;
        }
    }
    while(m--) {
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c);
    }
    floyd();
    int x,y;
    while(k--) {
        scanf("%d%d", &x, &y);
        if(g[x][y] > INF / 2)
        printf("impossible\n");
        else printf("%d\n", g[x][y]);

    }
    return 0;
}