弗洛伊德算法（Floyd）简介

Floyd算法适用于解决求最短路径问题，相比于Digkstra算法思路更加简单，更容易理解，但是效率会明显低很多，可以作为初步学习的一种方法。

主要思想

主要的想法就是创建一个矩阵用于记录最短距离，如果需要求最短距离的路径的话则需要创建另外一个矩阵用于记录路径，矩阵中放置中介点即可。

具体步骤

1.在主函数中创建一个矩阵，存储输入的两点间的距离。
2.在Floyd函数中，初始化记录最短距离的矩阵和记录中介点的矩阵。初始化之后将主函数的矩阵复制给记录最短距离的矩阵。
3.用三层循环不断更新最短距离。
以上仅为简要介绍，具体过程结合实例介绍。

具体例题

Problem Description：
某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

Output
对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

Sample Input
3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

Sample Output
2
-1

#include<iostream>using namespace std;#define MAXN 200
#define INF 10000000class Path
{public:int vexnum;       //点的个数 int edgnum;       //边数 int matirx[MAXN][MAXN];      //点间的距离
};int D[MAXN][MAXN];void Floyd(Path G)
{int v, w, k;//初始化floyd算法的矩阵 for(v = 0; v < G.vexnum; v++){for(w = 0; w < G.vexnum; w++){D[v][w] = G.matirx[v][w];}}for(k = 0; k < G.vexnum; k++){for(v = 0; v < G.vexnum; v++){for(w = 0; w < G.vexnum; w++){if(D[v][w] > (D[v][k] + D[k][w])){D[v][w] = D[v][k] + D[k][w];//更新最小路径 }}}}
}int main()
{int N, M;while(~scanf("%d%d",&N,&M)){Path G;G.vexnum = N;G.edgnum = M;for(int i = 0; i < N; i++){for(int j = 0; j < N; j++){if(i == j)G.matirx[i][j] = 0;elseG.matirx[i][j] = INF;}}int s,e,l;for(int i = 0; i < M; i++){cin >> s >> e >> l;if(G.matirx[s][e] > l){G.matirx[s][e] = l;G.matirx[e][s] = l; }}Floyd(G);int st, en;cin >> st >> en;if(D[st][en] >= INF)cout << -1 << endl;elsecout << D[st][en] << endl;}return 0;
}

该代码主要有以下几个部分：
1.这个类用于储存了点的个数，输入边的条数，以及各点间的距离。这里当然可以不使用类，直接使用全局变量也可以！

2.
这个主函数中的类负责记录输入的所有信息。第一个for循环用于初始化矩阵，同一个点的距离是0，其它的则是无限大（相对于出现的数据）。第二个for循环用于记录输入的点间的距离，输入时需判断是否为两点间最短的距离，因为两点间的路径可能不止一条。

3.
该部分首先将主函数中的矩阵复制给D矩阵。三重循环中，k代表的是中介点，v是起点，w是终点，三重循环足以遍历所有的情况，并完善矩阵。则各点间的距离全部记录在D矩阵中，没有路径到达的两点间的距离是无穷大。

当然，以上仅为求出最短距离，路径则需要另外加上一个记录中介点的矩阵。详见下解。

输出最短路径

#include<iostream>using namespace std;#define MAXN 200
#define INF 10000000class Path
{public:int vexnum;       //点的个数 int edgnum;       //边数 int matirx[MAXN][MAXN];      //点间的距离
};int D[MAXN][MAXN];
int P[MAXN][MAXN];       //新加入的矩阵用于记录中介点void Floyd(Path G)
{int v, w, k;//初始化floyd算法的两个矩阵 for(v = 0; v < G.vexnum; v++){for(w = 0; w < G.vexnum; w++){D[v][w] = G.matirx[v][w];P[v][w] = w;        //中介点的初始化}}for(k = 0; k < G.vexnum; k++){for(v = 0; v < G.vexnum; v++){for(w = 0; w < G.vexnum; w++){if(D[v][w] > (D[v][k] + D[k][w])){D[v][w] = D[v][k] + D[k][w];//更新最小路径 P[v][w] = k;                //更新中介点}}}}
}void PP(int v, int w)         //路径输出函数
{while( P[v][w] != w){PP(v,P[v][w]);cout << P[v][w] << "->" ;return;}return;
}int main()
{int N, M;while(~scanf("%d%d",&N,&M)){Path G;G.vexnum = N;G.edgnum = M;for(int i = 0; i < N; i++){for(int j = 0; j < N; j++){if(i == j)G.matirx[i][j] = 0;elseG.matirx[i][j] = INF;}}int s,e,l;for(int i = 0; i < M; i++){cin >> s >> e >> l;if(G.matirx[s][e] > l){G.matirx[s][e] = l;G.matirx[e][s] = l; }}Floyd(G);int st, en;cin >> st >> en;if(D[st][en] >= INF)cout << -1 << endl;else{cout << D[st][en] << endl;cout << st << "->";PP(st,en);cout << en << endl;}    }return 0;
}

可见，上述代码中的变化是多了一个矩阵并且初始化了中介点，在更新最短路径的同时更新中介点。另外便是用递归输出了路径的中间过程，但要注意首尾需要自己加上。