Floyd算法

动态规划：
dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j])

typedef enum{DG,DN,UDG,UDN}GraphKind;
typedef int AdjType;
typedef char VertexData;

typedef struct ArcNode{
    AdjType adj;
}ArcNode;

typedef struct AdjMatrix{
    VertexData vertex[MAX_VERTEX_NUM];
    ArcNode arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int vexnum,arcnum;
    GraphKind kind;
    AdjMatrix()
    {
        for(int i = 0; i < MAX_VERTEX_NUM; i++)
        {
            for(int j = 0; j < MAX_VERTEX_NUM; j++)
            {
                if( i==j ) arcs[i][j].adj = 0;
                else
                    arcs[i][j].adj = INFINITY;
            }
        }
    }
}AdjMatrix;

void shortestPath(AdjMatrix g,int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM],int path[][20])
{
    for(int i = 0; i < g.vexnum; i++)
    {
        for(int j = 0; j < g.vexnum; j++)
        {
            if(i != j)
                path[i][j] = -1;
            else
                path[i][j] = 0;
            dist[i][j] = g.arcs[i][j].adj;
            if(i != j && dist[i][j] < INFINITY)
            {
                path[i][j] = i;
            }
        }
    }

    for(int i = 0; i < g.vexnum; i++)
    {
        for(int j = 0; j < g.vexnum; j++)
        {
            for(int k = 0; k < g.vexnum; k++)
            {

                if( dist[k][j] < INFINITY && dist[i][k] < INFINITY && dist[i][j] > dist[i][k]+dist[k][j])
                {
                    dist[i][j] = dist[i][k]+dist[k][j];
                    path[i][j] = k;
                }
            }
        }
    }

}