Floyd算法（任意两点间的最短路径）

Floyd（弗洛伊德）算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd算法的时间复杂度为O(N³)，空间复杂度为O(N²)。

算法思想：

     Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）

      从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。

算法步骤：

a.从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。 　　

b.对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。

给出矩阵，其中矩阵A是邻接矩阵，而矩阵Path记录u,v两点之间最短路径所必须经过的点

用处：可以通过以每个顶点作为源点循环求出每对顶点之间的最短路径，也可以用于求两顶点之间最短路径。

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

从图的带权邻接矩阵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)为图的距离矩阵。

其状态转移方程如下： D(k)[i,j]:=min{D(k-1)[i,k]+D(k-1) [k,j], D(k-1)[i,j]}；

优化后map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}

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

#include <stdio.h>
#define MAXV 100
#define INF 9999
typedef struct{
int edges[MAXV][MAXV];
int n,e;
}MGraph;
void ppath(int path[][MAXV],int i,int j)
{
	int k;
	k=path[i][j];
	if (k==-1)  return;
	ppath(path,i,k);
	printf("%d,",k);
	ppath(path,k,j);
}
void DisPath(int A[][MAXV],int path[][MAXV],int n)
{
	int i,j;
	for (i=0;i<n;i++)
		for (j=0;j<n;j++)
			if (A[i][j]!=INF && i!=j)
			{
				printf("  从%d到%d路径为:",i,j);
				printf("%d,",i);
				ppath(path,i,j);
				printf("%d",j);
				printf("\t路径长度为:%d\n",A[i][j]);
			}
}
void Floyd(MGraph g)	//弗洛伊德算法从每对顶点之间的最短路径
{
	int A[MAXV][MAXV],path[MAXV][MAXV];
	int i,j,k,n=g.n;
	for (i=0;i<n;i++)						//给A数组置初值
		for (j=0;j<n;j++)
		{
			A[i][j]=g.edges[i][j];
			path[i][j]=-1;
		}
	for (k=0;k<n;k++)						//计算Ak
	{
	for (i=0;i<n;i++)
		for (j=0;j<n;j++)
			if (A[i][j]>(A[i][k]+A[k][j]))
				{	A[i][j]=A[i][k]+A[k][j];
					path[i][j]=k;
				}
	}
	printf("\n输出最短路径:\n");
	DisPath(A,path,n);			//输出最短路径
}
void DispMat(MGraph g)
//输出邻接矩阵g
{
	int i,j;
	for (i=0;i<g.n;i++)
	{
		for (j=0;j<g.n;j++)
			if (g.edges[i][j]==INF)
				printf("%3s","∞");
			else
				printf("%3d",g.edges[i][j]);
		printf("\n");
	}
}
int main()
{
	int i,j;
	MGraph g;
	int B[MAXV][6]={
		{0,5,INF,7,INF,INF},
		{INF,0,4,INF,INF,INF},
		{8,INF,0,INF,INF,9},
		{INF,INF,5,0,INF,6},
		{INF,INF,INF,5,0,INF},
		{3,INF,INF,INF,1,0}};
	g.n=6;g.e=10;
	for(i=0;i<g.n;i++)
		for (j=0;j<g.n;j++)
			g.edges[i][j]=B[i][j];
			DispMat(g);
Floyd(g);
	printf("\n");
	return 0;
}

还是以上次的图为例

参考博客：最短路径—Dijkstra算法和Floyd算法 

对于两种算法的思想讲的比较详细，不懂得可以看一下。

https://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

#include <stdio.h>
#define MAXV 100
#define INF 99999
int A[MAXV][MAXV],path[MAXV][MAXV];
typedef struct
{
    int edges[MAXV][MAXV];
    int n,e;
} Mg;
void ppath(int i,int j)
{
    int k;
    k=path[i][j];
    if (k==-1)
        return;
    ppath(i,k);
    printf("%d,",k);
    ppath(k,j);
}
void DisPath(int n)
{
    int i,j;
    for (i=0; i<n; i++)
        for (j=0; j<n; j++)
            if(A[i][j]!=INF&&i!=j)
            {
                printf("从%d到%d路径为:",i,j);
                printf("%d,",i);
                ppath(i,j);
                printf("%d",j);
                printf("\t路径长度为:%d\n",A[i][j]);
            }
}
void floyd(Mg g)
{
    int i,j,k,n=g.n;
    for (i=0; i<n; i++)
        for (j=0; j<n; j++)
        {
            if(g.edges[i][j])
            {
            A[i][j]=g.edges[i][j];
            path[i][j]=-1;
            }
        }
    for (k=0; k<n; k++)
    {
        for (i=0; i<n; i++)
            for (j=0; j<n; j++)
                if (A[i][k]!=INF&&A[k][j]!=INF&&A[i][j]>(A[i][k]+A[k][j]))//注意判断条件
                {
                    A[i][j]=A[i][k]+A[k][j];
                    path[i][j]=k;
                }
    }
    for(i=0;i<n;i++)
       {
for(j=0;j<n;j++)
    {
        printf("%d ",A[i][j]);
    }
    printf("\n");
       }
    printf("\n输出最短路径:\n");
    DisPath(n);
}
int main()
{
    Mg g;
    scanf("%d %d",&g.n,&g.e);
    int i,j;
    for(i=0; i<g.n; i++)
        for(j=0; j<g.n; j++)
        {
            if(i==j)
                A[i][j]=0;
            else
                A[i][j]=INF;
        }
    for(i=g.e; i>0; i--)
    {
        int v1,v2,Q;
        scanf("%d %d %d",&v1,&v2,&Q);
        g.edges[v1][v2]=Q;
    }
    floyd(g);
    return 0;
}