图的最短路径算法

最新推荐文章于 2023-03-18 13:11:03 发布

dounineli

最新推荐文章于 2023-03-18 13:11:03 发布

阅读量2.1k

点赞数 1

分类专栏：计算机基础文章标签：算法

本文链接：https://blog.csdn.net/CQL_sure/article/details/113408006

版权

计算机基础专栏收录该内容

16 篇文章 1 订阅

订阅专栏

本文介绍了三种关键的图最短路径算法：迪杰斯特拉（Dijkstra）、弗洛伊德（Floyd）和贝尔曼-福特（Bellman-Ford），分别讨论了它们的原理、实现步骤、适用场景及其优缺点。深入理解这些算法有助于在实际项目中高效寻找最短路径。

摘要由CSDN通过智能技术生成

title: 图的最短路径算法
date: 2019-02-12 19:33:29

文章目录

0. 前言

本文将介绍求解图最短路径的三个经典算法：迪杰斯特拉 Dijkstra、弗洛伊德 Floyd、贝尔曼-福特 Bellman-Ford。

1. 迪杰斯特拉 Dijkstra

迪杰斯特拉算法，用于解决 “给定起始点到其余点的最短路径” 问题，即单源最短路径算法。时间复杂度为 $O(n^2)$ 。其本质是贪心。

算法步骤为：

用 G[n][n] 二维数组记录图数据；定义 dis[n] 一维数组记录起始点到各点的最短路径，初始化为 INF（可以是 int 的最大值）；visited[n] 一维数组记录该点是否给访问过（“访问过”表示已找到最短路径），初始化为 false。
选择起始点 s ，令 dis[s] == 0。
进行 n 次循环：
1. 先从 dis[n] 数组的所有未访问结点中，找出最小值，并记录对应下标 p ，令 visited[p] = true。
2. 更新 p 所有邻接点在 dis[n] 数组中的值，更新规则为：dis[i] = min{dis[i], dis[p]+G[p][i]}

示例及图解：

核心伪代码如下：

int dis[n];
bool visited[n];
for (int i = 0; i < n; i++) {
    dis[i] = INF;
    visited[i] = false;
}

dis[s] = 0;
for (int j = 0; j < n; j++) {
    // 找 dis 数组中的最小值
    int p = -1, min = INF;
    for (int i = 0; i < n; i++) {
        if (visited[i] == false && dis[i] < min) {
            p = i;
            min = dis[i];
        }
    }
    visited[p] = true;

    // 更新最小值所有邻接点的值
    for (int i = 0; i < n; i++) {
        if (G[p][i] == INF || visited[i]) continue;
        if (dis[i] > dis[p]+G[p][i]) {
            dis[i] = dis[p] + G[p][i];
        }
    }
}

2. 弗洛伊德 Floyd

弗洛伊德是求解图中任意两点间最短路径的算法。时间复杂度为 $O(n^3)$ 。其本质是动态规划。

算法步骤为：

任意两点间的最短距离用 d(x,y) 表示，初始值为两点相连边的权重。
遍历所有点 k，若任意两点 i 和 j，满足 d(i,j) > d(i,k) + d(k,j)，则 d(i,j) = d(i,k) + d(k,j)。

代码如下：

for (k = 1; k <= n; k++) {
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n; j++) {
            if (d[i][j] > d[i][k] + d[k][j]) {
                d[i][j] = d[i][k] + d[k][j];
            }
        }
    }
}

算法分析：Floyd 的核心思想是动态规划。

我们先定义状态：d[k][i][j]，它表示经过前 k 个节点，点 i 到点 j 的最短路径。
d[k][i][j] 可以由 d[k-1][i][j] 转移而来：
- 假设已经求出，经过前 k-1 个节点，任意两点间的最短路径。
- 那么，d[k][i][j] 就是 经过前 k-1 个节点 i 到 j 最短路径 与 经过第 k 个节点 i 到 j 最短路径 中的最小值。
- 而经过第 k 个节点 i 到 j 最短路径，就是 i 到 k 的最短路径加上 k 到 j 的最短路径。
- 最终，得出状态转移方程为：d[k][i][j] = min{d[k-1][i][j], d[k-1][i][k] + d[k-1][k][j]}。
由于 d[k][x][x] 的状态仅由 d[k-1][x][x] 转移而来，所以我们可以进行优化：d[i][j] = min{d[i][j], d[i][k] + d[k][j]}。

3. 贝尔曼-福特 Bellman-Ford

贝尔曼-福特算法，也是一个单源最短路径算法，同时它还能处理负权边。算法时间复杂度为 $O (N E)$ ， $N$ 是点的个数， $E$ 是边的个数。

算法步骤：

令源点为 s ，源点到任意点 x 的最短距离用 d(x) 表示。d(s) 初始值为0，其余初始值为无穷。
进行 $N - 1$ 次松弛操作，松弛操作即：遍历所有边，对于每一条边 e(i,j) ，如果存在 d(j) > d(i) + e(i,j) ，则令 d(j) = d(i) + e(i,j)。

代码如下：

for (i = 0; i < n-1; i++) {
    for (j = 0; j < E; j++) {
        if (d(e[j].to) > d(e[j].from) + e[j]) {
            d(e[j].to) = d(e[j].from) + e[j];
        }
    }
}