数据结构之最短路径

其他 2018-11-11 02:08:55 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhangquan2015/article/details/82844408

对于网图来说，最短路径，是指两顶点之间经过的边上权值之和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点。

迪杰斯特拉（Dijkstra）算法

这是一个按路径长度递增的次序产生最短路径的算法。它的思路大体是这样的：并不是一下子就求出v0到v8的最短路径，而是一步步求出它们之间顶点的最短路径，过程中都是基于已经求出的最短路径的基础上，求得更远顶点的最短路径，最终得到你要的结果。
在这里插入图片描述

#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];    /* 用于存储最短路径下标的数组 */
typedef int ShortPathTable[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];
		}
	}

}
/*  Dijkstra算法，求有向网G的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v] */
/*  P[v]的值为前驱顶点下标,D[v]表示v0到v的最短路径长度和 */
void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D)
{
	int v, w, k, min;
	int final[MAXVEX];/* final[w]=1表示求得顶点v0至vw的最短路径 */
	for (v = 0; v<G.numVertexes; v++)    /* 初始化数据 */
	{
		final[v] = 0;			/* 全部顶点初始化为未知最短路径状态 */
		(*D)[v] = G.arc[v0][v];/* 将与v0点有连线的顶点加上权值 */
		(*P)[v] = -1;				/* 初始化路径数组P为-1  */
	}
	(*D)[v0] = 0;  /* v0至v0路径为0 */
	final[v0] = 1;    /* v0至v0不需要求路径 */
					  /* 开始主循环，每次求得v0到某个v顶点的最短路径 */
	for (v = 1; v<G.numVertexes; v++)
	{
		min = INFINITY;    /* 当前所知离v0顶点的最近距离 */
		for (w = 0; w<G.numVertexes; w++) /* 寻找离v0最近的顶点 */
		{
			if (!final[w] && (*D)[w]<min)
			{
				k = w;
				min = (*D)[w];    /* w顶点离v0顶点更近 */
			}
		}
		final[k] = 1;    /* 将目前找到的最近的顶点置为1 */
		for (w = 0; w<G.numVertexes; w++) /* 修正当前最短路径及距离 */
		{
			/* 如果经过v顶点的路径比现在这条路径的长度短的话 */
			if (!final[w] && (min + G.arc[k][w]<(*D)[w]))
			{ /*  说明找到了更短的路径，修改D[w]和P[w] */
				(*D)[w] = min + G.arc[k][w];  /* 修改当前路径长度 */
				(*P)[w] = k;
			}
		}
	}
}
int main(void)
{
	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]);
	system("pause");
	return 0;
}

运行结果为：

最短路径倒序如下:
v0 - v1 :
v0 - v2 : 1
v0 - v3 : 4 2 1
v0 - v4 : 2 1
v0 - v5 : 4 2 1
v0 - v6 : 3 4 2 1
v0 - v7 : 6 3 4 2 1
v0 - v8 : 7 6 3 4 2 1
源点到各顶点的最短路径长度为:
v0 - v1 : 1
v0 - v2 : 4
v0 - v3 : 7
v0 - v4 : 5
v0 - v5 : 8
v0 - v6 : 10
v0 - v7 : 12
v0 - v8 : 16

弗洛伊德（Floyd）算法

先定义两个二维数组 D [ 3 ] [ 3 ] D[3][3] 和 P [ 3 ] [ 3 ] P[3][3] ， D D 代表顶点到顶点的最短路径权值和的矩阵，初始化为 D − 1 D^{-1} ，其实就是初始的图的邻接矩阵。将 P P 命名为 P − 1 P^{-1} ，初始化为图中矩阵。
在这里插入图片描述

首先分析所有的顶点经过v0后到达另一个顶点的最短路径。因为只有三个顶点，因此需要查看v1->v0->v2，得到路径为3。而v1->v2权值为5，所以就有了 D 0 D^0 矩阵，同时修改 P 0 P^0 矩阵。接下来，再在 D 0 和 P 0 D^0和P^0 的基础上计算经过v1和v2的后到达另一个顶点的最短路径，得到 D 1 、 P 1 和 D 2 、 P 2 D^1、P^1和D^2、P^2 。
在这里插入图片描述

#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 (v = 0; v<G.numVertexes; ++v)
		{
			for (w = 0; w<G.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的顶点 */
				}
			}
		}
	}
}

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");
	}
	system("pause");
	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


最短路径D
0       1       4       7       5       8       10      12      16
1       0       3       6       4       7       9       11      15
4       3       0       3       1       4       6       8       12
7       6       3       0       2       5       3       5       9
5       4       1       2       0       3       5       7       11
8       7       4       5       3       0       7       5       9
10      9       6       3       5       7       0       2       6
12      11      8       5       7       5       2       0       4
16      15      12      9       11      9       6       4       0
最短路径P
0 1 1 1 1 1 1 1 1
0 1 2 2 2 2 2 2 2
1 1 2 4 4 4 4 4 4
4 4 4 3 4 4 6 6 6
2 2 2 3 4 5 3 3 3
4 4 4 4 4 5 7 7 7
3 3 3 3 3 7 6 7 7
6 6 6 6 6 5 6 7 8
7 7 7 7 7 7 7 7 8

猜你喜欢

转载自blog.csdn.net/zhangquan2015/article/details/82844408
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022