Floyd算法(弗洛伊德算法)

算法描述：

　　Floyd算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。从图的带权邻接矩阵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来记录两点间的最短路径。

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

算法过程：

　　把图用邻接距阵G表示出来，如果从Vi到Vj有路可达，则G[i,j]=d，d表示该路的长度；否则G[i,j]=无穷大。定义一个距阵D用来记录所插入点的信息，D[i,j]表示从Vi到Vj需要经过的点，初始化D[i,j]=j。把各个顶点插入图中，比较插点后的距离与原来的距离，G[i,j] = min( G[i,j], G[i,k]+G[k,j] )，如果G[i,j]的值变小，则D[i,j]=k。在G中包含有两点之间最短道路的信息，而在D中则包含了最短通路径的信息。比如，要寻找从V5到V1的路径。根据D，假如D(5,1)=3则说明从V5到V1经过V3，路径为{V5,V3,V1}，如果D(5,3)=3，说明V5与V3直接相连，如果D(3,1)=1，说明V3与V1直接相连。

优缺点分析：
　　Floyd算法适用于APSP(All Pairs Shortest Paths)，稠密图效果最佳，边权可正可负。此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。
　　优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单；
　　缺点：时间复杂度为O(n³)，比较高，不适合计算大量数据。

代码实现：

#include <stdio.h>
#include <stdlib.h>
#define MAXVERTEX 8
#define INF 65535
typedef char VertexType;
typedef int EdgeType;
typedef struct MGraph
{
    VertexType vertex[MAXVERTEX];
    EdgeType edge[MAXVERTEX][MAXVERTEX];
    int numvex;
    int numedge;
}MGraph;

static int D[MAXVERTEX][MAXVERTEX];
static int P[MAXVERTEX][MAXVERTEX];

void CreateMGraph(MGraph *G)
{
    int i = 0,j = 0,k = 0,w = 0;
    VertexType c;
    printf("请输入顶点数和边数:\n");
    scanf("%d,%d",&G->numvex,&G->numedge);
    for(i = 0;i < G->numvex;i++)
    {
        for(j = 0;j < G->numvex;j++)
        {
           if(i == j)
           {
               G->edge[i][j] = 0;
           }
           else
           {
               G->edge[i][j] = INF;
           }
        }
    }
    printf("请输入顶点的值:\n");
    fflush(stdin);
    scanf("%c",&c);
    while(i < G->numvex)
    {
        if(c == '\n')
            break;
        else
        {
            G->vertex[i] = c;
            i++;
            scanf("%c",&c);
        }
    }
    fflush(stdin);
    for(k = 0;k < G->numedge;k++)
    {
        printf("请输入边vi-vj所依附的顶点下标 i 和 j，以及权重w:\n");
        scanf("%d,%d,%d",&i,&j,&w);
        G->edge[i][j] = w;
        G->edge[j][i] = G->edge[i][j];
    }
}

void Floyd(MGraph *G)
{
    int i,j,k;
    //初始化
    for(i = 0;i < G->numvex;i++)
    {
        for(j = 0;j < G->numvex;j++)
        {
            D[i][j] = G->edge[i][j];
            P[i][j] = j;
        }
    }
    for(k = 0;k < G->numvex;k++)
    {
        for(i = 0;i < G->numvex;i++)
        {
            for(j = 0;j < G->numvex;j++)
            {
                if(D[i][j] > D[i][k] + D[k][j])
                {
                    D[i][j] = D[i][k] + D[k][j];
                    P[i][j] = P[i][k];
                }
            }
        }
    }
    printf("\n P矩阵为：\n");
    for(i = 0;i < G->numvex;i++)
    {
        for(j = 0;j < G->numvex;j++)
        {
           printf("%d ",P[i][j]);
        }
        printf("\n");
    }
}
void PrintPath(MGraph *G)
{
    int i,j,k;
    for(i = 0;i < G->numvex;i++)
    {
        for(j = i+1;j < G->numvex;j++)
        {
            printf("V%d-V%d minimum weight:%d  ",i,j,D[i][j]);
            k = P[i][j];
            printf("Path: V%d",i);
            while(k != j)
            {
                printf("-->V%d",k);
                k = P[k][j];
            }
            printf("-->V%d\n",j);
        }
        printf("\n");
    }
}

int main()
{
    MGraph G;
    CreateMGraph(&G);
    Floyd(&G);
    PrintPath(&G);
    return 0;
}

来源：https://www.cnblogs.com/devinblog/p/4179900.html

标签

printf

矩阵

算法

最短路径

floyd算法