《数据结构》Floyd算法

Floyd算法分析：

                          Floyd算法即为求每一对顶点之间的最短路径，应用“动态规划”思想。

图结构

             *图存储方式为邻接矩阵*

基本思想：

在两点之间若加入一点能够使原路径长度变短，则加入该点，并更新路径。

过程图表：

1.仅为两点之间的距离（存储矩阵）

	A（0）	B（1）	C（2）
A（0）	0	5 AB	12 AC
B1	7 BA	0	2 BC
C2	3 CA	无穷大 CB	0

2.加入中间点A

	A（0）	B（1）	C（2）
A（0）	0	5 AB	12 AC
B（1）	7 BA	0	2 BC
C（2）	3 CA	无穷大 CB CA+AB=8 <CB(无穷大)	0

 3.加入中间点B

	A（0）	B（1）	C（2）
A（0）	0	5 AB	12 AC AB+BC=7 <AC(12)
B（1）	7 BA	0	2 BC
C（2）	3 CA	8 CAB	0

4.加入中间点C 

	A（0）	B（1）	C（2）
A（0）	0	5 AB	7 ABC
B（1）	7 BA BC+CA=5 <BA(7)	0	2 BC
C（2）	3 CA	8 CAB	0

 5.最终结果

	A（0）	B（1）	C（2）
A（0）	0	5 AB	7 ABC
B（1）	5 BCA	0	2 BC
C（2）	3 CA	8 CAB	0

 简易代码描述：

#define MAX 32767
#define N 3 // Define the maximum number of vertices
void shortpath_Floyd(int cost[N][N], int n, int dist[N][N], char path[N][N]) {
    int i, j, k;

    // 初始化距离和路径
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            dist[i][j] = cost[i][j];
            if (dist[i][j] < MAX) {
                path[i][j] = i; // 使用节点的编号作为路径的初始值
            } else {
                path[i][j] = -1; // 无路径
            }
        }
    }

    // Floyd-Warshall 算法
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                if (dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    path[i][j] = k; // 记录中间节点
                }
            }
        }
    }
}

代码解释

1. 初始化：

   • dist[i][j] 直接设为 cost[i][j]。
   • path[i][j] 设为起始点 (i)（对于可直接到达的点）。

2. 算法核心：

   • 对每个中间点 (k)，尝试通过 (k) 来更新 (i) 到 (j) 的最短路径。