最短路径——弗洛伊德算法

求每一对顶点之间的最短路径

对于这类最短路径问题，DIF算法也可以解决，只需要定义一个二维数组，以数组的横坐标作为有向网顶点的下标，循环n次依次求解各个源点到其余顶点的最短路径，时间复杂度为O(n^3)。

由于弗洛伊德算法求解该问题的的时间复杂度同为O(n^3)，而且思路简单及代码实现简洁，故采用弗洛伊德算法(Floyd)求解该类问题。

链接

欲了解迪杰斯拉特算法求解单源点到其余顶点的最短路径可点击链接：http://t.csdn.cn/miPKQ

弗洛伊德算法

算法实现思想

总结为一句话即：任意一个顶点都有可能作为其他任意两顶点间最短路径的中转点，以更新两顶点间的更短路径，且中转点的顺序交换没有影响，通过依次使n个顶点充当一次中转点以求解任意顶点间的最短路径。

图解（1）

由图可见，若将B称为一级中转点，那么A通过一级中转点B获取到达顶点C的更短路径。

图解（2）即使B没有作为以及中转点，其依旧有可能充当其他级别的中转点。

由图可见，即使B没有作为A到C的一级中转点（直接中转），但是B作为D到C的一级中转点，为A借助中转点D获取到达C的更短路径打下了基础。可见，每一个顶点都有可能作为任意两点的直接或间接中转点，因此主循环需要循环n次，依次将图中的顶点vk作为其余顶点间的路径<vi,vj>的中转点，判断该顶点是否可以作为<vi,vj>的中转点。若可以，则更新<vi,vj>的最短路径。其数学表达式为，假设Dis(vi,vj)表示顶点vi到顶点vj的路径权值，假如Dis(vi,vj)>Dis(vi,vk)+Dis(vk,vj)，则Dis(vi,vj)=Dis(vi,vk)+Dis(vk,vj)。

同时，各个顶点充当中转点的顺序不影响求解任意顶点间最短路径的效果。如图（2）所示，若B先充当中转点再到D，则D先通过B连通C，即D->B->C。再到D充当中转点时，A通过D连通C，即A->D->B->C为最短路径；若D先充当中转点再到B，则A先通过D连通B，即A->D->B.再到D通过B连通C，即A->D->B->C.可见，各个顶点充当中转点的顺序不影响求解任意顶点间最短路径的效果。

数据结构说明

本例将采取邻接矩阵作为有向网的存储结构，其中Mvnum为最大顶点数，VerType为顶点类型（此处用char），ArcType为弧的权值(int)，infs表示无穷大，表示<vi,vj>无路可通。

辅助数组将采用int D[Mvnum][Mvnum]表示任意两个顶点之间最短路径的状态，且D的初态等同于数组G.arcs（存储任意顶点间的路径）；采用int Path[Mvnum][Mvnum]表示在当前的最短路径<vi,vj>中，顶点vj的直接前驱顶点下标为Path[i][j]，初始化时，若<vi,vj>存在弧，则Path[i][j]=i。

n阶方阵D的数学含义：规定D（-1）==G.arcs，假设D(k+1)表示方阵D经过v0,v1,v2……vk等中转点更新后的状态,则

D(k+1)[i][j]=Min{D(k)[i][j],D(k)[i][k]+D(k)[k][j]}

算法实现

//文件名：AMGraph.h
#pragma once
#include<iostream>
using namespace std;

//邻接矩阵存储有向网
#define Mvnum 100  //最大顶点数
typedef char VerType;  //顶点数据类型
typedef int ArcType;  //弧的权值
typedef struct AMGraph {
    int vexnum, arcnum;
    VerType vexs[Mvnum];          //顶点信息表
    ArcType arcs[Mvnum][Mvnum];   //邻接矩阵
}AMGraph;

//创建有向网
void CreateUDN(AMGraph& G);

//文件名:AMGraph.cpp
#include"AMGraph.h"

//用邻接矩阵创建有向网
void CreateUDN(AMGraph& G)
{
    //inf表示两顶点间没有线路，距离为无穷大
    int infs = 99999999;
    //输入顶点与弧的个数
    cin >> G.vexnum >> G.arcnum;
    //判断合法性
    if (G.vexnum > Mvnum || G.arcnum > (G.vexnum - 1) * G.vexnum)
    {
        cout << "所输入信息非法" << endl;
        return;
    }
    //输入顶点的信息，类型为char
    for (int i = 0;i < G.vexnum;i++)
    {
        cin >> G.vexs[i];
    }
    //将图的边初始化
    for (int i = 0;i < G.vexnum;i++)
    {
        for (int j = 0;j < G.vexnum;j++)
        {
            if (i != j)
                G.arcs[i][j] = infs;
            else
                G.arcs[i][j] = 0;
        }
    }
    //输入权值
    for (int i = 0;i < G.arcnum;i++)
    {
        //输入v1,v2作为弧<v1,v2>的顶点以及该弧权值w
        //顶点下标从0开始
        int v1, v2, w;
        //此处省略了查找v1,v2编号的过程
        cin >> v1 >> v2 >> w;
        //判断合法性
        if (v1 == v2 || v1 >= G.vexnum || v2 >= G.vexnum
            || v1 < 0 || v2 < 0)
        {
            i--;
            continue;
        }
        if (G.arcs[v1][v2] != infs)
        {
            i--;
            continue;
        }
        //输入弧<v1,v2>的权值
        G.arcs[v1][v2] = w;
    }
    //创建完毕
}

//文件名：Floyd.h
#pragma once
#include"AMGraph.h"
//弗洛伊德算法的头文件

/*
    该算法的思想是，每一个顶点都有可能是其他任意两个顶点的中转点，
    因此有向网中的每一个顶点都需要尝试作为其他任意两个顶点的中转点
*/

//输出任意顶点之间的最短路径
void OutshortestPath_Floyd(const AMGraph& G, int(*D)[Mvnum], int(*Path)[Mvnum]);

//任意顶点之间最短路径的顶点顺序
void OutvexInPath_Floyd(const int& i, const int& j, int(*Path)[Mvnum], const AMGraph& G);
//初始化函数
void Init_Floyd(const AMGraph& G, int(*D)[Mvnum], int(*Path)[Mvnum]);

//弗洛伊德算法
void ShortestPath_Floyd(const AMGraph& G);

//文件名：Floyd.cpp
#include"Floyd.h"
//infs表示两顶点间没有线路，距离为无穷大
int infs = 99999999;
//初始化函数
void Init_Floyd(const AMGraph& G, int(*D)[Mvnum], int(*Path)[Mvnum])
{
    //D的初始状态为G.arcs[Mvnum][Mvnum]
    for (int i = 0;i < G.vexnum;i++)
    {
        for (int j = 0;j < G.vexnum;j++)
        {
            D[i][j] = G.arcs[i][j];
        }
    }
    //初始化Path，假如<vi,vj>之间弧，则vj的直接前驱为vi,否则为-1
    for (int i = 0;i < G.vexnum;i++)
    {
        for (int j = 0;j < G.vexnum;j++)
        {
            if (G.arcs[i][j] != infs && i != j)
                Path[i][j] = i;
            else
                Path[i][j] = -1;
        }
    }
}

//任意顶点之间最短路径的顶点顺序
void OutvexInPath_Floyd(const int& i, const int& j, int(*Path)[Mvnum], const AMGraph& G)
{
    if (Path[i][j] == -1)
    {
        cout << G.vexs[i];
    }
    else
    {
        OutvexInPath_Floyd(i, Path[i][j], Path, G);
        cout << "->" << G.vexs[j];
    }
}

//输出任意顶点之间的最短路径
void OutshortestPath_Floyd(const AMGraph& G, int(*D)[Mvnum], int(*Path)[Mvnum])
{
    cout << "任意两顶点之间的最短路径如下:>" << endl;
    for (int i = 0;i < G.vexnum;i++)
    {
        for (int j = 0;j < G.vexnum;j++)
        {
            if (i == j)
                continue;
            if (Path[i][j] == -1)
            {
                cout << "<" << G.vexs[i] << "," << G.vexs[j] << ">" << "无路可通!!!" << endl;
            }
            else
            {
                cout << "顶点" << G.vexs[i] << "到顶点";
                cout << G.vexs[j] << "的最短路径为:>" << D[i][j] << endl;
                //源点为vi,终点为vj
                OutvexInPath_Floyd(i, j, Path, G);
                cout << endl;
            }
        }
    }
}

//弗洛伊德算法
void ShortestPath_Floyd(const AMGraph& G)
{
    //辅助数组

    //1.任意两个顶点之间最短路径的状态数组
    //或者写为ArcType D[Mvnum][Mvnum] = { 0 };
    int D[Mvnum][Mvnum] = { 0 };
    //2.存储在当前的最短路径<vi,vj>中，顶点vj的直接前驱顶点下标为Path[i][j]
    int Path[Mvnum][Mvnum] = { 0 };

    //初始化函数
    Init_Floyd(G, D, Path);

    //将下标为k的顶点作为试探中转点
    for (int k = 0;k < G.vexnum;k++)
    {
        for (int i = 0;i < G.vexnum;i++)
        {
            for (int j = 0;j < G.vexnum;j++)
            {
                if (D[i][j] > D[i][k] + D[k][j])
                {
                    //更新弧<vi,vi>的最短路径
                    D[i][j] = D[i][k] + D[k][j];
                    //更新在最短路径<vi,vj>中，vj的直接前驱结点
                    //因为如今<vi,vj>的路径由路径<vi,vk>与<vk,vj>组成
                    //因此vj在<vi,vj>中的直接前驱等同于vj在<vk,vj>的直接前驱
                    Path[i][j] = Path[k][j];
                }
            }
        }
    }
    //输出任意顶点之间的最短路径
    OutshortestPath_Floyd(G, D, Path);
}

测试

//文件名：test.cpp
void test()
{
    AMGraph G;
    CreateUDN(G);
    ShortestPath_Floyd(G);
}


int main()
{
    test();
    return 0;
}

测试结果

算法分析

显而易见，空间复杂度为O(n^2),时间复杂度为O(n^3);另外，即使使用邻接表也不方便，因为需要对比Dis(vi,vj)与Dis(vi,vk)+Dis(vk,vj)每一轮需要在顶点vi与vk中找三条边，特别不方便，不及邻接矩阵的随机访问。同时，虽然邻接表一般适合于存储稀疏网，但是对于具有n个顶点与e条边的有向网而言，后序可能需要生成n^2-e条新边，网的边数激增将使邻接矩阵失去其存储稀疏网的优势，故在求解最短路径问题时，一般采用支持随机访问的邻接矩阵作为存储结构。