Floyd算法简单实现（C++）

图的最短路径问题主要包括三种算法：

（1）Dijkstra (没有负权边的单源最短路径）

（2）Floyed (多源最短路径)

（3）Bellman (含有负权边的单源最短路径）

本文主要讲使用C++实现简单的Floyd算法，Floyd算法原理参见 Floyd–Warshall algorithm

Floyd算法简单实现（C++）

#include<iostream>
using namespace std;

#define MAXVEX 10
#define INFINITY 65535

typedef int Patharc[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

typedef struct {
    int vex[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes;
} MGraph;

// 构建图
void CreateMGraph(MGraph *G){
    int i, j, k;

    // 初始化图
    G->numVertexes = 9;
    for(i = 0; i < G->numVertexes; ++i){
        G->vex[i] = i;
    }
    for(i = 0; i < G->numVertexes; ++i){
        for(j = 0; j < G->numVertexes; ++j){
            if(i == j)
                G->arc[i][j] = 0;
            else
                G->arc[i][j] = G->arc[j][i] = INFINITY;
        }
    }

    G->arc[0][1] = 1;
    G->arc[0][2] = 5;

    G->arc[1][2] = 3;
    G->arc[1][3] = 7;
    G->arc[1][4] = 5;

    G->arc[2][4] = 1;
    G->arc[2][5] = 7;

    G->arc[3][4] = 2;
    G->arc[3][6] = 3;

    G->arc[4][5] = 3;
    G->arc[4][6] = 6;
    G->arc[4][7] = 9;

    G->arc[5][7] = 5;

    G->arc[6][7] = 2;
    G->arc[6][8] = 7;

    G->arc[7][8] = 4;

    // 设置对称位置元素值
    for(i = 0; i < G->numVertexes; ++i){
        for(j = i; j < G->numVertexes; ++j){
            G->arc[j][i] = G->arc[i][j];
        }
    }
}

// Floyd algorithm
void ShortPath_Floyd(MGraph G, Patharc P, ShortPathTable D){
    int i, j, k;
    // 二重循环，初始化P, D
    for(i = 0; i < G.numVertexes; ++i){
        for(j = 0; j < G.numVertexes; ++j){
            D[i][j] = G.arc[i][j];
            P[i][j] = j;
        }
    }
    // 三重循环, Floyd algorithm
    for(k = 0; k < G.numVertexes; ++k){
        for(i = 0; i < G.numVertexes; ++i){
            for(j = 0; j < G.numVertexes; ++j){
                if(D[i][j] > D[i][k]+D[k][j]){
                    D[i][j] = D[i][k]+D[k][j];
                    P[i][j] = P[i][k];
                }
            }
        }
    }
}

// 打印最短路径
void PrintShortPath(MGraph G, Patharc P, ShortPathTable D){
    int i, j, k;
    cout<<"各顶点之间的最短路径如下: "<<endl;
    for(i = 0; i < G.numVertexes; ++i){
        for(j = i+1; j < G.numVertexes; ++j){
            cout<<"v"<<i<<"--"<<"v"<<j<<" "<<"weight: "<<D[i][j]<<"  Path: "<<i<<" -> ";
            k = P[i][j];
            while(k != j){
                cout<<k<<" -> ";
                k = P[k][j];
            }
            cout<<j<<endl;
        }
        cout<<endl;
    }
}

int main(int argc, char const *argv[]) {
    MGraph G;
    Patharc P;
    ShortPathTable D;
    CreateMGraph(&G);
    ShortPath_Floyd(G, P, D);
    PrintShortPath(G, P, D);
    return 0;
}

运行结果：

各顶点之间的最短路径如下: 
v0--v1 weight: 1  Path: 0 -> 1
v0--v2 weight: 4  Path: 0 -> 1 -> 2
v0--v3 weight: 7  Path: 0 -> 1 -> 2 -> 4 -> 3
v0--v4 weight: 5  Path: 0 -> 1 -> 2 -> 4
v0--v5 weight: 8  Path: 0 -> 1 -> 2 -> 4 -> 5
v0--v6 weight: 10  Path: 0 -> 1 -> 2 -> 4 -> 3 -> 6
v0--v7 weight: 12  Path: 0 -> 1 -> 2 -> 4 -> 3 -> 6 -> 7
v0--v8 weight: 16  Path: 0 -> 1 -> 2 -> 4 -> 3 -> 6 -> 7 -> 8

v1--v2 weight: 3  Path: 1 -> 2
v1--v3 weight: 6  Path: 1 -> 2 -> 4 -> 3
v1--v4 weight: 4  Path: 1 -> 2 -> 4
v1--v5 weight: 7  Path: 1 -> 2 -> 4 -> 5
v1--v6 weight: 9  Path: 1 -> 2 -> 4 -> 3 -> 6
v1--v7 weight: 11  Path: 1 -> 2 -> 4 -> 3 -> 6 -> 7
v1--v8 weight: 15  Path: 1 -> 2 -> 4 -> 3 -> 6 -> 7 -> 8

v2--v3 weight: 3  Path: 2 -> 4 -> 3
v2--v4 weight: 1  Path: 2 -> 4
v2--v5 weight: 4  Path: 2 -> 4 -> 5
v2--v6 weight: 6  Path: 2 -> 4 -> 3 -> 6
v2--v7 weight: 8  Path: 2 -> 4 -> 3 -> 6 -> 7
v2--v8 weight: 12  Path: 2 -> 4 -> 3 -> 6 -> 7 -> 8

v3--v4 weight: 2  Path: 3 -> 4
v3--v5 weight: 5  Path: 3 -> 4 -> 5
v3--v6 weight: 3  Path: 3 -> 6
v3--v7 weight: 5  Path: 3 -> 6 -> 7
v3--v8 weight: 9  Path: 3 -> 6 -> 7 -> 8

v4--v5 weight: 3  Path: 4 -> 5
v4--v6 weight: 5  Path: 4 -> 3 -> 6
v4--v7 weight: 7  Path: 4 -> 3 -> 6 -> 7
v4--v8 weight: 11  Path: 4 -> 3 -> 6 -> 7 -> 8

v5--v6 weight: 7  Path: 5 -> 7 -> 6
v5--v7 weight: 5  Path: 5 -> 7
v5--v8 weight: 9  Path: 5 -> 7 -> 8

v6--v7 weight: 2  Path: 6 -> 7
v6--v8 weight: 6  Path: 6 -> 7 -> 8

v7--v8 weight: 4  Path: 7 -> 8


[Finished in 1.2s]

参考资料：

大话数据结构

Floyd–Warshall algorithm, Wikipedia

Floyd Warshall Algorithm | DP-16 , geeksforgeeks