Floyd求最短路径

Floyd求最短路径
相比于Dijkstra算法来说，Floyd算法真的是容易理解多了，仅仅需要邻接矩阵，还有一个三重循环即可，但是比Dijkstra算法的复杂度要高，各有各的优点，自己选择即可。
实现代码如下：

#include<iostream>
#include<cstring>
const int Maxsize=100;
const int Max=10000000;
using namespace std;
string panduan(int i)//同上
{
    string str="v";
    int j=i;
    string news=str + to_string(i);;
    return news;
}

void Floyd(int dis[Maxsize][Maxsize],int v)
{
    int vex=v;
    string path[Maxsize][Maxsize];
    for(int i=0;i<vex;i++)
    {
        for(int j=0;j<vex;j++)
        {
            if(dis[i][j]!=Max)//不为自己预设的最大值就代表着两个节点之间存在路径
            {
                path[i][j]=panduan(i)+" "+panduan(j);
            }
            else
            {
                 path[i][j]="";
            }
        }
    }
    for(int k=0;k<vex;k++)//在两个节点之间都插入一遍其他所有节点，如果小的话就更新权值
    {
        for(int i=0;i<vex;i++)
        {
            for(int j=0;j<vex;j++)
            {
                if(dis[i][k]+dis[k][j]<dis[i][j])
                {
                    dis[i][j]=dis[i][k]+dis[k][j];
                    path[i][j]=path[i][k]+" "+panduan(j);
                }
            }
        }
    }
    for(int i=0;i<vex;i++)//输出每两个节点之间的权值，如果仍未自己预设的最大值那么证明不存在路径，输入“no answer”
    {
        for(int j=0;j<vex;j++)
        {
            if(i!=j)
            {
                if(dis[i][j]==Max)
            {
                cout<<"no answer";
            }
            else
            {
                cout<<dis[i][j]<<" "<<path[i][j]<<endl;
            }
            }
        }
    }

}
int main()
{
    int v,a,s,e;
    cin>>v>>a;
    int dis[Maxsize][Maxsize];
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            dis[i][j]=0;
        }
    }
    int from,tail,zhi;
    for(int i=0;i<a;i++)
    {
        cin>>from>>tail>>zhi;
        dis[from][tail]=zhi;
    }
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            if(dis[i][j]==0)
            {
                dis[i][j]=Max;
            }
        }
    }
    Floyd(dis,v);
}