【图论——第六讲】Floyd算法求多源最短路问题

ฅ(๑˙o˙๑)ฅ 大家好, 欢迎大家光临我的博客:面向阿尼亚学习
算法学习笔记系列持续更新中~

阿


文章目录

  • 一、前言
  • 二、Floyd算法
  • 最后


一、前言

单源最短路,指的是求一个点,到其他所有点的最短距离。即起点是固定的,单一的
那么多源最短路就是指每一个点到图中其他顶点的最短路

注意:最短路问题的核心在于,把问题抽象成一个最短路问题,并建图。图论相关的问题,不侧重于算法原理,而侧重于对问题的抽象。


二、Floyd算法

Floyd 属于多源最短路径算法,能够求出任意2个顶点之间的最短路径,支持负权边
时间复杂度 O(n^3), n 表示点数。
Floyd算法时间复杂度很高,但效率比执行 n次 Dijkstra 算法要好。

算法解释

从任意顶点 i 到任意顶点 j 的最短路径不外乎两种可能
① 直接从 i 到 j
② 从 i 经过若干个顶点到 j

  • 假设 dist(i,j) 为顶点 i 到顶点 j 的最短路径的距离
  • 对于每一个顶点 k,检查 dist(i,k) + dist(k,j)<dist(i,j) 是否成立
  • 如果成立,证明从 i 到 k 再到 j 的路径比 i 直接到 j 的路径短,设置 dist(i,j) = dist(i,k) + dist(k,j)
  • 当我们遍历完所有结点 k,dist(i,j) 中记录的便是 i 到 j 的最短路径的距离

算法实现
初始化

    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;
// 算法结束后,d[a][b]表示a到b的最短距离

核心代码只有四行

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]);
}

求任意两个点之间的最短路

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

样例

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

impossible
1

#include 
using namespace std;

const int N = 210, M = 2e+10, INF = 1e9;

int n, m, k, x, y, z;
int d[N][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]);
    //            if(d[i][j]>d[i][k]+d[k][j])
     //           d[i][j]=d[i][k]+d[k][j];
}

int main() {
    cin >> n >> m >> k;
    //初始化
    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--) {
        cin >> x >> y >> z;
        d[x][y] = min(d[x][y], z);
        //注意保存最小的边
    }
    floyd();
    while(k--) {
        cin >> x >> y;
        if(d[x][y] > INF/2) puts("impossible");
        //由于有负权边存在所以约大过INF/2也很合理
        else cout << d[x][y] << endl;
    }
    return 0;
}

最后

莫言真理无穷尽,寸进自有寸进欢

【图论——第六讲】Floyd算法求多源最短路问题_第1张图片

你可能感兴趣的:(图论,图论,算法,数据结构)