图论 最短路 difjstra 专题

最新推荐文章于 2022-06-26 18:26:36 发布
原创 最新推荐文章于 2022-06-26 18:26:36 发布 · 475 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Dijkstra算法的基本原理及其在不同场景中的应用案例，包括城市间最短路径计算、网络路由寻径等，并提供了多个编程实现示例。 
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <list>
#include <stack>
#include <queue>
using namespace std;
/*
	T3 hdu 2066
*/

int MAX=1111111111;
int mp[1002][1002];
int vis[1002];
int p[1002];
int main()
{
	int T,S,D;
	int a,b,time;
	int i,j;
	int maxn;
	while(cin>>T>>S>>D)
	{
		//初始化
		for(i=0;i<=1002;i++)
			for(j=0;j<=1002;j++)
				mp[i][j]=MAX;
		maxn=-1;//编号最大的城市
		for(i=1;i<=T;i++)
		{
			cin>>a>>b>>time;
			if(mp[a][b]>time)
				mp[a][b]=mp[b][a]=time;//两个方向
			if(maxn<a)
				maxn=a;
			if(maxn<b)
				maxn=b;
		}
		maxn++;
		//初始化起点
		for(i=1;i<=S;i++)
		{
			cin>>a;
			mp[0][a]=mp[a][0]=0;
		}
		//初始化终点
		for(i=1;i<=D;i++)
		{
			cin>>a;
			mp[a][maxn]=mp[maxn][a]=0;
		}

		//初始化vis 和p
		for(i=0;i<=maxn;i++)
		{
			vis[i]=0;
			p[i]=mp[0][i];
		}
		//difjstra
		vis[0]=1;
		p[0]=0;
		
		int min;
		int k;//标记
		for(i=0;i<=maxn;i++)
		{
			min=MAX;
			for(j=1;j<=maxn;j++)
			{
				if(vis[j]==0 &&min>p[j])
				{
					min=p[j];
					k=j;
				}
			}
			vis[k]=1;//最小的条路
			//选出来的最小的路，跟其他路径的比较
			for(j=1;j<=maxn;j++)
			{
				if(vis[j]==0 && p[j]>p[k]+mp[k][j])
					p[j]=p[k]+mp[k][j];
			}
		}
		cout<<p[maxn]<<endl;
	}
	return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <list>
#include <stack>
#include <queue>
using namespace std;

/*
	T2 hdu 3631
	*/
int MAX=100000000;
int mp[305][305];
int vis[305];


void flag(int x)
{
	for(int i=0;i<=304;i++)
	{
		if(mp[i][x] == MAX) continue;
		for(int j=0;j<=304;j++)
			if(mp[i][j]>mp[i][x]+mp[x][j] )
				mp[i][j]=mp[i][x]+mp[x][j];
	}
}
int main()
{
	int N,M,Q;
	int n,i,j;
	int x,y,c;
	n=1;
	while(cin>>N>>M>>Q ,N+M+Q)
	{
		if(n!=1) cout<<endl;
		for(i=0;i<=304;i++)
		{
			for(j=0;j<=304;j++)
				mp[i][j]= MAX;
			mp[i][i]=0;
		}
		while(M--)
		{
			cin>>x>>y>>c;
			if(mp[x][y] >c)
				mp[x][y]= c;
			if(x==y)
				mp[x][y] =0;
		}
		memset(vis,0,sizeof(vis));
		cout<<"Case "<<n<<":"<<endl;
		n++;
		while(Q--)
		{
			cin>>c;
			if(c==0)
			{
				cin>>x;
				if(vis[x] !=0)
					cout<<"ERROR! At point "<<x<<endl;
				else
				{
					vis[x]=1;
					flag(x);
					continue;
				}
			}
			if(c==1)
			{
				cin>>x>>y;
				if(vis[x] == 0 || vis[y]==0)
					cout<<"ERROR! At path "<<x<<" to "<<y<<endl;
				else if(mp[x][y] == MAX)
				{
					cout<<"No such path"<<endl;
				}
				else cout<<mp[x][y]<<endl;
			
			}
		}

	}

	return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <list>
#include <stack>
#include <queue>
using namespace std;


/*
	T1 hdu 2544
*/
int MAX=1111111111;
int mp[105][105];
int vis[105];
int p[105];
int main()
{
	int n,m;
	int i,j;
	while(cin>>n>>m && n!=0&& m!=0)
	{
		int a,b,c;
		//数组 初始化,
		memset(vis,0,sizeof(vis));
		memset(mp,-1,sizeof(mp));
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)
				mp[i][j]=MAX;
			mp[i][i]=0;
		}
		while(m--)
		{
			cin>>a>>b>>c;
			mp[a][b]=mp[b][a] = c;
		}
		//difjstra
		vis[1]=1;
		int min,min_index,pos=1;
		//起始第一步
		for(i=2;i<=n;i++)
			p[i]=mp[1][i];
		for(j=1;j<=n-1;j++)
		{
			min=MAX;
			//找到
			for(i=1;i<=n;i++)
			{
				if(!vis[i] && mp[pos][i]!= -1 && min>p[i])
				{
					min=p[i];
					min_index=i;
				}
			}
			vis[min_index] =1;//这个点 已求
			pos=min_index;//记录这个点
			for(i=1;i<=n;i++)
			{
				if(!vis[i] && mp[pos][i] != -1 && p[i]>p[pos]+mp[pos][i])
					p[i] = p[pos] + mp[pos][i];
			}
		}
		cout<<p[n]<<endl;
	}
	return 0;
}
</pre><pre name="code" class="cpp">#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <list>
#include <stack>
#include <queue>
#define MAX 100000000
using namespace std;


/*
	T 2 poj 2387
*/
int mp[1005][1005];
int vis[1005];
int p[1005];
int main()
{
	int T,N;
	int i,j;
	int a,b,c;
	while(cin>>T>>N)
	{
		//数组初始化
		memset(vis,0,sizeof(vis));
		memset(mp,-1,sizeof(mp));
		for(i=1;i<=N;i++)
		{
			for(j=1;j<=N;j++)
				mp[i][j]=MAX;
			mp[i][i]=0;
		}
		for(i=0;i<T;i++)
		{
			cin>>a>>b>>c;
			if(mp[a][b]>c)
				mp[a][b]=mp[b][a]=c;
		}
		//difjstra
		vis[1]=1;
		int min,k,pos=1;
		//起始第一步
		for(i=1;i<=N;i++)
			p[i]=mp[1][i];

		for(j=1;j<=N;j++)
		{
			min=MAX;
			//找到
			for(i=1;i<=N;i++)
			{
				if(!vis[i] && min>p[i])
				{
					min=p[i];
					k=i;
				}
			}

			vis[k] =1;//这个点 已求
			pos=k;//记录这个点
			for(i=1;i<=N;i++)
			{
				if(!vis[i] && mp[pos][i] != MAX && p[i]>p[pos]+mp[pos][i])
					p[i] = p[pos] + mp[pos][i];
			}
		}
		cout<<p[N]<<endl;


	}

	return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <list>
#include <stack>
#include <queue>
#define MAX 100000000
using namespace std;


/*
	T1 hdu 2544
*/
int MAX=1111111111;
int mp[105][105];
int vis[105];
int p[105];
int main()
{
	int n,m;
	int i,j;
	while(cin>>n>>m && n!=0&& m!=0)
	{
		int a,b,c;
		//数组 初始化,
		memset(vis,0,sizeof(vis));
		memset(mp,-1,sizeof(mp));
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)
				mp[i][j]=MAX;
			mp[i][i]=0;
		}
		while(m--)
		{
			cin>>a>>b>>c;
			mp[a][b]=mp[b][a] = c;
		}
		//difjstra
		vis[1]=1;
		int min,min_index,pos=1;
		//起始第一步
		for(i=2;i<=n;i++)
			p[i]=mp[1][i];
		for(j=1;j<=n-1;j++)
		{
			min=MAX;
			//找到
			for(i=1;i<=n;i++)
			{
				if(!vis[i] && mp[pos][i]!= -1 && min>p[i])
				{
					min=p[i];
					min_index=i;
				}
			}

			vis[min_index] =1;//这个点 已求
			pos=min_index;//记录这个点
			for(i=1;i<=n;i++)
			{
				if(!vis[i] && mp[pos][i] != -1 && p[i]>p[pos]+mp[pos][i])
					p[i] = p[pos] + mp[pos][i];
			}
		}
		cout<<p[n]<<endl;
	}
	return 0;
}


图论：Dijkstra算法——最详细的分析，图文并茂，一次看懂！
普罗米修斯的博客
08-25 17万+
Dijstra算法
最短路径问题---Dijkstra算法详解
热门推荐
William
03-08 87万+
前言 Nobody can go back and start a new beginning,but anyone can start today and make a new ending. Name:Willam Time:2017/3/8 1、最短路径问题介绍 问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径 解决问题的算法：...
狄克斯特拉(Dijkstra)算法详解
Wopelo的博客
06-26 4万+
最近在看《算法图解》，其中第七章狄克斯特拉算法个人感觉并没有讲的清楚，比如看完7.1节给人的感觉是狄克斯特拉算法会遍历图中的每一条边，后续狄克斯特拉不适用负权边的说法就站不住脚了。后续在查阅诸多资料之后，总结文章一篇，尽可能以通俗易懂且思路清晰的方式来讲解狄克斯特拉算法。...
Dijkstra算法(最短单源路径)学习笔记
LSS
05-05 933
Dijkstra算法是一种最短路径算法，用于计算一个节点到其它所有节点的最短路径，动态路由协议OSPF中就用到了Dijkstra算法来为路由计算最短路径。 算法本身并不是按照我们的正常思维习惯，我们一般会，从原点遍历所有与之相连的节点，找到最短路径，再从最短路径上的那个点遍历与之相连的所有其它点（原点除外），然后依次类推。这样做虽然可以算出一个树形，但是在大多数情况下，这种算法会产生很多次优
算法之迪杰斯特拉（dijkstra）非常详细介绍
PRML_MAN的博客
03-07 8万+
迪杰斯特拉（dijkstra）算法是单源最短路径问题的求解方法。单源最短路径就在给出一个固定网络，指定一个原点s，一个目标点e，求这两个点之间的最短路径。举个栗子来理解一下。 小明上学的时候，从家到学校的道路非常多，小明为了减少路上骑车的时间，因此，想找出一个最短的路径。他构造一个网络图，如下： 小明是一个很喜欢动脑筋的同学，他开始研究如何才能找出最优的路径呢？ 1）所有的点到家的距离都进行初始化： 2）每次选择距离家最短的一个点，然后用这个点的距离更新其他相邻点到家的距离，如果比当前的点小，则更新节点
图论最短路dijkstra算法.doc
05-06
图论最短路 Dijkstra 算法 图论最短路 Dijkstra 算法是计算图论中从一个节点到另一个节点的最短路径的经典算法。该算法于 1959 年由荷兰数学家 Edsger W. Dijkstra 首次提出，是一种常用的图论算法。 算法描述 ...
NOIP图论最短路.pptx
07-29
最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
图论最短路方法详细介绍
07-25
在图论中，最短路问题是一个核心议题，主要涉及寻找两个或多个节点之间路径的最小代价。本文将详细介绍几种常见的最短路算法，包括Dijkstra算法、Dijkstra的堆优化、Floyd算法以及Bellman-Ford算法。 首先，...
图论matlab实现，各种图论的求解，最短路、哈密尔顿回路等等
09-07
1. **最短路算法**：最短路问题是在图中找到从一个起点到其他所有顶点的最短路径。Dijkstra算法是最常用的单源最短路径算法，适用于有向无权图或非负权重图。Floyd-Warshall算法则可以解决所有对间的最短路径问题，...
prim和dikjstra复习时。。。
coder_xia的专栏
07-06 887
以前学数据结构的时候，没认真写这俩算法，现在复习来高下，先上Prim的（严蔚敏版数据结构174页）   首先是引入结构体保存的当前最近节点和长度
最短路算法——Dijstra算法——迪杰斯特拉算法
世上再无张显宗
08-09 2434
Dijstra算法1、最短路径问题介绍2、Dijstra算法介绍3、Dijstra算法示例演示4、Dijstra代码实现-pthon 1、最短路径问题介绍 问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径 解决问题的算法： 迪杰斯特拉算法（Dijkstra算法） 弗洛伊德算法（Floyd算法） SPFA算法 2、Dijstra算法介绍 算法特点： 迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常
路径规划—详解Dijkstra算法
一地鸡毛的博客
10-08 6986
本文首先详述了Dijstra算法的定义和思路，以初始点为中心按照路径长度以递增方式层层向外扩展，直到扩展到终止点。然后使用拓扑连通图展示了其实现步骤。最后展示了在栅格地图中运用Dijstra算法的Matlab仿真效果。
Dijstra--讲解
周周的博客
09-05 441
这个算法只能计算单源最短路，而且不能计算负权值，这个算法是贪心的思想。 Dijkstra是按路径长度递增的顺序构造最短路径，每次都是从dist数组中选择最小的，然后加入已经确定出最短路的顶点的集合中，然后去更新，没有加入到已经确定出最短路的顶点的集合中，Dijkstra 每次循环都可以确定一个顶点的最短路径，故程序需要循环 n-1 次。 Dijkstra O(n^2) 单源最短路算法（计算从一...
Dijkstra算法图文详解
black_hole6的博客
11-20 37万+
Dijkstra算法 Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。 问题引入： 指定一个点（源点）到其余各个顶点的最短路径，也叫做“单源最短路径”。例如求下图中...
最短路问题
浮生若梦
05-05 373
单元最短路（Single-Soure Shortest Paths)SSSP无权图，路径是1；采用深度优先搜索，定义dist数字存储路径长度，，之后进行深度优先搜索。利用dist存储路径长度还有一个好处就是不用建立visited数组进行存储是否遍历过。dist数组初始化-1；伪码描述：void Unweight(int S){建立队列，S入队；只要队列不空，所有和S相连的W，只要W的dist是-1...
最短路径问题，djkstra算法
QPL0404157920的博客
12-16 1054
Problem C: Shortest Path Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 1007  Solved: 348 [Submit][Status][Web Board] Description Abrao is a beautiful country. It has N cities (1 ≤ N≤ 2,500)
最短路径算法（I）-Floyed、dijkstra
weixin_30877227的博客
02-22 292
弗洛伊德算法(Floyed-Warshall) 适用范围及时间复杂度 该算法的时间复杂度为O（N^3），适用于出现负边权的情况。 可以求取最短路径或判断路径是否连通。可用于求最小环，比较两点之间的大小。 （什么？？你不知道什么是负边权？？戳->http://t.cn/Ef7pbu6） 核心思想 对于任意一个K点，i到j的距离有两种可能：要么经过k点，要么不经过k点。所以我们只需要...
迪杰斯特拉算法介绍
weixin_33762130的博客
12-05 4919
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 基本思想      通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。      此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还...
图论-单源最短路径算法（拓扑，Dijkstra，Floyd，SPFA）
qq_39747794的博客
04-05 924
前言 单源最短路径是学习图论算法的入门级台阶，但刚开始看的时候就蒙了，什么有环没环，有负权没负权，下面就来总结一下求单源最短路径的所有算法以及其适用的情况。 单源最短路径 设定图中一个点为源点，求其他所有点到源点的最短路径。 先声明一点：有负环的图中没有最短路径 因为负环绕一圈的权值和是负的，只要过一遍环，路径就减小，可以反复过，无限减小 1. 无环 无负权 图求单源最短路径--...
MATLAB实现图论最短路算法
资源摘要信息:"最短路径算法在图论中是一个经典且基础的问题，它在很多实际应用中都非常重要，比如网络路由、地图导航、社交网络分析等领域。在Matlab中实现最短路径算法，可以采用多种算法，其中Floyd算法是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值