阶段复习——最短路径——Floyd算法

/**Floyd算法
数据结构：
1.存储图的数据结构
2.dist数组，path数组
3.MaxSize,INF
方法：
floyd
*/


/**伪代码：
1.初始化矩阵dist和path；
2.重复下列操作i*j次；
  2.1 比较i到j的距离大小小于插入任意k后i到k的距离加上k到j的距离的大小的真值；
      2.1.1 为真将后者距离代替i到j的距离，路径中间加上k；
*/


#include<iostream>
#include<string>
#include <sstream>
#define MaxSize 100
#define INF 0x3f3f3f3f


using namespace std;




string path[MaxSize][MaxSize];
int dist[MaxSize][MaxSize];
//int s[MaxSize];




string Int_to_String(int n)
{
    ostringstream stream;
    stream<<n;              //n为int类型
    return stream.str();
}


struct Graph
{
    string vertex[MaxSize];
    int arc[MaxSize][MaxSize];
    int vertexNum;
    int arcNum;
} G;


/**< 初始化图G */
void creatGraph()
{
    int i,j,k,w;
    //初始化图G
    cout<<"请依次输入图的顶点数，边数及各边的三个数据"<<endl;
    cin>>G.vertexNum>>G.arcNum;
    for(i=0; i<G.vertexNum; i++)
        for(j=0; j<G.vertexNum; j++)
        {
            G.arc[i][j]=INF;
//            if(i==j)
//                G.arc[i][j]=0;
        }




    for(i=0; i<G.vertexNum; i++)
    {
        G.vertex[i]="v"+Int_to_String(i)+"  ";
    }


    for(i=0; i<G.arcNum; i++)
    {
        cin>>j>>k>>w;
        G.arc[j][k]=w;      //有向图
    }
}


//核心算法，floyd算法


void floyd(struct Graph G)
{
    int i,j,k;
    //初始化矩阵dist和path
    for(i=0; i<G.vertexNum; i++)
        for(j=0; j<G.vertexNum; j++)
        {
            dist[i][j]=G.arc[i][j];
            if(dist[i][j]!=INF) 
            {
                path[i][j]=G.vertex[i]+G.vertex[j];
            }
            else
            {
                path[i][j]="";
            }
        }


    //算法核心
    for(k=0; k<G.vertexNum; k++)
        for(i=0; i<G.vertexNum; i++)
            for(j=0; j<G.vertexNum; j++)
            {
                if(dist[i][j]>dist[i][k]+dist[k][j])
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=path[i][k]+G.vertex[j];      //因为加入的位置一般都是j的前一位
                }
            }
}


void print(int i,int j)
{
    cout<<i<<"到"<<j<<"的最短路径为："<<path[i][j];
    cout<<"    其长度为："<<dist[i][j]<<endl;
}


int main()
{
    creatGraph();
    floyd(G);
    print(1,3);
    return 0;

}

/*
测试数据：
4 8
0 1 2
1 2 3
0 2 6
2 0 7
0 3 4
3 0 5
2 3 7
3 2 12


输出：
1到3的最短路径为：v1  v2  v3      其长度为：10
*/