最短路 Floyd + Dijkstra

1. 问题

在一给定的有向图 $G<V,E>$ 中，V代表点集，$E<u,v,w>$ 代表连接顶点 $u$ 与顶点 $v$ 且边权为w的边集。给定顶点 $S$ 和起点 $E$，要求出 $S$ 点到 $E$ 点的总权值的最小路径，即最短路问题。

• 用$Floyd$ 算法求解下图各个顶点的最短距离，并求得距离矩阵（顶点之间的最短距离矩阵）。

  

• 对于下图使用 $Dijkstra$ 算法求由顶点 $a$ 到顶点 $h$ 的最短路径。

2. 解析

$Floyd$ 算法：

• $Floyd$ 算法的本质是 $dp$ 状态转移，设三维数组 $mp[k][i][j]$，$k$ 代表可以经过 $[1,k]$ 区间中的顶点(可以经过也可以不经过其中某个点)，$i$ 和 $j$ 分别代表起点和终点，那么 $mp[k][i][j]$ 代表能够经过 $[1,k]$ 区间结点的 $i$ 结点到 $j$ 结点的最短距离。对于从 $i$ 结点到 $j$ 结点有两个状态，即我们可以选择不经过 $k$ 结点，也可以选择经过 $k$ 结点。那么状态转移方程如下：$mp[k][i][j]=min(mp[k-1][i][j],mp[k-1][i][k]+mp[k-1][k][j])$

• $k$ 循环必须放在最外层，因为 $k$ 同时也代表了当前状态转移的层数。如果 $k$ 循环放在最内层，无法确保状态转移的正确性，例如我们必须先递推完 $(k=1,mp[k][i][j])$ 的情况，我们才能通过 $k=1$ 这层状态，转移到 $(k=2,mp[k][i][j])$ 这层状态上，$mp[0][i][j]$ 为最初始邻接矩阵图的状态，这里还可以使用滚动数组进行空间压缩。

for (int k=1;k<=n;k++) {
    for (int i=1;i<=n;i++) {
        for (int j=1;j<=n;j++) {
            mp[k][i][j] = min(mp[k-1][i][j],mp[k-1][i][k]+mp[k-1][k][j]);
            //通过滚动数组对第一维进行压缩，就可以得到如下二维的dp数组
            mp[i][j] = min(mp[i][j],mp[i][k]+mp[k][j]);
        }
    }
}

$Dijkstra$ 算法：

• $Dijkstra$ 算法基于贪心算法，通过 $Select$ 和 $Slack$ 两个操作不断更新源点 $S$ 到点 $V$ 的距离，最后得到的 $dis[i]$ 数组即源点 $S$ 到点 $i$ 的最近距离，若 $dis[i]$ 数组的值仍等于初始化的无穷大，说明源点 $S$ 无法到达点 $i$。

• $Select:$ 即点 $V$ 的选择操作，我们每次需要从图中找到一个距离源点 $S$ 最近的点 $V$，即当前 $dis[V]$ 最小的点，并且满足这个点 $V$ 未被 $vis$ 数组标记，然后将其标记，然后对这个点 $V$ 相连的边进行 $Slack$ 操作。

• $Slack:$ 即边的松弛操作，我们遍历 $Select$ 得到的点 $V$ 所有的边，如果存在点 $K$ 的 $dis[K]$ 大于 $dis[V]+mp[V][K]$，我们就可以成功松弛这条边，让源点 $S$ 到点 $K$ 的最短路径更新为经过点 $V$ 到达点 $K$ 的最短路径，使得源点 $S$ 到 $K$ 的最短距离更新，即更新 $dis[K]$。

3. 设计

Floyd算法：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+10;

int n,m,k;
int mp[110][110];


/**
 * 存单向边
 */
void add(int u,int v,int w) {
    mp[u][v] = min(mp[u][v],w);
}

/**
 * Floyd算法
 */
void floyd() {
    for (int k=1;k<=n;k++) {
        for (int i=1;i<=n;i++) {
            for (int j=1;j<=n;j++) {
                mp[i][j] = min(mp[i][j],mp[i][k]+mp[k][j]);
            }
        }
    }
}

void run() {
	scanf("%d %d",&n,&m);
    int u,v,w;
    memset(mp,0x3f3f3f3f,sizeof mp);
    for (int i=1;i<=m;i++) {
        scanf("%d %d %d",&u,&v,&w);
        add(u,v,w);
    }
	floyd();
    puts("the distance matrix is:");
    for (int i=1;i<=n;i++) {
        for (int j=1;j<=n;j++) {
            printf("%d ",i==j?0:mp[i][j]);
        }
        puts("");
    }
}

int main() {
    run();
    return 0;
}

/*
4 8
4 1 5
1 4 4
4 3 12
3 4 1
3 1 7
1 3 6
1 2 2
2 3 3
*/

Dijkstra算法：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+10;
const int inf = 0x3f3f3f3f;

int n,m,k,idx;
int mp[110][110],dis[110],vis[110],pre[110];
map<char,int>a;
map<int,char>b;
char st,ed;


/**
 * 存单向边
 */
void add(int u,int v,int w) {
    mp[u][v] = min(mp[u][v],w);
}

/**
 * 将字母顶点映射为数字编号，并将数字编号映射为字母顶点方便输出路径
 */
int get(char ch) {
    if (!a[ch]) {
        a[ch] = ++idx;
        b[idx] = ch;
    }
    return a[ch]; 
}

/**
 * Dijkstra算法
 */
int dijkstra(int st,int ed) {
    memset(dis,inf,sizeof dis);
    for (int i=1;i<=n;i++) {
        dis[i] = mp[st][i];
        if (dis[i] != inf && i != st) {
            pre[i] = st;
        }
    }
    vis[st] = 1;
    for (int i=1;i<n;i++) {

        /**
         * 寻找未被标记，且当前距离源点最近的点k
         */
        int mi = inf, k;
        for (int j=1;j<=idx;j++) {
            if (!vis[j] && dis[j] < mi) {
                mi = dis[j];
                k = j;
            }
        }

        /**
         * 将k点标记
         */
        vis[k] = 1;

        /**
         * 对k点相邻的边进行松弛操作,即
         * 更新源点到达每个j点的最短距离
         */
        for (int j=1;j<=n;j++) {
            if (dis[j] > dis[k] + mp[k][j]) {
                dis[j] = dis[k] + mp[k][j];
                pre[j] = k;
            }
        }
    }
    return dis[ed];
}

/**
 * 打印最短路径
 */
void getPath(int u) {
    if (get(st) == u) {
        printf("The shortest path is %c",b[u]);
        return;
    }
    getPath(pre[u]);
    printf("->%c",b[u]);
}

void run() {
	scanf("%d %d",&n,&m);
    char u,v;
    int w;
    memset(mp,inf,sizeof mp);
    for (int i=1;i<=n;i++) mp[i][i] = 0;
    for (int i=1;i<=m;i++) {
        scanf(" %c %c %d",&u,&v,&w);
        add(get(u),get(v),w);
    }
    scanf(" %c %c",&st,&ed);
    int res = dijkstra(get(st),get(ed));
    if (res == inf) {
        puts("No path");
        return;
    }
    printf("The shortest distance From %c To %c = %d\n",st,ed,res);
    getPath(get(ed));
}

int main() {
    run();
    return 0;
}

/*
8 11
a b 1
b d 2
c a 2
d c 1
e d 2
d f 8
f e 2
e g 2
g f 3
h f 2
g h 3
a h
*/

4. 分析

$Floyd$ 算法需要遍历三重循环，故总时间复杂度为$O(n^3)$。

$Dijkstra$ 算法需要对点集 $V$ 进行 $Select$ 操作，并对选取到的点 $K$ 通过邻接矩阵，遍历与点 $K$ 相邻的边进行 $Slack$ 操作，故总时间复杂度为 $O(n^2)$。

5. 源码

https://github.com/a894985555/Algorithm/tree/main/%E6%9C%80%E7%9F%AD%E8%B7%AF