节点最短路径算法改进

2744557306

实现了一种基于邻接矩阵的图算法，具体是 Floyd-Warshall 算法的一个变种，用于计算每对节点之间的最短路径。下面对代码进行逐行分析并解释算法思想。

Floyd-Warshall 算法的基本思想Floyd-Warshall 算法是一种用于求解加权图中任意两点之间最短路径的动态规划算法。它的思想是通过中间节点逐步更新路径长度，最终得到所有节点对之间的最短路径。
9 t/ p; e( R5 C6 X+ Q% F; m代码解析

[color=rgba(6, 8, 31, 0.88)]函数定义:

1. function a = dij2_m(a)

复制代码

- `a` 为输入的邻接矩阵，表示图中节点之间的边的权重。
- 输出结果也是更新后的邻接矩阵 `a`，其中的值代表任意两节点之间的最短路径距离。
7 C9 c, J: O: O* \! g
- |( O% @& L, ]1 F. |  U" f. k[color=rgba(6, 8, 31, 0.88)]将邻接矩阵变为对称矩阵[color=rgba(6, 8, 31, 0.88)]:

1. n = length(a);  , F\" M4 L+ J# w. a' ?
   
2. for i = 2:n  
   4 m( u* O. c' m
3.     for j = 1:(i-1)  
   ! ~. v. w* X/ G
4.         a(i,j) = a(j,i);  5 t' d. R/ [1 a\" Y9 J( S$ O% m! ]+ E
   
5.     end  
   ' C! F0 e2 |2 s5 W- t. {2 I
6. end

复制代码

- 这部分代码确保输入的邻接矩阵是对称的，即 \(a(i, j) = a(j, i)\)。这是因为对于无向图，节点间的距离应该是相同的。

[color=rgba(6, 8, 31, 0.88)]主程序[color=rgba(6, 8, 31, 0.88)]:

1. for k = 1:(n-1)  & y\" c\" ^2 q  @1 u# f0 T  O% Y
   
2.     b = [1:(k-1),(k+1):n]; % 初始化剩余节点  
   - _' n$ O+ j/ F3 i' M5 e
3.     kk = length(b);  
   , }, H* x& a+ K& m
4.     a_id = k;              % 当前节点    x# K$ I, A. X' S
   
5.     b1 = [(k+1):n];       % 节点的一部分  
   \" F8 h3 _7 e6 M& k
6.     kk1 = length(b1);

复制代码

- 这段代码是在外层循环中执行的。变量 `k` 表示当前考虑的中间节点。
- `b` 是未考虑的节点集合，初始为包含所有节点（除了当前节点 `k`）的数组。
- `b1` 是一组要更新的节点，将从 `k+1` 开始划分，以找到与节点 `k` 的路径。
. l) z  m% B  e3 A
+ S" l/ F- K4 p$ @" N, C9 z* N9 o( C[color=rgba(6, 8, 31, 0.88)]更新最短路径[color=rgba(6, 8, 31, 0.88)]:

1. while kk > 0  
   * d1 o6 `# h8 a; a, q$ V
2.     for j = 1:kk1  $ h  Q2 n) a# n( O+ }
   
3.         te = a(k, a_id) + a(a_id, b1(j));  
   # |: q  _- B; N% X: D! N
4.         if te < a(k, b1(j))  
   3 I2 k! z  p: D, ?* v' M/ }4 R( i
5.             a(k, b1(j)) = te;  
   : v) Y7 ?: N4 N( T7 t, n6 U+ f
6.         end  
   ; m- p; ?8 R' H1 U7 _
7.     end

复制代码

- 在 `while` 循环中，对于每个未访问节点，从当前节点 `k` 到所有在 `b1` 中节点的路径进行更新。
8 l$ \9 O8 C1 ^+ s9 ^2 y- 计算通过当前节点 `a_id` 访问 `b1` 中的每个节点的路径 `te`，如果这个新路径比已知的更短，就更新邻接矩阵。
8 Q* y4 C- J& a: }4 B2 `& ?9 f
[color=rgba(6, 8, 31, 0.88)]选择下一个节点[color=rgba(6, 8, 31, 0.88)]:

1. miid = 1;  
   - V4 e' i3 {  w% b! I, K
2. for j = 2:kk  
   . o8 w, `- E+ G1 `; s6 p5 P$ T; A
3.     if a(k, b(j)) < a(k, b(miid))  
   2 z/ y' M! l: ^. K
4.         miid = j;  - r; W+ ]! C; I6 m\" S- g
   
5.     end  ( f. \/ l* Z8 F- ^
   
6. end  8 u5 u% c1 A\" |, S- v
   
7. a_id = b(miid);          % 选取出最短路径的节点    F0 a5 @7 q$ n2 h; K
   
8. b = [b(1:(miid-1)), b((miid+1):kk)]; % 从该集合中移除选择的节点  
   9 \  j9 ~1 d( H1 p5 ?
9. kk = length(b);

复制代码

- 找到当前未访问节点中与 `k` 相连的最短距离节点，将其标记为 `a_id`，并更新集合 `b`，剔除已经访问的节点。
4 ^/ e% q9 ^" X5 `6 \$ t
. Y. b1 w7 z! D0 Z  ^& d$ T% W0 L[color=rgba(6, 8, 31, 0.88)]更新所有节点间的距离[color=rgba(6, 8, 31, 0.88)]:

1. for j = (k+1):n  ; ~4 k8 }0 [% ]& I8 z
   
2.     a(j, k) = a(k, j);  9 w4 {3 w' a5 i, h, N, w
   
3. end

复制代码

- 更新 `a` 中关于节点 `k` 的距离，保证后续节点间的对称性。

总结整体来看，这段代码通过逐步选择中间节点，并更新已处理节点之间的最短路径距离，从而计算出无向图的任意两点之间的最短路径。其核心思想是动态规划和“逐步逼近”，和传统的 Floyd-Warshall 算法有相似之处，但实现上有所变化。

" [) w7 f0 E! ~$ y此算法的时间复杂度为 \(O(V^3)\)，其中 \(V\) 是图中节点的数量，适合用于小型图的最短路径计算。
+ }8 E% F8 Z/ s, T! R3 |/ q( v0 D
* _( o* x( l, F. h3 F6 }
# Y, ?5 V" p! u7 l& J0 c9 e5 m