数据结构与算法--图的应用之最短路径

最新推荐文章于 2022-11-23 10:24:53 发布
最新推荐文章于 2022-11-23 10:24:53 发布
阅读量557 收藏 3
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiangliangSpeak/article/details/106105143
版权

数据结构与算法--图的应用之最短路径

前言

  上一篇简单的介绍了图的应用之最小生成树的两种求解方法，本篇来了解一下关于 图的最短路径 的两种求解方法

首先看下面的图，

从上图中可以很直观的看出：

最短路径：V0 -> V1 -> V2 -> V4 -> V3 -> V6 -> V7 -> V8
最短路径权值和： 1 + 3 + 1 + 2 + 3 + 2 + 4 = 16

那么最短路径怎么求解呢？接下来Dijkstra算法

1. Dijkstra 算法

首先，我们可以将上面的图，存储到 邻接矩阵 中，如下：

因为是无向图，所以是对称的

我们知道，从 V0 到 V1 的权重是 1，V0到V2的权重是5，V1到V2的权重是3，

那么，可以先从V0 到 V1，再从V1 到 V2，总权重是4，优于直接从 V0 到 V2 ，

因此，我们可以修改V0 到V2 的权重为4，路径为 V0 -> V1 -> V2，但是我们并不能直接修改 邻接矩阵，

所以，可以定义一个 数组D，来表示V0 到某个顶点 Vw 的路径。

定义一个数组final，来标识V0到Vw直接是否有最短路径，数组final[w] = 1，表示V0到Vw有最短路径

定义一个 数组P，来记录当前顶点的前驱顶点的下标。

思路：

1. 定义 数组D 表示V0 到Vw 的路径，数组final 表示V0 到Vw 是否求得最短路径（1表示已经求得）
   ，数组P 表示当前顶点的前驱顶点的下标（最后根据 P 数组，打印出V0到 Vw 的路径）
2. 初始化三个数组：
    数组D：V0 和其他顶点的路径
    数组P：先默认所有顶点的前驱都是V0（然后遍历修改前驱的下标）
    数组final： 未知最短路径状态 0
3. V0 到 V0的路径为0，D[0] = 0, V0 到 V0的没有路径，final[v0] = 1，
   P[V0] = -1(-1表示没有路径)
4. 开始循环，找到离 V0 最近的顶点，即从 数组D 中找到距离V0权重最小的顶点的下标 k，并记录最小权重
5. 将目前找到最近的顶点，标记为1，表示到V0有最小路径
6. 在找到V0到Vk最短路径的基础上,对于 Vk 与其他顶点的边进行计算，当其小于 V0 直接到某顶点的距离且该顶点未被标记为有最小路径时，更新V0到某顶点的距离，得到V0与它们的当前最短距离。

代码实现：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXEDGE 20
#define MAXVEX 20
#define INFINITYC 65535

typedef int Status;

typedef struct {
    int vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;
//存储最短路径下标的数组
typedef int Patharc[MAXVEX];
//存储到各点最短路径权值的和
typedef int ShortPathTable[MAXVEX];

void CreateMGraph(MGraph *G)
{
    int i, j;
    
    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] = INFINITYC;
        }
    }
    
    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];
        }
    }
    
}
 

void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D) {
    
    int v,w,k,min = 0;
    
    k = 0;
    // 定义数组，标记到V0是否有最短路径，1有最短路径，0为未知d最短路径
    int final[MAXVEX];
    
    // 初始化
    for (v = 0; v < G.numVertexes; v++) {
        // 默认未知最短路径状态 0，
        final[v] = 0;
        // 将 V0 与其他有连接的顶点的路径赋值给D
        (*D)[v] = G.arc[0][v];
        //初始化路径数组p = 0;
        (*P)[v] = 0;
    }
    
    // V0到V0 是没有路径1
    final[v0] = 1;
    // 没有前驱，前驱下标为-1，
    (*P)[v0] = -1;
    // V0 到 V0 路径为0，
    (*D)[v0] = 0;
    
    // ✅开始主循环
    for (v = 1; v < G.numVertexes; v++) {
        min = INFINITYC;
        // ✅寻找离V0最近的顶点
        for (w = 0; w < G.numVertexes; w++) {
            if (!final[w] && (*D)[w] < min) {
                // 找到，修改最小值，并记录最小顶点下标
                k = w;
                min = (*D)[w];
            }
        }
        // ✅修改标记，标识下标为k的顶点到V0有最小路径
        final[k] = 1;
        
        // ✅在V0到Vk的基础上，对于Vk到其他顶点的边进行计算，
        for (w = 0; w < G.numVertexes; w++) {
            // ✅V0 到Vk + Vk到Vw 的权重 < V0 直接到Vw的路径，更新V0 直接到Vw的路径
            // 并记录顶点Vw的前驱顶点下标
            if (!final[w] && (min + G.arc[k][w] < (*D)[w])) {
                (*D)[w] = min + G.arc[k][w];
                (*P)[w] = k;
            }
        }
    }

}

// 调用
void show() {
    int i,j,v0;
    MGraph G;
    Patharc P;
    ShortPathTable D;
    v0=0;
    
    CreateMGraph(&G);
    
    ShortestPath_Dijkstra(G, v0, &P, &D);
    
    printf("最短路径路线:\n");
    for(i=1;i<G.numVertexes;++i)
    {
        printf("v%d -> v%d : ",v0,i);
        j=i;
        while(P[j]!=-1)
        {
            printf("%d ",P[j]);
            j=P[j];
        }
        printf("\n");
    }
    
    printf("\n最短路径权值和\n");
    for(i=1;i<G.numVertexes;++i)
        printf("v%d -> v%d : %d \n",G.vexs[0],G.vexs[i],D[i]);
    
    printf("\n");
}

执行流程分析：

定义并初始化数组如下：

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
100000000

数组 D：（V0到某个顶点Vw的最短路径）

012345678
015∞∞∞∞∞∞

数组 P：（当前顶点的前驱的下标）

012345678
-100000000

第一次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
110000000

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
015∞∞∞∞∞∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
01486∞∞∞∞

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-100000000

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101110000
先找到最小下标k = 1, min = 1，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 0，G.arc[1][2] = 3，min + G.arc[1][2] < D[2](1 + 3 < 5)，
满足，找到V0 -> V2最短路径，更新D[2] = 4, 更新顶点 V2 前驱顶点的下标，P[2] = 1
4. w = 3，final[3] = 0，G.arc[1][3] = 7，min + G.arc[1][3] < D[3](1 + 7 < ∞)，
满足，找到V0 -> V3最短路径，更新D[3] = 8, 更新顶点 V3 前驱顶点的下标，P[3] = 1
5. w = 4，final[4] = 0，G.arc[1][4] = 5，min + G.arc[1][4] < D[4](1 + 5 < ∞)，
满足，找到V0 -> V4最短路径，更新D[4] = 6, 更新顶点 V4 前驱顶点的下标，P[4] = 1
6. w = 5, final[5] = 0，G.arc[1][1] = 0，min + G.arc[1][5] < D[5](1 + ∞ < ∞)，不满足条件
7. 同上，当w = 6,w = 7,w = 8时，条件不成立

第二次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111000000

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
01486∞∞∞∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
0148511∞∞∞

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101110000

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101122000
先找到最小下标k = 2, min = 4，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 0，G.arc[2][3] = ∞，min + G.arc[2][3] < D[3](4 + ∞ < 8)，
条件不成立
5. w = 4，final[4] = 0，G.arc[2][4] = 1，min + G.arc[2][4] < D[4](4 + 1 < 6)，
满足，找到V0 -> V4最短路径，更新D[4] = 5, 更新顶点 V4 前驱顶点的下标，P[4] = 2
6. w = 5, final[5] = 0，G.arc[2][5] = 7，min + G.arc[1][5] < D[5](4 + 7 < ∞)，
满足，找到V0 -> V5最短路径，更新D[5] = 11, 更新顶点 V5 前驱顶点的下标，P[5] = 2
7. w = 6，final[6] = 0，G.arc[2][6] = ∞，min + G.arc[2][6] < D[3](4 + ∞ < ∞)，条件不成立
8. 同上，当w = 7,w = 8时，条件不成立

第三次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111010000

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
0148511∞∞∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
0147581114∞

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101122000

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424440
先找到最小下标k = 4, min = 5，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 0，G.arc[4][3] = 2，min + G.arc[4][3] < D[3](5 + 2 < 8)，
满足，找到V0 -> V3最短路径，更新D[3] = 7, 更新顶点 V3 前驱顶点的下标，P[3] = 4
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 0，G.arc[4][5] = 3，min + G.arc[4][5] < D[5](5 + 3 < 11)，
满足，找到V0 -> V5最短路径，更新D[5] = 8, 更新顶点 V5 前驱顶点的下标，P[5] = 4
7. w = 6，final[6] = 0，G.arc[4][6] = 6，min + G.arc[4][6] < D[6](5 + 6 < ∞)，
满足，找到V0 -> V6最短路径，更新D[6] = 11, 更新顶点 V6 前驱顶点的下标，P[6] = 4
8. w = 7，final[7] = 0，G.arc[4][7] = 9，min + G.arc[4][7] < D[7](5 + 9 < ∞)，
满足，找到V0 -> V7最短路径，更新D[7] = 14, 更新顶点 V7 前驱顶点的下标，P[7] = 4
9. w = 8，final[8] = 0，G.arc[4][8] = ∞，min + G.arc[4][8] < D[7](5 + ∞ < ∞)，不满足条件

第四次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111110000

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
0147581114∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
0147581014∞

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101424440

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424340
先找到最小下标k = 3, min = 7，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 1，不满足条件
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 0，G.arc[3][5] = ∞，min + G.arc[3][5] < D[5](7 + ∞ < 8)，不满足条件
7. w = 6，final[6] = 0，G.arc[3][6] = 3，min + G.arc[3][6] < D[6](7 + 3 < 11)，
满足，找到V0 -> V6最短路径，更新D[6] = 10, 更新顶点 V6 前驱顶点的下标，P[6] = 3
8. w = 7，final[7] = 0，G.arc[3][7] = ∞，min + G.arc[3][7] < D[7](7 + ∞ < 14)，不满足条件
9. w = 8，final[8] = 0，G.arc[3][8] = ∞，min + G.arc[3][8] < D[7](7 + ∞ < ∞)，不满足条件

第五次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111111000

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
0147581014∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
0147581013∞

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101424340

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424350
先找到最小下标k = 5, min = 8，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 1，不满足条件
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 1，不满足条件
7. w = 6，final[6] = 0，G.arc[5][6] = ∞，min + G.arc[3][6] < D[6](8 + ∞ < 11)，不满足条件
8. w = 7，final[7] = 0，G.arc[5][7] = 5，min + G.arc[3][7] < D[7](8 + 5 < 14)，
满足，找到V0 -> V7最短路径，更新D[7] = 13, 更新顶点 V7 前驱顶点的下标，P[7] = 5
9. w = 8，final[8] = 0，G.arc[5][8] = ∞，min + G.arc[3][8] < D[7](8 + ∞ < ∞)，不满足条件

第六次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111111100

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
0147581013∞

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
014758101217

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101424350

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424366
先找到最小下标k = 6, min = 10，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 1，不满足条件
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 1，不满足条件
7. w = 6，final[6] = 1，不满足条件
8. w = 7，final[7] = 0，G.arc[6][7] = 2，min + G.arc[6][7] < D[7](10 + 2 < 13)，
满足，找到V0 -> V7最短路径，更新D[7] = 12, 更新顶点 V7 前驱顶点的下标，P[7] = 6
9. w = 8，final[8] = 0，G.arc[6][8] = 7，min + G.arc[6][8] < D[7](10 + 7 < ∞)，足条件
满足，找到V0 -> V8最短路径，更新D[8] = 17, 更新顶点 V8 前驱顶点的下标，P[8] = 6

第七次执行主循环

final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111111110

数组 D（旧）：（V0到某个顶点Vw的最短路径）

012345678
014758101217

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
014758101216

数组 P（旧）：（当前顶点的前驱的下标）

012345678
-101424366

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424367
先找到最小下标k = 7, min = 12，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 1，不满足条件
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 1，不满足条件
7. w = 6，final[6] = 1，不满足条件
8. w = 7，final[7] = 1，不满足条件
9. w = 8，final[8] = 0，G.arc[7][8] = 4，min + G.arc[7][8] < D[7](12 + 4 < 17)，足条件
满足，找到V0 -> V8最短路径，更新D[8] = 16, 更新顶点 V8 前驱顶点的下标，P[8] = 7

第八次执行主循环
先找到最小下标k = 8, min = 16，设置final[8] = 1，如下，所以不会在更新数组D 和数组P，最终得到数组P
final 数组：（标记V0和其他顶点是否有最短路径）

012345678
111111111

数组 D（新）：（V0到某个顶点Vw的最短路径）

012345678
014758101216

数组 P（新）：（当前顶点的前驱的下标）

012345678
-101424367
先找到最小下标k = 7, min = 12，基于Vk，寻找 V0 到Vw 的最小路径
1. w = 0, final[0] = 1，不满足条件
2. w = 1, final[1] = 1，不满足条件
3. w = 2, final[2] = 1，不满足条件
4. w = 3，final[3] = 1，不满足条件
5. w = 4, final[4] = 1，不满足条件
6. w = 5, final[5] = 1，不满足条件
7. w = 6，final[6] = 1，不满足条件
8. w = 7，final[7] = 1，不满足条件
9. w = 8，final[8] = 1，不满足条件

最后根据数组P和数组D，求得V0到某个顶点的最短路径和权重，

在求最短路径时，遍历数组p，当前驱下标等-1 时，表示找到源点。

2. 佛洛依德（Floyd）算法

如下图：

上图的邻接矩阵

DV0V1V2
V0021
V1205
V2150

从V1 -> V2 的最短路径是什么？

直接从V1 -> V2 = 5，但是从V1 -> V0 -> V2 = 3

那么我们可以定义一个 邻接矩阵 D，代表顶点到顶点的最短路径的矩阵

初始化 邻接矩阵 D 和 图的邻接矩阵一致，

然后判断 D[1][2] > D[1][0]+D[0][2] 时，说明 顶点V1 到 顶点V2，之间 有更短的路径，此时更新 D[1][2] 位置上的权重（即V1到顶点V2最短路径的总权重）。

同时，定义一个 二维数组P，代表对应顶点最短路路径的前驱矩阵，

当更新某位置的权重时，同时更新 前驱矩阵 的对应位置为其前驱节点下标（比如上面的P[1][2] = P[1][0]）。

佛洛依德（Floyd）算法公式：

D[V][W] = min{ D[V][W], D[V][K]+D[K][W] }

P[V][W] = P[V][K]

其中，k为从 V 到 W 的中转点。

佛洛依德（Floyd）算法代码实现：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 20
#define INFINITYC 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];

/* 11.1 构成邻近矩阵 */
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] = INFINITYC;
       }
   }
   
   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算法
/// @param G 图
/// @param P 前驱矩阵
/// @param D 最短路径矩阵
void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
{
   int w, v, k;
   
   // ✅初始化P和D
   for (v = 0; v < G.numVertexes; ++v) {
       for (w = 0; w < G.numVertexes; ++w) {
           // ✅D[v][w]值即为对应点间的权值
           (*D)[v][w] = G.arc[v][w];
           // ✅初始化P P[v][w] = w
           (*P)[v][w] = w;
       }
   }
   // ✅K表示经过的中转顶点
   for (k = 0; k < G.numVertexes; ++k) {
       for (v = 0; v < G.numVertexes; ++v) {
           for (w = 0; w < G.numVertexes; ++w) {
               if ((*D)[v][w] > (*D)[v][k] + (*D)[k][w]) {
                   // ✅将当前两点间权值设为更小的一个
                   (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                   // ✅路径设置为经过下标为k的顶点
                   (*P)[v][w] = (*P)[v][k];
               }
           }
       }
   }
   
}

// 调用
void show(){
   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");
   }
   
   //✅打印最终变换后的最短路径D数组
   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");
   }
   //✅打印最终变换后的最短路径P数组
   printf("最短路径P数组\n");
   for(v=0; v<G.numVertexes; ++v)
   {
       for(w=0; w<G.numVertexes; ++w)
       {
           printf("%d ",P[v][w]);
       }
       printf("\n");
   }
}

执行过程分析：


第一次执行：k = 0
当K = 0，所有的顶点都经过V0中转，k = 0，没有任何变化。

第二次执行：k = 1(所有顶点都经过 V1 中转)

v = 0，w = [0 - 8]

 D[0][0] = 0，D[0][1] + D[1][0] = 0，不更新
 D[0][1] = 1，D[0][1] + D[1][1] = 1，不更新
 D[0][2] = 5，D[0][1] + D[1][2] = 1 + 3，4 < 5，更新D[0][2] = 4
 D[0][3] = ∞，D[0][1] + D[1][3] = 1 + 7，8 < ∞，更新D[0][3] = 8
 D[0][4] = ∞，D[0][1] + D[1][4] = 1 + 5, 6 < ∞, 更新D[0][4] = 6
 D[0][5] = ∞，D[0][1] + D[1][5] = 1 + ∞, 不更新
 D[0][6] = ∞，D[0][1] + D[1][6] = 1 + ∞, 不更新
 D[0][7] = ∞，D[0][1] + D[1][7] = 1 + ∞, 不更新
 D[0][8] = ∞，D[0][1] + D[1][8] = 1 + ∞, 不更新

v = 1，w = [0 - 8]

 D[1][0] = 1，D[1][1] + D[1][0] = 1，不更新
 D[1][1] = 0，D[1][1] + D[1][1] = 0，不更新
 D[1][2] = 3，D[1][1] + D[1][2] = 0 + 3，不更新
 D[1][3] = 7，D[1][1] + D[1][3] = 0 + 7，不更新
 D[1][4] = 5，D[1][1] + D[1][4] = 0 + 5, 不更新
 D[1][5] = ∞，D[1][1] + D[1][5] = 0 + ∞, 不更新
 D[1][6] = ∞，D[1][1] + D[1][6] = 0 + ∞, 不更新
 D[1][7] = ∞，D[1][1] + D[1][7] = 0 + ∞, 不更新
 D[1][8] = ∞，D[1][1] + D[1][8] = 0 + ∞, 不更新
 
v = 3，w = [0 - 8]

 D[3][0] = ∞，D[3][1] + D[1][0] = 7 + 1 < ∞，更新D[3][0] = 8
 D[3][1] = 7，D[3][1] + D[1][1] = 7，不更新
 D[3][2] = ∞，D[3][1] + D[1][2] = 7 + 3 < ∞，更新D[3][2] = 10
 D[3][3] = 0，D[3][1] + D[1][3] = 7 + 7 > 0，不更新
 D[3][4] = 2，D[3][1] + D[1][4] = 7 + 5 > 2, 不更新
 D[3][5] = ∞，D[3][1] + D[1][5] = 7 + ∞, 不更新
 D[3][6] = 3，D[3][1] + D[1][6] = 7 + ∞, 不更新
 D[3][7] = ∞，D[3][1] + D[1][7] = 7 + ∞, 不更新
 D[3][8] = ∞，D[3][1] + D[1][8] = 7 + ∞, 不更新

按照上面的规律，依次循环遍历，最终得到：

然后根据数组D和前驱矩阵P打印顶点和顶点之间的最短路径

亮亮不想说话
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈工大数据结构与算法-图型结构的应用算法-最短路径算法的实现.zip
06-02
在哈工大的数据结构与算法课程中，图型结构的应用算法是重要的研究领域，而最短路径算法则是其中的关键部分。本课程实验旨在让学生深入理解并掌握如何在实际问题中运用这些算法。通过分析和实现最短路径算法，学生...
最短路径问题（图表详解迪杰斯特拉算法）
CXR_XC的博客
11-18 2821
图表详解迪杰斯特拉算法，用C++实现
带权无向图求最短路径_迪杰斯特拉算法求最短路径（C语言详解版）
weixin_39585974的博客
01-27 4685
如今出行已经不需要再为找不着路而担心了，车上有车载导航，手机中有导航 App。只需要确定起点和终点，导航会自动规划出可行的距离最短的道路。这是最短路径在人们实际生活中最典型的应用。在一个网(有权图)中，求一个顶点到另一个顶点的最短路径的计算方式有两种：迪杰斯特拉(Dijkstra算法)和弗洛伊德(Floyd)算法。迪杰斯特拉算法计算的是有向网中的某个顶点到其余所有顶点的最短路径；弗洛伊德...
图之从一个顶点到其余各个顶点的最短路径（有向图）
热门推荐
GailyYelp的博客
03-21 2万+
目录 从一个顶点到其余各个顶点最短路径的简介 举例以及详细分析 代码块 测试结果 从一个顶点到其余各个顶点最短路径的简介1.定义概览Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，
算法导论之单源最短路径
医疗影像检索
10-26 5711
单源最短路径，在现实中是很多应用的，是图的经典应用，比如在地图中找出两个点之间的最短距离、最小运费等。单源最短路径的问题：已知图G=(V,E)，找出给定源顶点s∈V到每个顶点v∈V的最短路径。单源最短路径衍生出的变体问题如下： 1）单终点最短路径问题：找出从每个顶点v到指定终点t的最短路径。这个是单源最短路径的反向，把图的每条边反向，问题就变成单源最短路径的问题； 2）单对顶点最短路径问题：对
单源最短路径（狄克斯特拉算法）
龙进的博客
01-28 1204
在加权图G=(V,E)中，求给定顶点s,d之间各边权值总和最小的路径，这就是最短路径问题。 这个问题主要分为两类： 单源最短路径：在图G中，求给定顶点s到其他所有顶点di之间的最短路径 全点对间最短路径：在图G中，求“每一对顶点”之间的最短路径 求单源最短路径，其实就是求从起点出发的最短路径生成树的过程。如果顶点s到G的所有顶点都存在路径，那么一定存在一棵以s为根，包含s到G所有顶点最短路径的生成树T。这种树就称为最短路径生成树。 狄克斯特拉算法 解决最短路径生成树问题，就需要用到狄克斯.
最短路径经典数据结构算法-dijkstra
最新发布
12-30
dijkstra算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。 本代码使用了有向图，数据为整数int，数据结构...
c语言算法与数据结构最短路径报告+代码.zip
08-06
这份"C语言算法与数据结构最短路径报告+代码"压缩包，显然是为了帮助初学者理解和应用这些概念。以下是对其中涉及的主要知识点的详细阐述： 1. **C语言**：C语言是一种强大的、低级的编程语言，广泛用于系统编程、...
大学数据结构--图的最短路径算法.doc
05-26
大学数据结构--图的最短路径算法.doc
数据结构课程设计报告--Dijkstra算法求最短路径.doc
05-30
本文档是关于数据结构课程设计报告，主要介绍Dijkstra算法在求最短路径中的应用。下面是本文档的详细知识点总结： 目录结构 本文档的目录结构清晰，分为四个章节：问题分析与任务定义、数据结构的选择和概要设计、...
数据结构与算法——最短路径（图）
12-15
C#写的c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#
最短路径算法（Dijkstra）
在下李逍遥的博客
08-25 2107
一、前言　　最短路径算法，顾名思义就是求解某点到某点的最短的距离、消耗、费用等等，有各种各样的描述，在地图上看，可以说是图上一个地点到达另外一个地点的最短的距离。比方说，我们把地图上的每一个城市想象成一个点，从一个城市到另一个城市的花费是不一样的。现在我们要从上海去往北京，需要考虑的是找到一条路线，使得从上海到北京的花费最小。有人可能首先会想到，飞机直达啊，这当然是时间消耗最小的方法，但是考虑到费用
算法导论-上课笔记11:单源最短路径
我是一只小嵩鼠
05-26 2485
找到从源结点s到图G中每个结点v的最短路径
一点到多点最短路径长度_单源最短路径问题（Dijkstra算法）
weixin_36468140的博客
01-28 3117
单源最短路径问题是给定带权有向图G=(V，E)，其中每条边的权都是非负实数，且给定V中一个源点，计算从源点到其它各个顶点的最短路径长度(路上各边权之和)。Dijkstra算法是解单源最短路径问题的贪心算法，且不能处理带负边权的情况，用邻接矩阵或邻接表存图。下面我们讲解一下算法思路，我们找来一张带权有向图：问题重述：假设它的起点是 a ，要求它到各点的最短距离。Dijkstra 算...
2. 单源最短路径
qq_44651930的博客
11-23 1112
给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源（默认源点为顶点1）。现在要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为单源最短路径问题。输出n-1行，分别为源点到其他各点的最短路径。本题用了Floyd算法，但用dj其实会更快。随后m行是所有边的起点 终点和边长。第一行是顶点数n和边数m。
最短路径问题
不依法度的博客
06-06 1448
Dijkstra算法 Dijkstra算法一般是用来处理单源最短路径问题 单源最短路径问题：给定一个带权有向图G=（V,E），其中每条边的权是一个实数。另外，还给定V中的一个顶点，称为源。要计算从源到其他所有各顶点的最短路径长度。这里的长度就是指路上各边权之和。这个问题通常称为单源最短路径问题。 但要注意的是！！Dijkstra算法适用要求必须每个边的权重都为正数 Dijkstra算法的原理 配合视频食用 推荐视频1：【算法】最短路径查找—Dijkstra算法 推荐视频2：Dijkstra(迪杰斯特拉)
【数据结构】图的应用之最短路径
WINGREZ‘S BLOG
09-02 952
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 最短路径 Dijkstra算法 求顶点到其余各顶点的最短距离： （1）假设用带权的邻接矩阵arcs来表示带权有向...
图的应用——最短路径（迪杰斯特拉算法）
syh的技术记录
05-21 2233
Content1. 什么是最短路径2. 迪杰斯特拉算法【O(n^2^)】3. 代码4. 迪杰斯特拉算法 VS 普利姆算法 1. 什么是最短路径 在一个带权有向图中，从某一顶点到另一顶点可能有很多条路径，最短路径即权值之和最小的那条路径。 如在上图中，从顶点0到顶点5的最短路径是0-4-3-5，长度为60。 2. 迪杰斯特拉算法【O(n2)】 该算法用到了贪心的思想，设 v0为源点，S 为已求得的最短路径的终点集合； 则下一条最短路径。( 设其终点为 v)或者是弧 < v0, v>, 或者是中间
图的应用及经典算法-----最短路径算法合集----c语言
weixin_53272394的博客
07-30 616
最短路径 定义 最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图(由结点和路径组成的)中两结点之间的最短路径。 算法具体的形式包括: 确定起点的最短路径问题 - 即已知起始结点，求最短路径的问题。 确定终点的最短路径问题 - 与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。 确定起点终点的最短路径问题 - 即已知起点和终点，求两结点之间的最短路径。 全局最短路径问题 - 求图
数据结构与算法之最短路径路径与最短路径和
04-22
最短路径是指在一张图中从一个节点出发到另一个节点的路径上边的权值之和最小的路径。而最短路径和是指在一张图中找到所有节点对之间的最短路径，并将这些路径的权值之和相加，得到的结果就是最短路径和。在计算最短...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值