jQuery火箭图标返回顶部代码

【1】为什么需要弗洛伊德算法？

带权图中单个源点到所有顶点的最短路径问题可以用《迪杰斯特拉算法》求解。

那如果要求图中每一个顶点与其它顶点之间的最短路径呢？类似可以想到的方法为：

每次以一个顶点为源点，重复执行地杰斯特拉算法算法n次。

这样，理论上我们便可以求得每一个顶点与其它顶点的最短路径，总的执行时间为O(n3）。

好吧！为了实现这个中需求，可以采用另外一种求解算法：弗洛伊德算法。

为了更好的理解弗洛伊德算法的精妙，我们先看简单的案例。

如下图是一个最简单的3个顶点连通网图:

附上dist数组与prev数组：(左边为dist 右边为prev)

【2】弗洛伊德算法

弗洛伊德算法是非常漂亮的算法，简洁直观大气上档次。

不过很可惜由于它的三重循环，因此也是O(n*n*n)的时间复杂度。

如果你面临需要求所有顶点至所有顶点的最短路径问题？

它是很好的选择。

[如果上面的不太懂那就直接看代码就好啦，代码更容易懂一些]

代码如下：

#include "stdafx.h"
#include<iostream>
#include<string>
#define MAX_VERTEX_NUM 100
#define INFINITY 65535
typedef int Pathmatirx[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef int ShortPathTable[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
using namespace std;
typedef struct Graph            //有向图的邻接矩阵
{
    char vexs[MAX_VERTEX_NUM];  //存放顶点的数组
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//定义一个临界矩阵
    int vexnum, arcnum;         //总顶点数、总边数
}Graph;

int LocateVex(Graph G, char ch) //搜索
{
    for (int i = 0; i < G.vexnum; i++)
        if (G.vexs[i] == ch)
            return i;
    return -1;
}

void CreateGraph(Graph &G)      //创建无向图
{
    char c1, c2;                //弧尾、弧头
    int i, j, weight;           //weight为权重
    cout << "请输入总顶点数、总边数(空格隔开):";
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入顶点信息(空格隔开):" << endl;
    for (i = 0; i < G.vexnum; i++)  
    {
        cin >> G.vexs[i];
    }
    for (i = 0; i < G.vexnum; i++) 
        for (j = 0; j < G.vexnum; j++)
            G.arcs[i][j] = INFINITY;
    cout << "请输入弧尾、弧头以及权值:" << endl;
    for (int k = 0; k < G.arcnum; k++)
    {
                 cin >> c1 >> c2 >> weight;
                 i = LocateVex(G, c1);
                 j = LocateVex(G, c2);
                 G.arcs[i][j] = weight;
     }
}

void ShortestPath_Floyd(Graph G, int prev[MAX_VERTEX_NUM][MAX_VERTEX_NUM], int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM])
{    //Floyd算法，求网图G中个顶点v到其余顶点w最短路径prev[v][w]及带权长度dist[v][w]
    int v, w, k;
    for (v = 0; v < G.vexnum; v++)
        for (w = 0; w < G.vexnum; w++)  //初始化dist与prev
        {
            dist[v][w] = G.arcs[v][w];  //dist[v][w]值即为对应点间的权值
            prev[v][w] = w;             //初始化prev
        }
        for (k = 0; k < G.vexnum; k++)  //更新路径
            for (v = 0; v < G.vexnum; v++)
                for (w = 0; w < G.vexnum; w++)
                {  //如果经过下标为k顶点路径比原两点间路径更短
                    if (dist[v][w] > dist[v][k] + dist[k][w])
                    {
                        dist[v][w] = dist[v][k] + dist[k][w];
                        prev[v][w] = prev[v][k];  //路径设置经过下标为k的顶点
                    }
                }
    for (v = 0; v < G.vexnum; v++)      //输出函数
    {
        for (w = v + 1; w < G.vexnum; w++)
        {
            cout << G.vexs[v] << " - " << G.vexs[w] << " weight: " << dist[v][w]<<" ";
            int k = prev[v][w];
            cout << "path: " << G.vexs[v];
            while (k != w)
            {
                cout << "->" << G.vexs[k];
                k = prev[k][w];
            }
            cout << "->" << G.vexs[w]<<" ";
        }
        cout << endl;
    }
}

int main()
{
    Graph G;
    int prev[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int v0;
    CreateGraph(G);
    ShortestPath_Floyd(G, prev, dist);
    
}

测试结果: