西工大NOJ数据结构理论——022.Dijkstra算法（严7.42）

最新推荐文章于 2022-06-09 23:15:49 发布
最新推荐文章于 2022-06-09 23:15:49 发布
阅读量1k 收藏 1
点赞数 2
分类专栏： 链表 C 文章标签： 数据结构 链表 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15735748145a/article/details/125022038
版权
链表 同时被 2 个专栏收录
33 篇文章 8 订阅
订阅专栏
C
33 篇文章 31 订阅
订阅专栏

我直到最近才意识到，为什么我开学前几周有时间来做这个博客了，是因为我选的大物实验是从第9周开始的，而大家很多人选的都是第3到第8周，所以我之前就会有很多的空闲时间来做这个事情，而不是什么我时间效率利用高。自从第9周开始，我的时间就明显不够用了，因为这个大物实验实在太费时间了，所以就导致我最近更新这么慢。

回到这道题，我认为的两大法宝是：

1.足量的注释；

2.逐步的调试。

当然，这个代码还有很多的不足，现在又要考试了，我实在没心思再静下心来优化它了，等暑假再优化叭（这大概率又是一个必会倒的 flag）

#include<stdio.h>
#include<stdlib.h>
#define MAX_VERTEX_NUM 120
#define YES 1
#define NO 0
typedef struct Dist{ //D数组 
	int adjvex; //最终要到达的顶点 
	int length; //当前路径的长度 
	int done; //如果确定了当前路径就是最短路径，那么done=1 
}Path;

typedef struct ArcNode{ //弧 
	int adjvex; //该弧所指向的顶点的位置 
	struct ArcNode *nextarc; //指向下一条弧的指针 
	int length; //该弧的路径长度 
}ArcNode;

typedef struct VNode{ //顶点 
	int data; //顶点信息 
	ArcNode *firstarc; //指向第一条依附该顶点的弧的指针 
}VNode;

typedef struct ALGraph{ //图 
	VNode vertices[MAX_VERTEX_NUM]; //图的各个顶点 
	int vexnum,arcnum; //图的当前结点数和弧数 
}ALGraph;

void graph_initialize(ALGraph* graph){ //图的初始化 
	graph->vexnum=0;
	graph->arcnum=0;
	for(int i=0;i<MAX_VERTEX_NUM;i++){
		graph->vertices[i].data=0;
		graph->vertices[i].firstarc=NULL;
	}
}

void arcnode_initialize(ArcNode* arcnode){ //弧结点的初始化 
	arcnode->adjvex=0;
	arcnode->nextarc=NULL;
}

ArcNode* arcnode_create(){ //弧结点的创建 
	ArcNode *arcnode=(ArcNode*)malloc(sizeof(ArcNode));
	arcnode_initialize(arcnode);
	return arcnode;
}

ALGraph* graph_create(){ //图的创建 
	ALGraph* graph=(ALGraph*)malloc(sizeof(ALGraph));
	graph_initialize(graph);
	int n,m; //n是顶点数，m是边数 
	scanf("%d %d",&n,&m);
	graph->vexnum=n;
	graph->arcnum=m; 
	for(int i=1;i<=graph->vexnum;i++){//读入顶点信息 
		graph->vertices[i].data=i;
		graph->vertices[i].firstarc=NULL;
	}
	for(int j=0;j<graph->arcnum;j++){ //读入弧信息 
		int a,b,length;
		//a是弧尾，b是弧头，length是路径长度 
		scanf("%d %d %d",&a,&b,&length);
		//下面用创建一个弧结点，并且完善这个结点的信息： 
		ArcNode *arcnode=arcnode_create();
		arcnode->adjvex=b;
		arcnode->length=length; 
		//下面找到弧要插入的位置（尾插法） 
		int i=0;
		while(i<graph->vexnum){
			if(graph->vertices[i].data==a) break;
			i++; 
		}
		ArcNode *temp=graph->vertices[i].firstarc;
		//如果插入的位置很尴尬，恰好是第一个，那我们就得把它单独拉出来做成特殊情况。 
		if(temp==NULL) graph->vertices[i].firstarc=arcnode;
		//但如果它不是第一个，那我们就把它当成普遍情况来对待 
		else{
			while(temp->nextarc) temp=temp->nextarc;
			//找到要插入的位置后，插入进去 
			temp->nextarc=arcnode;
		}
	}
	return graph;
}

int Dijkstra(ALGraph* graph){
	//第一大步，创建一个D数组，用来记录最短路径 
			//因为第0个位置是不用的，而第1个位置是从原点到原点，也是不用的 
			//所以如果有6个顶点，就得要给它分配7个位置 
	Path D[graph->vexnum+1];
	//第二大步，我们对D数组进行初始化操作 
		//第一步，默认从原点到不了任何一个顶点: 
	for(int i=2;i<=graph->vexnum;i++){
		D[i].adjvex=i;
		D[i].length=10000;
		//在这里，将D[i].length设为10000，就表示路径长度为无穷大 
		D[i].done=NO;
	}
		//最终，通过这个循环，系统认为，从1到不了2，3，4，5，6 
		//第二步，根据邻接表，确定从原点能到达哪些顶点： 
	ArcNode *temp=graph->vertices[1].firstarc;
	while(temp){
		D[temp->adjvex].length=temp->length;
		temp=temp->nextarc;
	}
		//最终，通过这个while循环，我们确定了从1能到达哪些顶点 
	//第三大步，假如共有1，2，3，4，5，6这6个顶点，那么分5次，每次找出从1到单顶点的最短路径 
	for(int times=1;times<=5;times++){
		//第一步，在数组D中找到最小的那一个(也就是路径最短) 
		//这里随便给个min_vex的初值，要不然处理太麻烦。 
		int min_vex=2;
		while(min_vex<=graph->vexnum){
			if(D[min_vex].done==YES){
				min_vex++;
			}
			else{
				break;
			}
		}
		for(int i=2;i<=graph->vexnum;i++){
			if(D[i].done==YES){
				continue;
				//如果从原点1到i的最短路径已经找到了，那就不用看它了 
			}
			if(D[i].length<D[min_vex].length) min_vex=i; 
		}
		D[min_vex].done=YES;
		//然后从小到大输出最短路径： 
		if(D[min_vex].length!=10000){
			printf("%d %d %d\n",1,min_vex,D[min_vex].length);
		}
		//最终，通过这个循环，确定了从1到单个顶点的最短路径，我们把它标记为done=YES,这样以后就不用再去看它了 
		//第二步，我们看一看从原点1到min_vex,再从min_vex到2,3,4,5,6，是不是能更短 
		for(int i=2;i<=graph->vexnum;i++){
			if(D[i].done==YES) continue;
			//如果从原点1到min_vex，再从min_vex到i的路径已经确定为最短了，那么就不看它了 
			ArcNode* temp=graph->vertices[min_vex].firstarc;
			int flag=0;
			while(temp){
				if(temp->adjvex==i){
					flag=1; break;
				}
				temp=temp->nextarc;
			}
			if(flag==0) continue;
			//如果没有从原点1到min_vex，再从min_vex到i的路径的原因，是从min_vex到不了i，那么也不看它了 
			//相反，如果路径存在，那我们可就要好好看看了： 
			else if(flag==1){
				//怎么个好好看法呢？不难，就是看从原点1到min_vex，再从min_vex到i，是不是能比D[i]更短：  
				//如果能更短，那何乐而不为呢？二话不说就把D[i]更新掉。 
				if(D[min_vex].length+temp->length<D[i].length){
					D[i].length=D[min_vex].length+temp->length;
				} 
			}
		}
	}
	//第四大步，根据D[]数组，输出不可达的路径 
	for(int i=2;i<=graph->vexnum;i++){
		if(D[i].length==10000){
			printf("%d %d -1\n",1,i);
		}
	}
}

int main(){
	ALGraph* graph=graph_create();
	//首先，用这个函数处理掉所有的input 
	Dijkstra(graph);
	//然后，用这个函数得到从1到2、3、4、5、6......的最短路径output 
	return 0;
}

mmp说我字数不够，那我把几个函数拿下来凑个字数叭

int Dijkstra(ALGraph* graph){
    //第一大步，创建一个D数组，用来记录最短路径 
            //因为第0个位置是不用的，而第1个位置是从原点到原点，也是不用的 
            //所以如果有6个顶点，就得要给它分配7个位置 
    Path D[graph->vexnum+1];
    //第二大步，我们对D数组进行初始化操作 
        //第一步，默认从原点到不了任何一个顶点: 
    for(int i=2;i<=graph->vexnum;i++){
        D[i].adjvex=i;
        D[i].length=10000;
        //在这里，将D[i].length设为10000，就表示路径长度为无穷大 
        D[i].done=NO;
    }
        //最终，通过这个循环，系统认为，从1到不了2，3，4，5，6 
        //第二步，根据邻接表，确定从原点能到达哪些顶点： 
    ArcNode *temp=graph->vertices[1].firstarc;
    while(temp){
        D[temp->adjvex].length=temp->length;
        temp=temp->nextarc;
    }
        //最终，通过这个while循环，我们确定了从1能到达哪些顶点 
    //第三大步，假如共有1，2，3，4，5，6这6个顶点，那么分5次，每次找出从1到单顶点的最短路径 
    for(int times=1;times<=5;times++){
        //第一步，在数组D中找到最小的那一个(也就是路径最短) 
        //这里随便给个min_vex的初值，要不然处理太麻烦。 
        int min_vex=2;
        while(min_vex<=graph->vexnum){
            if(D[min_vex].done==YES){
                min_vex++;
            }
            else{
                break;
            }
        }
        for(int i=2;i<=graph->vexnum;i++){
            if(D[i].done==YES){
                continue;
                //如果从原点1到i的最短路径已经找到了，那就不用看它了 
            }
            if(D[i].length<D[min_vex].length) min_vex=i; 
        }
        D[min_vex].done=YES;
        //然后从小到大输出最短路径： 
        if(D[min_vex].length!=10000){
            printf("%d %d %d\n",1,min_vex,D[min_vex].length);
        }
        //最终，通过这个循环，确定了从1到单个顶点的最短路径，我们把它标记为done=YES,这样以后就不用再去看它了 
        //第二步，我们看一看从原点1到min_vex,再从min_vex到2,3,4,5,6，是不是能更短 
        for(int i=2;i<=graph->vexnum;i++){
            if(D[i].done==YES) continue;
            //如果从原点1到min_vex，再从min_vex到i的路径已经确定为最短了，那么就不看它了 
            ArcNode* temp=graph->vertices[min_vex].firstarc;
            int flag=0;
            while(temp){
                if(temp->adjvex==i){
                    flag=1; break;
                }
                temp=temp->nextarc;
            }
            if(flag==0) continue;
            //如果没有从原点1到min_vex，再从min_vex到i的路径的原因，是从min_vex到不了i，那么也不看它了 
            //相反，如果路径存在，那我们可就要好好看看了： 
            else if(flag==1){
                //怎么个好好看法呢？不难，就是看从原点1到min_vex，再从min_vex到i，是不是能比D[i]更短：  
                //如果能更短，那何乐而不为呢？二话不说就把D[i]更新掉。 
                if(D[min_vex].length+temp->length<D[i].length){
                    D[i].length=D[min_vex].length+temp->length;
                } 
            }
        }
    }
    //第四大步，根据D[]数组，输出不可达的路径 
    for(int i=2;i<=graph->vexnum;i++){
        if(D[i].length==10000){
            printf("%d %d -1\n",1,i);
        }
    }
} 

没耳朵的Rabbit
关注
专栏目录
22 Dijkstra 算法（严 7.42）
voice34的博客
06-18 427
题目 description： 编写程序，实现以邻接表作存储结构，求从源点到其余各顶点的最短路径的 Dijkstra算法。 input： 第一行输入顶点数 n 和边数 m；第二行输入顶点信息；分 m 行输入 m 对顶点 vi，vj（表示由顶点 vi 到顶点 vj（i 不等于 j）的边）以及该弧的权值。 output： 输出从源点到其余各顶点的最短路径（不可达用-1 表示）。 sample_input： 6 11 1 2 50 1 3 10 1 5 45 2 3 15 2 5 10 3 1 20 3 4 1
『西工大-数据结构-NOJ』 022-Dijkstra算法(耿7.42) 『西北工业大学』
LanXiu_的博客
07-10 2659
解题思路： 这道题要求使用邻接来作为储存结构，使用Dijkstra算法计算源点到其余各点的最短距离，无法到达时令距离为-1. 了解一下Dijkstra算法： 而根据题目预期的Output来看，输出数据是按照最短路径升序输出的，因此我们还要对数据进行一次排序，最短路径升序优先，其次是目标点序号，之后将最短路径为-1的放在最后输出。 具体操作见代码，代码中有部分注释。 题解代码： #include<stdio.h> #include<stdlib.h> #define MAX..
西工大 数据结构 noj22.Dijkstra算法（严7.42）
Lelouch_24的博客
06-09 350
迪杰斯特拉算法
Dijkstra算法（严7.42）
zhao2018的博客
05-23 1602
Description编写程序，实现以邻接表作存储结构，求从源点到其余各顶点的最短路径的Dijkstra算法。Input第一行输入顶点数n和边数m；第二行输入顶点信息；分m行输入m对顶点vi，vj（表示由顶点vi到顶点vj（i不等于j）的边）以及该弧的权值。(0&lt;m,n&lt;100)Output输出从源点到其余各顶点的最短路径（不可达用-1表示）。Sample Input 6 11 1 2...
西工大NOJ数据结构理论——019.基于图的深度优先搜索策略（耿7.10）
m0_54849806的博客
05-22 162
临近期末考了，所以思路来不及整理了，但大家还是可以仿照我的上几篇文章，“先动笔，再代码”的思路还是不变的。 #include<stdio.h> #include<stdlib.h> #define MAX_VERTEX_NUM 120 #define FALSE 0 #define TRUE 1 #define YES 1 #define NO 0 int visited[MAX_VERTEX_NUM]={FALSE}; int flag=NO; typedef struct A.
西北工业大学数据结构noj_1-6题
04-27
在“西北工业大学数据结构noj_1-6题”中，我们可以推测这是一系列与数据结构相关的编程练习题目，旨在帮助学生理解和应用各种数据结构。以下是基于这些题目可能涵盖的一些关键知识点的详细解释： 1. **线性数据结构...
西工大NOJ数据结构实验——3.1哈夫曼
最新发布
05-24
哈夫曼编码是一种常用的数据压缩算法，可以将原始数据转换为更短的编码，从而减少存储空间。它的基本思想是：根据字符出现的频率，构建一颗二叉树，使得出现频率高的字符离根节点近，出现频率低的字符离根节点远。...
西北工业大学数据结构及实验答案.7z
05-12
本资源“西北工业大学数据结构及实验答案.7z”包含了37个数据结构相关的编程实验题目及其解决方案，这些方案已经经过验证能够正确运行并获得预期结果。这个压缩包对于正在学习或复习数据结构的学生来说，是一个宝贵...
Dijkstra算法
qq_29131907的博客
04-12 91
#include<iostream> #include<queue> #include<stack> using namespace std; #define Init -1 #define Max 1000 int path[Max]; int dist[Max]; int G[Max][Max]; int collected[Max]; int Nv;//顶...
西工大noj答案
01-04
不太全 但很有用 第一季10题全（注：第五题问题已经解决,确认AC!)
noj100题题目+答案，供初学者使用
12-08
noj100题题目+答案，供初学c和c++的用户完成简单的程序设计
西工大cad大作业
11-15
西工大cad大作业 .dwg文件
noj22Dijkstra算法
蜜雪冰城
05-26 231
迪杰斯特拉算法： 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 基本思想 通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 通过Dijkstra计算图G中的最短路径..
西工大noj数据结构22题 迪杰斯特拉算法
qq_62393242的博客
05-12 473
#include <stdio.h> #include <stdlib.h> #define MAX 100 #define infinity 100 typedef struct { int vexs[MAX]; int arcs[MAX][MAX]; int arc_count,vex_count; }graph; typedef struct { int weight; int visited; }lnode; typedef struct { int ve.
数据结构实验4.2 noj 用迪杰斯特拉算法求赋权图的两点间的最短路径的长度。
Lelouch_24的博客
05-25 694
上一题 《用迪杰斯特拉算法求赋权图的两点间的最短路径的长度》参考了这篇文章 求赋权图中一个结点到所有结点的最短路径的长度_Laura2017的博客-CSDN博客_求图中每一节点到其他节点的最短路然后这题我又搜了一下，感觉大家写的有点复杂我不想看，就自己想了个写法，其实写出来更复杂（（ 原理是，在上一题的基础上，再创建一个二维数组，一个一维数组 int lu[maxnum][maxnum]：第一个值设为a，第二个值设为b，a用于定位某个节点，b用于记录路线，即，数组用于记录某个节点到各个节...
noj 实验4.2：用迪杰斯特拉算法求赋权图中的最短路径(无向图)
qq_42110967的博客
06-24 2333
//实验4.2：用迪杰斯特拉算法求赋权图中的最短路径(无向图) #include <stdio.h> #include <stdlib.h> #define max 2000 typedef struct MGraph{ int matrix[max][max];//邻接矩阵 int vernum; //节点数目 }MGraph; int P[max]; void InitMGraph(MGraph *G){ scanf("%d",&a.
【数据结构实验】NOJ009 实验4.2 用迪杰斯特拉算法求赋权图中的最短路径
weixin_45932570的博客
06-17 685
1. 题目 示例输入 4 0 2 10 10000 2 0 7 3 10 7 0 6 10000 3 6 0 0 2 示例输出 0 1 2 2. 代码 #include <iostream> using namespace std; typedef struct{ int n; //顶点数 int Edge[100][100]; }Graph; Graph G; bool visited[100]; int path[100]; int road[100]; int dist
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值