每队顶点之间的最短路径（弗洛伊德算法）

Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

路径矩阵

通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。

从图的带权邻接矩阵A=[a(i,j)] n×n开始，递归地进行n次更新，即由矩阵D(0)=A，按一个公式，构造出矩阵D(1)；又用同样地公式由D(1)构造出D(2)；……；最后又用同样的公式由D(n-1)构造出矩阵D(n)。矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度，称D(n)为图的距离矩阵，同时还可引入一个后继节点矩阵path来记录两点间的最短路径。

采用松弛技术（松弛操作），对在i和j之间的所有其他点进行一次松弛。所以时间复杂度为O(n^3);

状态转移方程

其状态转移方程如下： map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}；

map[i,j]表示i到j的最短距离，K是穷举i,j的断点，map[n,n]初值应该为0，或者按照题目意思来做。

当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路。

实现代码

#include<iostream>
using namespace std;

#define MAXV 4
#define INF 100000

typedef struct{
int edges[MAXV][MAXV];
int n;
}MGraph;

void Dispath(MGraph g,int A[][MAXV],int path[][MAXV]){

int i,j,k,s;
int apath[MAXV],d;
for(i=0;i<g.n;i++){
for(j=0;j<g.n;j++){
if(A[i][j]!=INF&&i!=j){
printf(" 从%d到%d的路径为:",i,j);

//获取到达终点的前驱
k=path[i][j];
//定义计数变量
d=0;
//将终点赋给路径数组
apath[d]=j;

while(k!=-1&&k!=i){
d++;
apath[d]=k;
k=path[i][k];
}
d++;
//将开始元素赋值给路径的尾元素
apath[d]=i;
printf("%d",apath[d]);
for(s=d-1;s>=0;s--){
printf("-->%d",apath[s]);
}
printf("\t路径长度为:%d\n",A[i][j]);
}
}
}
}

void Floyd(MGraph g){
int A[MAXV][MAXV],path[MAXV][MAXV];
int i,j,k;
for(int i=0;i<g.n;i++){
for(int j=0;j<g.n;j++){
A[i][j]=g.edges[i][j];
if(i!=j&&g.edges[i][j]<INF)
path[i][j]=i;
else
path[i][j]=-1;
}
}

for(k=0;k<g.n;k++){
for(i=0;i<g.n;i++){
for(j=0;j<g.n;j++){
if(A[i][j]>A[i][k]+A[k][j]) {
A[i][j]=A[i][k]+A[k][j];
path[i][j]=path[k][j];
}
}
}
}
Dispath(g,A,path);
}

int main(){
MGraph g;
g.n=4;
g.edges[0][0]=0;
g.edges[0][1]=5;
g.edges[0][2]=INF;
g.edges[0][3]=7;
g.edges[1][0]=INF;
g.edges[1][1]=0;
g.edges[1][2]=4;
g.edges[1][3]=2;
g.edges[2][0]=3;
g.edges[2][1]=3;
g.edges[2][2]=0;
g.edges[2][3]=2;
g.edges[3][0]=INF;
g.edges[3][1]=INF;
g.edges[3][2]=1;
g.edges[3][3]=0;
Floyd(g);
return 1;
}