弗洛伊德算法Floyed（求各顶点间最短路径）：可打印最短路径

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;  

#define INFINITY 65535
#define MAX_VERTEX_NUM 10  

typedef struct MGraph{
    string vexs[10];//顶点信息
    int arcs[10][10];//邻接矩阵
    int vexnum, arcnum;//顶点数和边数
}MGraph;  

int LocateVex(MGraph G, string u)//返回顶点u在图中的位置
{
    for(int i=0; i<G.vexnum; i++)
        if(G.vexs[i]==u)
            return i;
    return -1;
}  

void CreateDN(MGraph &G)//构造有向图
{
    string v1, v2;
    int w;
    int i, j, k;
    cout<<"请输入顶点数和边数：";
    cin>>G.vexnum>>G.arcnum;  

    cout<<"请输入顶点：";
    for(i=0; i<G.vexnum; i++)
        cin>>G.vexs[i];  

    for(i=0; i<G.vexnum; i++)
        for(j=0; j<G.vexnum; j++)
            G.arcs[i][j]=INFINITY;  

    cout<<"请输入边和权值："<<endl;
    for(k=0; k<G.arcnum; k++)
    {
        cin>>v1>>v2>>w;
        i=LocateVex(G, v1);
        j=LocateVex(G, v2);
        G.arcs[i][j]=w;
    }
}  

//弗洛伊德算法求每一对顶点间的最短路径
//p[v][w][i]表示当前求得的顶点v到顶点w的最短路径中的第i+1个顶点，这是打印最短路径的关键
//D[v][w]表示当前求得的顶点v到顶点w的最短路径的长度
void ShortestPath_FLOYD(MGraph G, int p[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM], int D[][MAX_VERTEX_NUM])
{
    int u, v, w, i, j;  

    for(v=0; v<G.vexnum; v++)
        for(w=0; w<G.vexnum; w++)
        {
            D[v][w]=G.arcs[v][w];
            for(u=0; u<G.vexnum; u++)
                p[v][w][u]=-1;
            if(D[v][w] < INFINITY)
            {
                p[v][w][0]=v;
                p[v][w][1]=w;
            }
        }  

        for(u=0; u<G.vexnum; u++)
            for(v=0; v<G.vexnum; v++)
                for(w=0; w<G.vexnum; w++)
                    if(D[v][u] < INFINITY && D[u][w] < INFINITY && D[v][u]+D[u][w] < D[v][w])
                    {
                        //更新D
                        D[v][w]=D[v][u]+D[u][w];
                        //更新p，从v到w的路径是从v到u，再从u到w的所有路径
                        for(i=0; i<G.vexnum; i++)
                        {
                            if(p[v][u][i]!=-1)
                                p[v][w][i]=p[v][u][i];
                            else
                                break;
                        }
                        for(j=1; j<G.vexnum; j++)//注意：这里j从1开始而不是从0开始，因为从v到u的路径最后一个顶点是u, 而从u到w的路径第一个顶点是u，只需打印u一次即可。
                        {
                            if(p[u][w][j]!=-1)
                                p[v][w][i++]=p[u][w][j];
                            else
                                break;
                        }  

                    }  

}  

void main()
{
    MGraph g;
    int p[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int D[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  

    CreateDN(g);
    for(int  i=0; i<g.vexnum; i++)
        g.arcs[i][i]=0;
    ShortestPath_FLOYD(g, p, D);  

    cout<<"d矩阵（最短路径长度矩阵）:"<<endl;
    for(i=0; i<g.vexnum; i++)
    {
        for(int j=0; j<g.vexnum; j++)
            cout<<setw(5)<<D[i][j]<<" ";
        cout<<endl;
    }  

    cout<<endl;
    cout<<"各顶点间最短长度及路径如下："<<endl;
    for(i=0; i<g.vexnum; i++)
    {
        for(int j=0; j<g.vexnum; j++)
        {
            if(i!=j)
            {
                if(D[i][j]!=INFINITY)
                {
                    cout<<g.vexs[i]<<"到"<<g.vexs[j]<<"的最短长度为："<<setw(5)<<D[i][j]<<", 最短路径为：";
                    for(int k=0; k<g.vexnum; k++)
                    {
                        if(p[i][j][k]!=-1)
                            cout<<g.vexs[p[i][j][k]]<<" ";
                        else
                            break;
                    }
                    cout<<endl;
                }
                else
                    cout<<g.vexs[i]<<"到"<<g.vexs[j]<<"不可达"<<endl;
            }  

        }
        cout<<endl;         

    }  

}  

测试一：

测试二：