问题 E: 算法7-16：弗洛伊德最短路径算法

题目描述

在带权有向图G中，求G中的任意一对顶点间的最短路径问题，也是十分常见的一种问题。

解决这个问题的一个方法是执行n次迪杰斯特拉算法，这样就可以求出每一对顶点间的最短路径，执行的时间复杂度为O(n3)。

而另一种算法是由弗洛伊德提出的，时间复杂度同样是O(n3)，但算法的形式简单很多。

可以将弗洛伊德算法描述如下：

E1：初始化从vi到vj的目前已知较短路径为从vi到vj的直达弧；
E2：对每两顶点对(vi,vj)依次计算P(i,j,k)，k=0…n-1，计算规则为：P(i,j,k) = min(P(i,k,k-1) + P(k,j,k-1), P(i,j,k-1))

在本题中，读入一个有向图的带权邻接矩阵（即数组表示），建立有向图并按照以上描述中的算法求出每一对顶点间的最短路径长度。

输入格式

输入的第一行包含1个正整数n，表示图中共有n个顶点。其中n不超过50。 以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

输出格式

共有n行，每行有n个整数，表示源点至每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径，输出-1。对于某个顶点到其本身的最短路径长度，输出0。 请在每个整数后输出一个空格，并请注意行尾输出换行。

输入样例

4
0 3 0 1
0 0 4 0
2 0 0 0
0 0 1 0

输出样例  

0 3 2 1 
6 0 4 7 
2 5 0 3 
3 6 1 0 

数据范围与提示

在本题中，需要按照题目描述中的算法完成弗洛伊德算法，并在计算最短路径的过程中将每个顶点是否可达记录下来，直到求出每一对顶点的最短路径之后，算法才能够结束。 相对于迪杰斯特拉算法，弗洛伊德算法的形式更为简单。通过一个三重循环，弗洛伊德算法可以方便的求出每一对顶点间的最短距离。 另外需要注意的是，为了更方便的表示顶点间的不可达状态，可以使用一个十分大的值作为标记。而在题目描述中的算法示例使用了另外一个三维数组对其进行表示，这使原本的O(n3)时间复杂度增长到了O(n4)，这也是需要自行修改的部分。

代码展示 

#include<iostream>
#include<bits/stdc++.h>
#include<vector>
#include<utility>
#include<climits>
using namespace std;
 
#define INFO_MAX_SIZE 20
#define MAX_SIZE 200
 //领接矩阵存储的图
struct Graph{
    int vexNumber;
    string vexInfo[INFO_MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};
 //弧结点定义
struct ArcNode{
    int weight;//弧上的信息部分
    int adj;//邻接点的序号
    ArcNode *nextarc;
};
 //顶点结点定义
struct VexNode{
    string Info;
    ArcNode *firstarc;
};
 //领接表结构的图的定义
struct linkGraph{
    VexNode *vexes;
    int vexnumber;
};
 
 
int preInitGraph(linkGraph &G,const Graph &g){
    G.vexes=new VexNode[g.vexNumber];
    G.vexnumber=g.vexNumber;
    for(int i=0;i<g.vexNumber;i++){
        G.vexes[i].firstarc=NULL;
    }
    return 0;
}
 
//将邻接矩阵存储的图转换为领接表存储的图
void InitGraph(linkGraph &G,const Graph &g){
    preInitGraph(G,g);
    for(int i=0;i<G.vexnumber;i++){
        for(int j=0;j<G.vexnumber;j++){
            if(g.adjMatrix[i][j]!=0){
                ArcNode *p=new ArcNode();
                p->nextarc=NULL;
                p->adj=j;
                p->weight=g.adjMatrix[i][j];
                ArcNode *q=G.vexes[i].firstarc;
                if(G.vexes[i].firstarc==NULL)
                    G.vexes[i].firstarc=p;
                else{
                    while(q->nextarc!=NULL){
                        q=q->nextarc;
                    }
                    q->nextarc=p;
                }
            }
        }
    }
}
 
 
vector<vector<int>>Floyd(linkGraph &G){
    //创建Path矩阵
    vector<vector<int>>Path(G.vexnumber);
    for(auto&r:Path)  r.resize(G.vexnumber);
    //创建shortest矩阵
    vector<vector<int>>shortest(G.vexnumber);
    for(auto&r:shortest)  r.resize(G.vexnumber);
    //初始化shortest和Path,即P(i,j,-)
    for(int i=0;i<G.vexnumber;i++){
        for(int j=0;j<G.vexnumber;j++){
            shortest[i][j]=INT_MAX;
            Path[i][j]=-1;
        }
    }
    for(int i=0;i<G.vexnumber;i++){
        for(ArcNode *p=G.vexes[i].firstarc;p!=nullptr;p=p->nextarc){
            shortest[i][p->adj]=p->weight;
            Path[i][p->adj]=i;
        }
    }
    //迭代计算P(i,j,k)
    for(int k=0;k<G.vexnumber;k++){
        for(int i=0;i<G.vexnumber;i++){
            for(int j=0;j<G.vexnumber;j++){
                if(shortest[i][k]<INT_MAX&&shortest[k][j]<INT_MAX&&shortest[i][k]+shortest[k][j]<shortest[i][j]){
                    shortest[i][j]=shortest[i][k]+shortest[k][j];
                    Path[i][j]=Path[k][j];
                }
            }
        }
    }
 
    for(int i=0;i<G.vexnumber;i++){
        for(int j=0;j<G.vexnumber;j++){
            if(i==j)  cout<<0<<" ";
            else  cout<<shortest[i][j]<<" ";
        }
        cout<<endl;
    }
 
    return Path;
}
 
 
 
 
int main(){
    //freopen("/config/workspace/test/test","r",stdin);
    int n;
    cin>>n;
     
    Graph g;
    g.vexNumber=n;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++)
            cin>>g.adjMatrix[i][j];
    }
    linkGraph G;
    InitGraph(G,g);
    Floyd(G);
 
    return 0;
}

//闲叙题外话：大家都回了啊……