运用Floyd算法求得带权有向图任意两点间的最短路径C/C++

一、 算法过程

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

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

把图用邻接矩阵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算法求得带权有向图任意两点间的最短路径
 */
#include<stdio.h>
#include<malloc.h>
#define MaxVertexNum 50
#define MAX 9999
typedef char VertexType ;
typedef int EdgeType ;
/*
 *定义图的存储结构
 */
typedef struct
{
    VertexType  vexs[MaxVertexNum][3] ; //定义顶点表
    EdgeType    edges[MaxVertexNum][MaxVertexNum] ; //定义边表
    int n , e ; //定义顶点数与边数
} MGraph ;
/*
 *构建图邻接矩阵
 */
void CreateMGraph(MGraph *G)
{
    int i , j , k , w ;
     printf("请输入定点数与边数（输入格式为：顶点数,边数）：") ;
     scanf("%d,%d" , &G->n , &G->e) ;
     printf("请输入顶点信息（输入格式为：顶点号<CR>）：\n") ;
     for(i = 0 ; i < G->n ; i++)
     {
         scanf("%s" , G->vexs[i]) ;
     }
     //初始化邻接矩阵
     for(i = 0 ; i < G->n ; i++)
     {
         for(j = 0 ; j < G->n ; j++)
         {
             if(i == j)
            {
                  G->edges[i][j] = 0 ;
             }else
            {
             G->edges[i][j] = MAX ;
            }
         }
     }
     printf("请输入每条边对应的两个顶点序号以及权值（输入格式为：i,j,w）：\n") ;
     for(k = 0 ; k < G->e ; k++)
     {
         scanf("%d,%d,%d" , &i , &j , &w) ;
         G->edges[i][j] = w ;
     }
     for(i = 0 ; i < G->n ; i++)
     {
         for(j = 0 ; j < G->n ; j++)
         {
             printf("%04d " , G->edges[i][j]) ;
         }
         printf("\n") ;
     }
}
void ShortestPath_2(MGraph G , int P[MaxVertexNum][MaxVertexNum][MaxVertexNum] , int D[MaxVertexNum][MaxVertexNum])
{
 int i , u , v , w ;
 for(v = 0 ; v < G.n ; v++)
 {
     for(w = 0 ; w < G.n ; w++)
     {
         D[v][w] = G.edges[v][w] ;
         for(u = 0 ; u < G.n ; u++)
         {
             P[v][w][u] = 0 ; //进行路径的初始化
         }
         if(D[v][w] < MAX)
         {
             P[v][w][u] = 1 ;
         }
     }
 }
     for(u = 0 ; u < G.n ; u++)
     {
         for(v = 0 ; v < G.n ; v++)
         {
             for(w = 0 ; w < G.n ; w++)
             {
                 if(D[v][u] + D[u][w] < D[v][w]) //从v经u到w的一条路径更短
                 {
                     D[v][w] = D[v][u] + D[u][w] ;
                     for(i = 0 ; i < G.n ; i++)
                     {
                         P[v][w][i] = P[v][u][i] || P[u][w][i] ; //更新路径
                     }
                 }
             }
         }
     }
 }
/*
 *测试代码
 */
void main()
{
    MGraph *G ;
    int i , j  , v , w ;
    int  P[MaxVertexNum][MaxVertexNum][MaxVertexNum] , D[MaxVertexNum][MaxVertexNum] ;
    G = (MGraph*)malloc(sizeof(MGraph)) ;
    CreateMGraph(G) ;
    ShortestPath_2(*G , P , D) ;
    for(v = 0 ; v < G->n ; v++)
    {
        for(w = 0 ; w < G->n ; w++)
        {
            printf("%04d " , D[v][w]) ;
        }
        printf("\n") ;
    }
}