Floyed

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

#define MaxVertices 100
#define MaxWeight 32767
#define MAXV 10
#define INF 32767

typedef struct {            //无向图
    char Vertices[MaxVertices];  //顶点信息的数组
    int Edge[MaxVertices][MaxVertices]; //边的权信息的数组
    int vexnum;         //顶点数
    int arcnum;         //边数
}MGraph;

void CreateGraph(MGraph* G) //图的生成函数
{
    int n, e, vi, vj, w, i, j;
    printf("请输入图的顶点数和边数：");
    scanf("%d%d", &n, &e);
    G->vexnum = n; G->arcnum = e;
    for (i = 0; i < n; i++) //图的初始化
        for (j = 0; j < n; j++)
        {
            if (i == j)
                G->Edge[i][j] = 0;      //点自己到自己的长度为0
            else
                G->Edge[i][j] = 32767;  //初始设置任意不同两点直接距离为无穷大
        }

    for (i = 0; i < n; i++)
        for (i = 0; i < n; i++) //将顶点存入数组中
        {
            printf("请输入第%d个顶点的信息(整型):", i + 1);
            scanf(" %c", &G->Vertices[i]);
        }
    printf("\n");

    for (i = 0; i < G->arcnum; i++)
    {
        printf("请输入边的信息i,j,w:");
        scanf("%d%d%d", &vi, &vj, &w);
        //若为不带权值的图，则w输入1
        //若为带权值的图，则w输入对应权值

        G->Edge[vi - 1][vj - 1] = w;
        G->Edge[vj - 1][vi - 1] = w;    //无向图需加上此行
    }
}

void DispGraph(MGraph G) //输出邻接矩阵的信息
{
    int i, j;
    printf("\n输出顶点的信息（整型）:\n");
    for (i = 0; i < G.vexnum; i++)
        printf("%8c", G.Vertices[i]);

    printf("\n输出邻接矩阵:\n");
    printf("\t");
    for (i = 0; i < G.vexnum; i++)
        printf("%8c", G.Vertices[i]);

    for (i = 0; i < G.vexnum; i++)
    {
        printf("\n%8d", i + 1);
        for (j = 0; j < G.vexnum; j++)
        {
            if (G.Edge[i][j] == 32767)
                //两点之间无连接时权值为默认的32767，但输出时为了方便输出 "∞"
                printf("%8s", "∞");
            else
                printf("%8d", G.Edge[i][j]);
        }
        printf("\n");
    }
}
void Ppath(int path[][MaxVertices], 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[][MaxVertices], int path[][MaxVertices], int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (A[i][j] == INF)
            {
                if (i != j)
                {
                    printf("从%d到%d没有路径\n", i, j);
                }
            }
            else
            {
                printf("  从%d到%d的最短路径长度为：%d ", i, j, A[i][j]);
                printf("路径：%d->", i);

                Ppath(path, i, j);//两点i,j之间还有其他中继结点，则循环套用次函数
                printf("%d\n", j);
            }
        }
        printf("\n");
    }
}
void Floyd(MGraph* G)
{
    int A[MaxVertices][MaxVertices], path[MaxVertices][MaxVertices];
    int i, j, k;
    //初始化
    for (i = 0; i < G->vexnum; i++)
    {
        for (j = 0; j < G->vexnum; j++)
        {
            A[i][j] = G->Edge[i][j];        //将路径中的数据全部导入二维数组A中
            path[i][j] = -1;
        }
    }

    //三重循环，floyd算法核心
    for (k = 0; k < G->vexnum; k++)
    {
        for (i = 0; i < G->vexnum; i++)
        {
            for (j = 0; j < G->vexnum; j++)
            {
                if (A[i][j] > A[i][k] + A[k][j])
                {
                    A[i][j] = A[i][k] + A[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
    Dispath(A, path, G->vexnum);//输出函数
}


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


/*

5 7
0 1 2 3 4
1 2 2
1 3 4
1 4 3
2 3 1
2 5 4
3 5 2
4 5 2

*/

测试结果：