16 - 12 - 08 弗洛伊德算法(Floyd)-最短路径 - Фрейд

最新推荐文章于 2023-11-16 11:21:03 发布

Sodaoo

最新推荐文章于 2023-11-16 11:21:03 发布

阅读量638

点赞数 1

分类专栏：数据结构与基本算法文章标签：算法弗洛伊德图论数据结构数据结构与算法

本文链接：https://blog.csdn.net/SoDaoo/article/details/53510525

版权

数据结构与基本算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

带权图中单个源点到所有顶点的最短路径问题可以用
迪杰斯特拉算法 http://blog.csdn.net/sodaoo/article/details/53495517

那如果要求图中每一个顶点与其它顶点之间的最短路径呢？可以想到的方法为：
每次以一个顶点为源点，重复执行地杰斯特拉算法算法n次。
这样，理论上我们便可以求得每一个顶点与其它顶点的最短路径，总的执行时间为O(n3）。
不过为了美观大气上档次地实现旮旯需求，采用：弗洛伊德算法

Floyd算法的基本思想：
从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，证明从A到X再到B的路径比A直接到B的路径短，我们便设置Dis(AB) = Dis(AX) + Dis(XB)，这样一来，当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径的距离。
但是这里我们要注意循环的嵌套顺序，如果把检查所有节点X 放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把 i 到 j 的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。

<<<<– 代码君 –>>>>


typedef int PathMatrix[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][Matrix];
void ShortestPath_Floyd(MGraph G,PathMatrix *P,ShortPathTable *D)
{
    int v,w,k;
    for (v  = 0; v < G.numVertexes; ++v)
    {
        for (w = 0; w < numVertexes; ++w)
        {   /*Matrix有的也作arc[][],表示邻接矩阵*/
            (*D)[v][w] = G.Matrix[v][w];  
                     /*(*D)[v][w]的值即为对应点之间的权值*/
            (*P)[v][w] = w;         /*初始化P[][]*/
        }
    }
    for (k = 0; k < numVertexes; ++k)
    {
        for (v = 0; v < numVertexes; ++v)
        {
            for (w = 0; w < numVertexes; ++w)
            {
                if ( (*D)[v][w] > (*D)[v][k] + (*D)[k][w] )
                {  /*如果经过下标为k的顶点路径比原来的两点间的路径更短*/
                    /*将当前两点间权值设置为更小的一个*/
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                    (*P)[v][w] = (*P)[v][k];  /*路径设置经过下标为k的顶点*/
、               }
            }
        }
    }
}

这里写图片描述
你可能有些困惑，（0，1）+（1，2） > （0，2）你能理解，
但是如 ↑ 图的 0-> 3 顶点，中间跨越了好几个顶点，又如何保证寻找到的路径是最短路径呢？
哈哈当然不必担心了，我们发现 k 在最外一层循环，
D[x][y] > D[x][0]+ D[0][y] 将维持到直到遍历完所有的D[x][0]+ D[0][y] 相关的顶点，这时候，与顶点0相近的最短路径已经被确定了下来，（0，2） = 4 ；（0，4） = 5 ；很自然的找到（0，3） = 7；

for (k = 0; k < numVertexes; ++k)
    {
        for (v = 0; v < numVertexes; ++v)
        {
            for (w = 0; w < numVertexes; ++w)
            {
                if ( (*D)[v][w] > (*D)[v][k] + (*D)[k][w] )
                {  
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
/*再看 k v w 的编排位置和 if()语句的对应关系，k是必须要放在最外一层的，然后v，w可以互换。（？没试验过。。）*/

那么如何由P这个路径数组得出具体的最短路径呢？以 V0 到 V8 为例，对 P 数组进行追踪发现，P[0][8] = 1,得到要经过顶点V1，然后将1取代0得到P[1][8] = 2, 说明要经过V2，然后将 2 取代 1 得到 P[2][8] = 4。。。。。。。。。
<<<代码>>>

 printf("各顶点间最短路径如下:\n"); 
    for(v=0; v<G.numVertexes; ++v) 
    { 
        for(w=v+1; w<G.numVertexes; w++) 
        {
            printf("v%d-v%d weight: %d ",v,w,D[v][w]);
            k=P[v][w];                /* 获得第一个路径顶点下标 */
            printf(" path: %d",v);    /* 打印源点 */
            while(k!=w)                /* 如果路径顶点下标不是终点 */
            {
                printf(" -> %d",k);    /* 打印路径顶点 */
                k=P[k][w];            /* 获得下一个路径顶点下标 */
            }
            printf(" -> %d\n",w);    /* 打印终点 */
        }
        printf("\n");
    }

这里写图片描述

全部代码
<<<全部代码君>>>

#include "stdio.h" 
#include "stdlib.h" 
#include "io.h" 
#include "math.h" 
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 20
#define INFINITY 65535

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef struct
{
    int vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;

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

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

    /* printf("请输入边数和顶点数:"); */
    G->numEdges=16;
    G->numVertexes=9;

    for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
    {
        G->vexs[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算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */ 
void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
{ 
    int v,w,k; 
    for(v=0; v<G.numVertexes; ++v) /* 初始化D与P */ 
    { 
        for(w=0; w<G.numVertexes; ++w) 
        {
            (*D)[v][w]=G.arc[v][w];    /* D[v][w]值即为对应点间的权值 */
            (*P)[v][w]=w;                /* 初始化P */
        }
    }
    for(k=0; k<G.numVertexes; ++k) 
    {
        for(w=0; w<G.numVertexes; ++w) 
        { 
            for(v=0; v<G.numVertexes; ++v) 
            {
                if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
                {/* 如果经过下标为k顶点路径比原两点间路径更短 */
                    (*D)[v][w]=(*D)[v][k]+(*D)[k][w];/* 将当前两点间权值设为更小的一个 */
                    (*P)[v][w]=(*P)[v][k];/* 路径设置为经过下标为k的顶点 */
                }
            }
        }
    }
}

int main(void)
{ 
    int v,w,k; 
    MGraph G; 

    Patharc P; 
    ShortPathTable D; /* 求某点到其余各点的最短路径 */ 

    CreateMGraph(&G);

    ShortestPath_Floyd(G,&P,&D); 

    printf("各顶点间最短路径如下:\n"); 
    for(v=0; v<G.numVertexes; ++v) 
    { 
        for(w=v+1; w<G.numVertexes; w++) 
        {
            printf("v%d-v%d weight: %d ",v,w,D[v][w]);
            k=P[v][w];                /* 获得第一个路径顶点下标 */
            printf(" path: %d",v);    /* 打印源点 */
            while(k!=w)                /* 如果路径顶点下标不是终点 */
            {
                printf(" -> %d",k);    /* 打印路径顶点 */
                k=P[k][w];            /* 获得下一个路径顶点下标 */
            }
            printf(" -> %d\n",w);    /* 打印终点 */
        }
        printf("\n");
    }

    printf("最短路径D\n");
    for(v=0; v<G.numVertexes; ++v) 
    { 
        for(w=0; w<G.numVertexes; ++w) 
        {
            printf("%d\t",D[v][w]);
        }
        printf("\n");
    }
    printf("最短路径P\n");
    for(v=0; v<G.numVertexes; ++v) 
    { 
        for(w=0; w<G.numVertexes; ++w) 
        {
            printf("%d ",P[v][w]);
        }
        printf("\n");
    }

    return 0;
}

鸣谢：
htp://blog.sina.com.cn/s/blog_66d94d130101l8i5.html
hp://www.cnblogs.com/Braveliu/archive/2013/12/05/3459768.html
htp://blog.csdn.net/wwj_ff/article/details/46560559
htp://blog.chinaunix.net/uid-26548237-id-3834873.html