【原创】求最短路径-dijkstra算法

有这样一类题,它要求你从某个点出发,到某个为止走过的最短路径。

上一次,我们学习了弗洛伊德算法,这次,我们来看看dijkstra算法。


从起点出发,有很多条路可以走,走哪一条路最短呢?

枚举出来看一看吧。依次枚举每条边。走最短的那一条路,最后到达终点时就一定最短啦!~\(≧▽≦)/~

但是这种做法有瑕疵:不能处理负权边,负权回路,O(n²)的代码只适合单源点,即只有出发点到目标点的距离,不像弗洛伊德可以处理任意两点的距离。

这种算法的时间复杂度为O(n²),改一改改成多源点就是O(n³)了。

详见代码:

//dis[i][j]:从i点到j点的距离,
//ans[i]:i点到源点的距离,
//bobo[i]:i点有没有走过
for(int i=1;i<=n;i++) ans[i]=dis[i][begin];
bobo[begin]=true; ans[begin]=0;//标记一下
for(int i=1;i<=n;i++)
{
	mini=VeryBig;
	int p=-1;//以此点出发,最短的路径的点的下表
	for(int j=1;j<=n;j++)
		if(!bobo[j] && ans[j]<mini)
			mini=ans[j],p=j;//若没有访问过且此点是最短路径,标记一下
	if(p<0) break;
	bobo[p]=true;//标记一下
	for(int j=1;j<=n;j++)
		ans[j]=min(dis[p][j]+ans[p],ans[j]);//尝试改变以此点出发的边的另一个端点的的值
}


我们还可以写出多源点的dijkstra算法。(应该可以吧,我没试过)

//dis[i][j]:从i点到j点的距离,
//ans[i][j]:i点到j点的最短距离,
//bobo[i]:i点有没有走过
for(int t=1;t<=n;t++)
{
	memset(bobo,0,sizeof bobo);
	for(int i=1;i<=n;i++) ans[t][i]=dis[i][begin];
	bobo[begin]=true; ans[t][begin]=0;//标记一下
	for(int i=1;i<=n;i++)
	{
		mini=VeryBig;
		int p=-1;//以此点出发,最短的路径的点的下表
		for(int j=1;j<=n;j++)
			if(!bobo[j] && ans[t][j]<mini)
				mini=ans[t][j],p=j;//若没有访问过且此点是最短路径,标记一下
		if(p<0) break;
		bobo[p]=true;//标记一下
		for(int j=1;j<=n;j++)
			ans[t][j]=min(dis[p][j]+ans[t][p],ans[t][j]);//尝试改变以此点出发的边的另一个端点的的值
	}
}

再来做一道例题吧!


题目描述


平面上有n个点(n<=100),每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线,则表示可从一个点到达另一个点,即两点间有通路,通路的距离为两点间的直线距离。现在的任务是找出从一点到另一点之间的最短路径。

输入

第1行:1个整数n
第2..n+1行:每行2个整数x和y,描述了一个点的坐标
第n+2行:1个整数m,表示图中连线的数量
接下来有m行,每行2个整数i和j,表示第i个点和第j个点之间有连线

最后1行:2个整数s和t,分别表示源点和目标点

输出

第1行:1个浮点数,表示从s到t的最短路径长度,保留2位小数

样例输入

5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5

样例输出

3.41

详见代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<stack>
#include<map>  
#include<vector>  
#include<functional>  
using namespace std;
const int VeryBig=9999999;
struct Epic
{
	int x,y;
}point[111];
double dis[111][111],ans[111];
int n,m,begin,end,a,b,bobo[111],mini;
void in()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d %d",&point[i].x,&point[i].y);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			dis[i][j]=ans[i]=VeryBig;
	scanf("%d",&m);
	for(int i=1;i<=m;i++)
	{
		scanf("%d %d",&a,&b);
		dis[a][b]=dis[b][a]=sqrt(double((point[a].x-point[b].x)*(point[a].x-point[b].x)+(point[a].y-point[b].y)*(point[a].y-point[b].y)));
	}
	scanf("%d %d",&begin,&end);
}
void search()
{
	for(int i=1;i<=n;i++) ans[i]=dis[i][begin];
	bobo[begin]=true; ans[begin]=1;
	for(int i=1;i<=n;i++)
	{
		mini=VeryBig;
		int p=-1;
		for(int j=1;j<=n;j++)
			if(!bobo[j] && ans[j]<mini)
				mini=ans[j],p=j;
		if(p<0) break;
		bobo[p]=true;
		for(int j=1;j<=n;j++)
			ans[j]=min(dis[p][j]+ans[p],ans[j]);
	}
}
int main()
{
	/*freopen("dijkstra.in","r",stdin);
	freopen("dijkstra.out","w",stdout);*/
	in();
	search();
	printf("%.2lf",ans[end]);
	return 0;
} 



  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Dijkstra算法是一种用于解决单源最短路径问题的算法。它的基本思想是从起点开始,逐步扩展到其他节点,每次选择当前距离起点最近的节点,并更新与该节点相邻的节点的距离。通过这种方式,可以找到起点到其他节点的最短路径Dijkstra算法的时间复杂度为O(n^2),但是可以通过使用堆优化来将其优化到O(nlogn)。 ### 回答2: Dijkstra算法是一种解决单源最短路径问题的贪心算法,其思想是利用“松弛”操作来不断更新当前点到源点的最短距离,但前提是所有边的权重非负。如果有负权边,则需要使用Bellman-Ford算法。 首先,我们需要定义一个数组dis数组,用于存储源点s到各个点的最短距离。dis[s]初始为0,其他点初始为无限大。接着,我们需要维护一个集合S,表示已经最短路径的点的集合。将源点s加入集合S中。 对于每个未加入S的点v,我们通过选择其它点到源点s的最短路径中的一个点u,然后将dis[v]更新为dis[u] + w(u,v),其中w(u,v)表示边(u,v)的权重。具体地,这个操作称为“松弛”操作。 在松弛操作中,我们需要比较dis[u] + w(u,v)和dis[v]的大小,如果前者更小,则更新dis[v]的值为dis[u] + w(u,v)。 重复执以上操作,直到所有的点都加入到集合S中。最后dis数组中存储的就是源点s到所有点的最短距离。 Dijkstra算法可以用堆优化,时间复杂度为O(mlogn),其中n表示图中的点数,m表示边数。Dijkstra算法也可以应用于稠密图,时间复杂度为O(n^2)。 总之,Dijkstra算法是一种经典的解单源最短路径问题的算法,其实现简单,效率高,被广泛应用于路由算法和图像处理等领域。 ### 回答3: Dijkstra算法是一种在加权有向图中寻找从源节点到其他节点的最短路径的贪心算法。该算法基于其它路径加权节点的已知最短路径去更新更长路径的信息直到找到从源节点到目标节点的最短路径。在整个计算过程中,Dijkstra算法需要维护一个待处理节点集合和一个距离源节点的最短路径数组。 算法的具体实现如下: 1. 初始化源节点及其距离为0,其他节点的距离为无穷大。 2. 将源节点加入到待处理节点集合中。 3. 对于源节点的所有相邻节点,更新它们距离源节点的最短路径。如果当前路径小于之前已知的最短路径,则更新最短路径数组。 4. 遍历待处理节点集合中除源节点外的节点,选择距离最近的节点作为当前节点,并将它从待处理机集合中移除。 5. 对于当前节点的所有相邻节点,更新它们距离源节点的最短路径。如果当前路径小于之前已知的最短路径,则更新最短路径数组。 6. 重复步骤4和5,直到待处理节点集合为空或者目标节点已经被遍历。 Dijkstra算法的时间复杂度为O(n^2),其中n为节点数,由于它是贪心算法,只能处理非负权重的图,否则可能会陷入死循环。但是,Dijkstra算法是单源最短路径问题的最优解,因此在处理小规模的图时效果很好。在处理大规模图时,需要使用其他高效的算法,如A*算法、Bellman-Ford算法等。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值