数学建模：图论模型 — 最短路算法 (Dijkstra 算法与 Floyd 算法) 及 Python 实现

最新推荐文章于 2024-07-01 11:30:00 发布

Charle4Leclerc

最新推荐文章于 2024-07-01 11:30:00 发布

阅读量1.8k

点赞数 1

分类专栏：数学建模文章标签：图论算法数据结构 python 数据分析

本文链接：https://blog.csdn.net/qq_55851911/article/details/124775249

版权

数学建模专栏收录该内容

17 篇文章 44 订阅

订阅专栏

本文详细介绍了Dijkstra算法和Floyd算法，用于求解图中固定起点到其余各点的最短路径以及任意两点间的最短路径。Dijkstra算法通过逐步标记顶点的方式找到最短路径，而Floyd算法则通过动态规划计算所有顶点对的最短路径。同时，文中给出了两种算法的Python实现示例，帮助理解算法原理。

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

Dijkstra 算法 (求固定起点到其余各点的最短路)

Dijkstra 算法时寻求从一固定起点 $u_{0}$ 到其余各点的最短路最有效的算法之一, 由 E. W. Dijkstra 于 1959 年提出.

Dijkstra 算法的理论依据是一个重要而明显的性质: 最短路是一条路, 最短路上的任一子段也是最短路.

Dijkstra 算法的基本思想是：按距固定起点 $u_{0}$ 从近到远为顺序, 依次求得 $u_{0}$ 到图 $G$ 各顶点的最短路和距离, 直至某个顶点 $v_{0}$ (或直至图 $G$ 的所有顶点).

步骤

设图 $G$ 有 $n$ 个顶点; 边的长度 $\ell_{i j} \geqslant 0$ ; 若结点 $v_i$ 和 $v_j$ 不相连, 则令 $\ell_{ij}=\infty$ , 对每个结点 $v_i$ , 令 $\ell_{ii}=0$ .

将顶点集 $V$ 分成两部分，一部分为具有 $P$ （永久性）标号的集合，另一部分为具有 $T$ （暂时性）标号的集合。
结点 $v$ 的 $P$ 标号是指从 $v_1$ 到 $v$ 的最短路径的长度；顶点 $u$ 的 $T$ 标号是指从 $v_1$ 到 $u$ 某条路径的长度。
Dijkstras 算法首先将 $v_1$ 取为 $P$ 标号，其余结点取为 $T$ 标号，逐步将具有 $T$ 标号的结点改为 $P$ 标号。当结点 $v_n$ 被改为 $P$ 标号时，就找到一条从 $v_1$ 到 $v_n$ 的最短路径。

Step 1: 初始化

将 ${v}_{1}$ 置为 ${P}$ 标号, ${d}\left({v}_{1}\right)=0, {P}=\left\{{v}_{1}\right\}; \forall {v}_{{i}}({i} \neq 1)$ , 置 ${v}_{{i}}$ 为 ${T}$ 标号, 即 $T = V - P$ , 且
$\begin{cases} d\left(v_{i}\right)=W\left(v_{1}, v_{i}\right), &\text{若} v_{i} v_{1} \text{相邻} \\ d\left(v_{i}\right)=\infty, \quad &\text{否则} \end{cases}$

Step 2: 找最小

寻找具有最小值的 $T$ 标号的结点。若为 $v_l$ ，则将 $v_l$ 的 $T$ 标号改为 $P$ 标号，且 $\cup \{v_l\}，T=T-\{v_l\}$ 。

Step 3：修改

修改与 ${v_l}$ 相邻的结点的 $T$ 标号的值。 $\forall {v_i} \in {T}$ :
$d(v_i)=\left\{\begin{array}{ll} d\left(v_{l}\right)+W\left(v_{l}, v_{i}\right) &\text { 若 } d\left(v_{1}\right)+W\left(v_{i}, v_{i}\right)<d\left(v_{i}\right) \\ d\left(v_{i}\right) \quad &\text { 否则 } \end{array}\right.$

Step 4：重复 (2) 和 (3)，直到 $v_n$ 改为 $P$ 标号为止。

示例

求无向图最短路

无向狄克斯特拉

Step 1:
$P=\{v_1(0)\}$
$T=\{v_2(1,v_1),v_3(4,v_1),v_4(\infty),v_5(\infty),v_6(\infty\}$
Step 2:
$P=\{v_1(0),v_2(1,v_1)\}$
$T=\{v_3(3,v_1,v_2),v_4(8,v_1,v_2),v_5(6,v_1,v_2),v_6(\infty)\}$
Step 3:
$P=\{v_1(0),v_2(1,v_1) , v_3(3,v_1,v_2)\}$
$T=\{v_4(8,v_1,v_2),v_5(4,v_1,v_2,v_3),v_6(\infty)\}$
Step 4:
$P=\{v_1(0),v_2(1,v_1) , v_3(3,v_1,v_2),v_5(4,v_1,v_2,v_3)\}$
$T=\{v_4(7,v_1,v_2,v_3,v_5),v_6(10,v_1,v_2,v_3,v_5)\}$
Step 5:
$P=\{v_1(0),v_2(1,v_1) , v_3(3,v_1,v_2),v_5(4,v_1,v_2,v_3),v_4(7,v_1,v_2,v_3,v_5)\}$
$T=\{v_6(9,v_1,v_2,v_3,v_5,v_4)\}$
Step 6:
$P=\{v_1(0),v_2(1,v_1) , v_3(3,v_1,v_2),v_5(4,v_1,v_2,v_3),v_4(7,v_1,v_2,v_3,v_5),v_6(9,v_1,v_2,v_3,v_5,v_4)\}$
${ } T=\{\}$

即

$\begin{array}{l|ccccc} & {v}_{2} & {v}_{3} & {v}_{4} & {v}_{5} & {v}_{6} & \\ \hline \operatorname{Step} 1 & 1({v_{1}}) & 4 & \infty & \infty & \infty & (v_2)第1短 \\ \operatorname{Step} 2 & & 3(v_2) & 8 & 6 & \infty & (v_3)第2短 \\ \operatorname{Step} 3 & & & 8 & 4 (v_{3}) & {\infty} & (v_5)第3短 \\ \operatorname{Step} 4 & & & 7 (v_{5}) & & 10 & (v_4)第4短 \\ \operatorname{Step} 5 & & & & & 9 (v_{4}) & (v_6)第5短 \end{array}$

所以 $v_1$ 到各顶点的最短路径和距离分别为:
$v_2: v_1 \rightarrow v_2 \quad (1)$
$v_3: v_1 \rightarrow v_2 \rightarrow v_3 \quad (3)$
$v_5: v_1 \rightarrow v_2 \rightarrow v_3 \rightarrow v_5 \quad (4)$
$v_4: v_1 \rightarrow v_2 \rightarrow v_3 \rightarrow v_5 \rightarrow v_4 \quad (7)$
$v_6: v_1 \rightarrow v_2 \rightarrow v_3 \rightarrow v_5 \rightarrow v_4 \rightarrow v_6 \quad (9)$

求有向图最短路

有向狄克斯特拉
仿照上例

$\begin{array}{c|ccccccr} & {v}_{2} & {v}_{3} & {v}_{4} & {v}_{5} & {v}_{6} & {v}_{7} & \\ \hline \operatorname{Step} 1 & 2 & 5 & 3 & \infty & \infty & \infty & 2\left(v_{2}\right) \text { 第1短 } \\ \operatorname{Step} 2 & & 4 & 3 & \infty & 9 & \infty & 3\left(v_{4}\right) \text { 第2短 } \\ \operatorname{Step} 3 & & 4 & & 8 & 9 & \infty & 4\left(v_{3}\right) \text { 第3短 } \\ \text {Step } 4 & & & & 7 & 9 & \infty & 7\left(v_{5}\right) \text { 第4短 } \\ \text {Step } 5 & & & & & 8 & 14 & 8\left(v_{6}\right) \text { 第5短 } \\ \text {Step } 6 & & & & & & 13 & 13\left(v_{7}\right) \text { 第6短 } \end{array}$

Python 实现

import numpy as np
def Dijkstra_all_minpath(matr,start): #matr为邻接矩阵的数组，start表示起点
    n=len( matr) #该图的节点数
    dis=[]; temp=[]
    dis.extend(matr[start])  #添加数组matr的start行元素
    temp.extend(matr[start]) #添加矩阵matr的start行元素
    temp[start] = np.inf  #临时数组会把处理过的节点的值变成 \infty
    visited=[start]  #start已处理
    parent=[start]*n   #用于画路径，记录此路径中该节点的父节点
    while len(visited)<n:
        i= temp.index(min(temp)) #找最小权值的节点的坐标
        temp[i]=np.inf
        for j in range(n):
            if j not in visited:
                if (dis[i]+ matr[i][j])<dis[j]:
                    dis[j] = temp[j] =dis[i]+ matr[i][j]
                    parent[j]=i  #说明父节点是i
        visited.append(i)  #该索引已经处理了
        path=[]  #用于画路径
        path.append(str(i))
        k=i
        while(parent[k]!=start):  #找该节点的父节点添加到path，直到父节点是start
            path.append(str(parent[k]))
            k=parent[k]
        path.append(str(start))
        path.reverse()   #path反序产生路径
        print(str(i)+':','->'.join(path))  #打印路径
    return dis

Floyd 算法 (求每对顶点间的最短路算法)

要求每对顶点间的最短路, 可多次使用 Dijkstra 算法, 每次以不同的顶点作为起点, 用 Dijkstra 算法求出从该起点到其余顶点的最短路径, 反复执行 $n - 1$ 次这样的操作, 就可得到每对顶点之间的最短路. 但这样做需要大量的重复计算, 效率不高. R. W. Floyd 于 1962 年提出了一个直接寻求任意两顶点之间最短路的算法.

迭代方式

Floyd 算法是一个经典的动态规划算法, 其基本思想是递推产生一个矩阵序列 $A_{1}, A_{2}, \cdots, A_{k}, \cdots, A_{n}$ , 其中矩阵 $A_{k}=\left(a_{k}(i, j)\right)_{n \times n}$ , 其第 $i$ 行第 $j$ 列元素 $a_{k}(i, j)$ 表示从顶点 $v_{i}$ 到顶点 $v_{j}$ 的路径上所经过的顶点序号不大于 $k$ 的最短路径长度.

计算时用迭代公式
$a_{k}(i, j)=\min \left(a_{k-1}(i, j), a_{k-1}(i, k)+a_{k-1}(k, j)\right),$

$k$ 是迭代次数, $\cdots, n$ . $A_0$ 为邻接矩阵, 当 $k = n$ 时, $A_{n}$ 即是各顶点之间的最短距离值.

路由矩阵

如果在求得两点间的最短距离时, 还需要求得两点间的最短路径, 需要在上面距离矩阵 $A_{k}$ 的迭代过程中, 引入一个路由矩阵 $R_{k}=\left(r_{k}(i, j)\right)_{n \times n}$ 来记录两点间路径的前驱后继关系, 其中 $r_{k}(i, j)$ 表示从顶点 $v_{i}$ 到顶点 $v_{j}$ 的路径经过编号为 $r_{k}(i, j)$ 的顶点.

路由矩阵的迭代过程如下:

(1) 初始时
${R}_{0}=\boldsymbol{0}_{n \times n}$
(2) 迭代公式为
$R_{k}=\left(r_{k}(i, j)\right)_{n \times n},$

其中
$r_{k}(i, j)=\left\{\begin{array}{l} k, \quad \text { 若 } a_{k-1}(i, j)>a_{k-1}(i, k)+a_{k-1}(k, j), \\ r_{k-1}(i, j), \quad \text { 否则. } \end{array}\right.$

直到迭代到 $k = n$ , 算法终止.

查找最短路径

查找 $v_{i}$ 到 $v_{j}$ 最短路径的方法如下:

若 $r_{n}(i, j)=p_{1}$ , 则点 $v_{p_{1}}$ 是顶点 $v_{i}$ 到顶点 $v_{j}$ 的最短路的中间点, 然后用同样的方法再分头查找. 若

(1) 向顶点 $v_{i}$ 反向追踪得: $r_{n}\left(i, p_{1}\right)=p_{2}, r_{n}\left(i, p_{2}\right)=p_{3}, \cdots, r_{n}\left(i, p_{s}\right)=0$ ;

(2) 向顶点 $v_{j}$ 正向追踪得: $r_{n}\left(p_{1}, j\right)=q_{1}, r_{n}\left(q_{1}, j\right)=q_{2}, \cdots, r_{n}\left(q_{t}, j\right)=0$ ;

则由点 $v_{i}$ 到 $v_{j}$ 的最短路径为: $v_{i}, v_{p_{s}}, \cdots, v_{p_{2}}, v_{p_{1}}, v_{q_{1}}, v_{q_{2}}, \cdots, v_{q_{t}}, v_{j}$ .

示例

Floyd

迭代 0:
$A_{0}=\left[\begin{array}{c} 0 & 4 & 6 & \infty & \infty & \infty \\ 4 & 0 & 2 & 2 & 1 & \infty \\ 6 & 2 & 0 & \infty & 2 & \infty \\ \infty & 2 & \infty & 0 & 1 & 3 \\ \infty & 1 & 2 & 1 & 0 & 7 \\ \infty & \infty & \infty & 3 & 7 & 0 \end{array}\right], {R}_{0}=(0)_{6 \times 6}$

迭代 1: $A_1$ 的元素 $a (i, j)$ 的意义为 $i$ 直接到达 $j$ 及经节点 1 到达 ${j}$ 的两种方式中, 最短路线的距离
$\mathrm{A}_{1}=\left[\begin{array}{c} 0 & 4 & 6 & \infty & \infty & \infty \\ 4 & 0 & 2 & 2 & 1 & \infty \\ 6 & 2 & 0 & \infty & 2 & \infty \\ \infty & 2 & \infty & 0 & 1 & 3 \\ \infty & 1 & 2 & 1 & 0 & 7 \\ \infty & \infty & \infty & 3 & 7 & 0 \end{array}\right] , {R}_{1}=\left[\begin{array}{c} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{array}\right]$

迭代 2: $A_2$ 的元素 $a (i, j)$ 的意义为 $i$ 直接到达 $j$ 及最多经节点 1, 2 到达 ${j}$ 的所有方式中, 最短路线的距离
$A_{2}=\left[\begin{array}{c} 0 & 4 & 6 & 6 & 5 & \infty \\ 4 & 0 & 2 & 2 & 1 & \infty \\ 6 & 2 & 0 & 4 & 2 & \infty \\ 6 & 2 & 4 & 0 & 1 & 3 \\ 5 & 1 & 2 & 1 & 0 & 7 \\ \infty & \infty & \infty & 3 & 7 & 0 \end{array}\right], R_{2}=\left[\begin{array}{c} 0 & 0 & 0 & 2 & 2 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 2 & 0 & 0 \\ 2 & 0 & 2 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{array}\right]$

迭代 3:
$\mathrm{A}_{3}=\left[\begin{array}{c} 0 & 4 & 6 & 6 & 5 & \infty \\ 4 & 0 & 2 & 2 & 1 & \infty \\ 6 & 2 & 0 & 4 & 2 & \infty \\ 6 & 2 & 4 & 0 & 1 & 3 \\ 5 & 1 & 2 & 1 & 0 & 7 \\ \infty & \infty & \infty & 3 & 7 & 0 \end{array}\right], {R}_{3}=\left[\begin{array}{c} 0 & 0 & 0 & 2 & 2 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 2 & 0 & 0 \\ 2 & 0 & 2 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{array}\right]$

迭代 4:
$\mathrm{A}_{4}=\left[\begin{array}{c} 0 & 4 & 6 & 6 & 5 & 9 \\ 4 & 0 & 2 & 2 & 1 & 5 \\ 6 & 2 & 0 & 4 & 2 & 7 \\ 6 & 2 & 4 & 0 & 1 & 3 \\ 5 & 1 & 2 & 1 & 0 & 4 \\ 9 & 5 & 7 & 3 & 4 & 0 \end{array}\right], {R}_{4}=\left[\begin{array}{c} 0 & 0 & 0 & 2 & 2 & 4 \\ 0 & 0 & 0 & 0 & 0 & 4 \\ 0 & 0 & 0 & 2 & 0 & 4 \\ 2 & 0 & 2 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 4 \\ 4 & 4 & 4 & 0 & 4 & 0 \end{array}\right]$

迭代 5:
$\mathrm{A}_{5}=\left[\begin{array}{c} 0 & 4 & 6 & 6 & 5 & 9 \\ 4 & 0 & 2 & 2 & 1 & 5 \\ 6 & 2 & 0 & 3 & 2 & 6 \\ 6 & 2 & 3 & 0 & 1 & 3 \\ 5 & 1 & 2 & 1 & 0 & 4 \\ 9 & 5 & 6 & 3 & 4 & 0 \end{array}\right], {R}_{5}=\left[\begin{array}{c} 0 & 0 & 0 & 2 & 2 & 4 \\ 0 & 0 & 0 & 0 & 0 & 4 \\ 0 & 0 & 0 & 5 & 0 & 5 \\ 2 & 0 & 5 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 4 \\ 4 & 4 & 5 & 0 & 4 & 0 \end{array}\right]$

迭代 6 ( $n$ ): 任意两节点之间的最短路, 最多可经过节点 $\ldots n$ 到达, 因此当迭代 ${n}$ 次时, 算法结束, 得到任意两点间的最短路及其距离.如本例题中, 节点 $1, 6$ 之间的最短路为 $1 - 2 - 4 - 6$ , 距离为 $9$ ; 节点 $3, 4$ 之间的最短路为 $3 - 5 - 4$ , 距离为 $3$ ; 节点 $6, 4$ 之间的最短路为 $6 - 4$ , 距离为 $3$ , 等等.

$\mathrm{A}_{6}=\left[\begin{array}{c} 0 & 4 & 6 & 6_{124} & 5_{125} & 9_{1246} \\ 4 & 0 & 2 & 2 & 1 & 5_{246} \\ 6 & 2 & 0 & 3_{354} & 2 & 6_{3546} \\ 6_{421} & 2 & 3_{453} & 0 & 1 & 3 \\ 5_{521} & 1 & 2 & 1 & 0 & 4_{546} \\ 9_{6421} & 5_{642} & 6_{6453} & 3 & 4_{645} & 0 \end{array}\right], {R}_{6}=\left[\begin{array}{c} 0 & 0 & 0 & 2 & 2 & 4 \\ 0 & 0 & 0 & 0 & 0 & 4 \\ 0 & 0 & 0 & 5 & 0 & 5 \\ 2 & 0 & 5 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 4 \\ 4 & 4 & 5 & 0 & 4 & 0 \end{array}\right]$

Python 实现

import numpy as np
def floyd(graph):
    m = len(graph)
    dis = graph
    path = np.zeros((m, m))  #路由矩阵初始化
    for k in range(m):
        for i in range(m):
            for j in range(m):
                if dis[i][k] + dis[k][j] < dis[i][j]:
                    dis[i][j] = dis[i][k] + dis[k][j]
                    path[i][j] = k
    return dis, path
    # dis 为各顶点的最短距离矩阵
    # path 为路由矩阵

Charle4Leclerc

关注

1
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
数学建模：图论模型 — 最短路算法 (Dijkstra 算法与 Floyd 算法) 及 Python 实现

目录Dijkstra 算法 (求固定起点到其余各点的最短路)步骤示例Python 实现Floyd 算法 (求每对顶点间的最短路算法)迭代方式路由矩阵查找最短路径示例Python 实现Dijkstra 算法 (求固定起点到其余各点的最短路)Dijkstra 算法时寻求从一固定起点 u0u_{0}u0 到其余各点的最短路最有效的算法之一, 由 E. W. Dijkstra 于 1959 年提出.Dijkstra 算法的理论依据是一个重要而明显的性质: 最短路是一条路, 最短路上的任一子段也是最短路.D
复制链接

扫一扫