迪杰斯特拉算法

最新推荐文章于 2024-07-23 17:36:37 发布
最新推荐文章于 2024-07-23 17:36:37 发布
阅读量95 收藏
点赞数
文章标签： 算法 c语言 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124659834
版权 
#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;

typedef struct ArcCell
{
	VRType adj;
	InfoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];
	AdjMatrix arcs;
	int vexnum, arcnum;
	GraphKind kind;
}MGraph;
Status CreatGraph(MGraph* G)
{
	printf("请输入图的类型\n");
	scanf("%d", &(G->kind));
	switch (G->kind)
	{
	case DG:return(CreatDG(G)); break;
	case DN:return(CreatDN(G)); break;
	case UDG:return(CreatUDG(G)); break;
	case UDN:return(CreatUDN(G)); break;
	default: return ERROR;
	}
}
Status CreatDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for(int i=0;i<G->vexnum;i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		G->arcs[tail][head].adj = 1;
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		printf("请输入弧的权值\n");
		scanf("%d", &(G->arcs[tail][head]));
		getchar();
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatUDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		G->arcs[vex1][vex2].adj = 1;
		G->arcs[vex2][vex1].adj = 1;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
Status CreatUDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		printf("请输入此弧权值\n");
		scanf("%d", &(G->arcs[vex1][vex2].adj));
		getchar();
		G->arcs[vex2][vex1].adj = G->arcs[vex1][vex2].adj;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}


//迪杰斯特拉算法求最短路径
typedef int** PathMatrix;
typedef int* ShortPathTable;
void ShortestPath_DIJ(MGraph G, char* ch, PathMatrix* P, ShortPathTable* D)
{
	int st;
	for(int i=0;i<G.vexnum;i++)
		if (strcmp(ch, G.vexs[i]) == 0)
		{
			st = i;
			break;
		}
	*P = (int**)malloc(sizeof(int*) * G.vexnum);
	if (!*P) exit(OVERFLOW);
	for (int i = 0; i < G.vexnum; i++)
	{
		(*P)[i] = (int*)malloc(sizeof(int) * G.vexnum);
		if (!(*P)[i]) exit(OVERFLOW);
	}
	*D = (int*)malloc(sizeof(int) * G.vexnum);
	if (!*D) exit(OVERFLOW);
	for (int i = 0; i < G.vexnum; i++)
		for (int j = 0; j < G.vexnum; j++)
			(*P)[i][j] = 0;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (G.arcs[st][i].adj < INFINITY)
			(*P)[i][i] = 1;
	}
	for (int i = 0; i < G.vexnum; i++)
		(*D)[i] = G.arcs[st][i].adj;
	int count = 1;
	int* visit;
	visit = (int*)malloc(sizeof(int) * G.vexnum);
	if (!visit) exit(OVERFLOW);
	for (int i = 0; i < G.vexnum; i++)
		visit[i] = 0;
	visit[st] = 1;
	while (count <= G.vexnum - 1)
	{
		int mincost = INFINITY, min;
		for (int i = 0; i < G.vexnum; i++)
			if (!visit[i] && (*D)[i] < mincost)
			{
				min = i;
				mincost = (*D)[i];
			}
		for (int i = 0; i < G.vexnum; i++)
		{
			if (!visit[i] && G.arcs[min][i].adj != INFINITY && (*D)[i] > (*D)[min] + G.arcs[min][i].adj)
			{
				(*D)[i] = (*D)[min] + G.arcs[min][i].adj;
				for (int j = 0; j < G.vexnum; j++)
					(*P)[i][j] = (*P)[min][j];
				(*P)[i][i] = 1;
			}
		}
		visit[min] = 1;
		count++;
	}
}
//迪杰斯特拉算法主函数
int main()
{
	PathMatrix P;
	ShortPathTable D;
	MGraph G;
	CreatGraph(&G);
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
    printf("请输入起始地点\n");
	gets(ch);
	ShortestPath_DIJ(G, ch, &P, &D);
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
			printf("%d  ", P[i][j]);
		printf("\n");
	}
	int st;
	for (int i = 0; i < G.vexnum; i++)
		if (strcmp(ch, G.vexs[i]) == 0)
		{
			st = i;
			break;
		}
	int count = 1;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (st != i)
		{
			printf("*******************************************************\n\n");
			printf("<%d>到%s：%d\n", count, G.vexs[i], D[i]);
			int j = st;
			while (j != i)
			{
				printf("%s->", G.vexs[j]);
				for (int k = 0; k < G.vexnum; k++)
				{
					if (P[i][k] && G.arcs[j][k].adj != INFINITY)
					{
						P[i][k] = 0;
						j = k;
						break;
					}
				}
			}
			printf("%s\n\n", G.vexs[i]);
			count++;
		}
	}
	printf("*******************************************************\n");
	return 0;
}

输入：（以大连为起始地点）

3
25 30 0
哈尔滨
长春
沈阳
大连
天津
北京
徐州
郑州
呼和浩特
兰州
西安
西宁
乌鲁木齐
上海
武汉
成都
昆明
贵阳
株洲
南昌
福州
柳州
南宁
广州
深圳
哈尔滨
长春
242
长春
沈阳
305
沈阳
大连
397
沈阳
天津
704
天津
徐州
674
天津
北京
137
北京
郑州
695
郑州
徐州
349
北京
呼和浩特
668
呼和浩特
兰州
1145
兰州
西安
676
西安
郑州
511
兰州
西宁
216
兰州
乌鲁木齐
1892
西安
成都
842
成都
贵阳
967
贵阳
株洲
902
株洲
武汉
409
武汉
郑州
534
株洲
南昌
367
南昌
上海
825
上海
徐州
651
成都
昆明
1100
昆明
贵阳
639
贵阳
柳州
607
柳州
株洲
672
柳州
南宁
255
株洲
广州
675
广州
深圳
140
南昌
福州
622
大连

原图：

 

结果：

1.P矩阵输出（行的序号所代表的地点是终点，列所代表的地点如果为1，意味着大连到终点的最短路径需要经过此地）

 2.部分地点输出

 

哆啦BCD梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dijkstra算法（迪杰斯特拉算法）
持之以恒2016
06-24 4万+
对比算法好坏需要考虑的因素 执行算法所耗费的时间 执行算法所耗费的存储空间 Dijkstra算法（迪杰斯特拉算法） 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959年提出的，是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。 迪杰斯特拉算法的主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 迪杰斯特拉算法的成功率是最高的，因为它每次必能搜索到最优路径。但迪杰...
迪杰斯特拉算法详解
dyx916_的博客
05-26 1282
迪杰斯特拉算法的定义、逻辑和实现
最短路问题迪杰斯特拉算法PPT课件.pptx
10-12
"迪杰斯特拉算法PPT课件" 迪杰斯特拉算法是解决最短路问题的一种常用方法。该算法以埃德斯格·迪杰斯特拉命名，是一种常用的图算法，用于计算从图中的某个节点到其他所有节点的最短路径。 问题的提法及应用背景： ...
zdlj.rar_迪杰斯特拉_迪杰斯特拉算法
09-21
在"zdlj.rar_迪杰斯特拉_迪杰斯特拉算法"压缩包中，包含了一个名为"zdlj.cpp"的文件，我们可以推断这是一个C++实现的迪杰斯特拉算法。这个程序可能是作者根据教科书上的代码进行改编的，可能包含了一些个人的优化和...
Python实现迪杰斯特拉算法过程解析
09-24
迪杰斯特拉（Dijkstra）算法是一种用于解决单源最短路径问题的算法，尤其适用于有权值非负的有向图。它通过贪心策略，每次扩展当前已知最短路径，逐步找到从源节点到所有其他节点的最短路径。在Python中实现Dijkstra...
数据结构迪杰斯特拉算法程序
10-14
迪杰斯特拉算法的基本思想是使用贪心策略，每次选取当前未访问节点中距离源节点最近的一个进行访问，并更新其相邻节点的距离。算法的核心在于维护一个优先队列（通常用最小堆实现），存储待处理的节点并根据它们到源...
数据库课程设计《火车出行路线规划及售票系统》迪杰斯特拉算法实现
01-04
首先，迪杰斯特拉算法是一种著名的图论算法，由荷兰计算机科学家艾兹格·迪杰斯特拉提出。它的主要目标是在加权有向或无向图中寻找从源节点到其余所有节点的最短路径。在火车出行路线规划中，每个城市可以被视为图中...
【18】输出字符菱形
2301_78786609的博客
07-19 425
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 378
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
最新发布
qq_62571233的博客
07-23 786
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 605
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 287
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 495
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 292
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 372
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 205
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
迪杰斯特拉算法使用前提
03-27
迪杰斯特拉算法是一种用于解决单源最短路径问题的算法，它可以找到从一个起点到其他所有节点的最短路径。使用迪杰斯特拉算法的前提是： 1. 图的表示：迪杰斯特拉算法适用于带权重的有向图或无向图。图可以使用邻接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值