问题 A: 最短路径问题

时间限制: 1 Sec  内存限制: 128 MB
提交: 113  解决: 33
[提交][状态][讨论版][命题人: cbc]

题目描述

平面上有n个点（n<=100），每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。

若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点间的直线距离。现在的

任务是找出从一点到另一点之间的最短路径。

输入

输入共n+m+3行，其中:

第一行为整数n。

第2行到第n+1行（共n行） ，每行两个整数x和y，描述了一个点的坐标。

第n+2行为一个整数m，表示图中连线的个数。

此后的m 行，每行描述一条连线，由两个整数i和j组成，表示第i个点和第j个点之间有连线。

最后一行：两个整数s和t，分别表示源点和目标点。 

输出

输出仅一行，一个实数（保留两位小数），表示从s到t的最短路径长度。

样例输入

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

写这题最短路径跟之前的某个东西搞混了，悲伤

分析：从源点开始，一步步更新最短路径，记住初始化（源点到源点为0，其它为0x3f3f3f3f，即标记）

错点：加入队列的条件不应该判断之前有没有更新过最短路径，而是判断本次循环是否更新了路径，因为在这个点更新了路径，那么源点由这个点到其它点的路径可能是最短路径

#include<iostream>
#include<algorithm>
#include<queue>
#include<cmath>
using namespace std;
int f[101][2];
int re[101][101],sign[101];
double dis[101];
double cal(int x,int y){
	double dis1=sqrt((f[x][1]-f[y][1])*(f[x][1]-f[y][1])+(f[x][0]-f[y][0])*(f[x][0]-f[y][0]));
	return dis1;
}
int main(){
	int n,m;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>f[i][0]>>f[i][1];
	}
	cin>>m;
	int a,b;
	for(int i=1;i<=m;i++){
		cin>>a>>b;
		re[a][b]=re[b][a]=1;
	}
	int sor,des;
	cin>>sor>>des;
	for(int i=1;i<=n;i++){
		if(i==sor) dis[i]=0;
		else dis[i]=1e9;
	}
	queue<int> q;
	q.push(sor);
	sign[sor]=1;
	while(!q.empty()){
		int point=q.front();
		q.pop();
		for(int i=1;i<=n;i++){
			if(i==point) continue;
			if(re[point][i]){
				dis[i]=min(dis[i],dis[point]+cal(point,i));//更新相连的点的最短路径 
				if(!sign[i])
				{
					sign[i]=1;
					q.push(i);
				}
			}
		}
	}
	printf("%.2lf\n",dis[des]);
	return 0;
}

改过后：

#include<iostream>
#include<algorithm>
#include<queue>
#include<cmath>
using namespace std;
int f[101][2];
int re[101][101],sign[101];
double dis[101];
double cal(int x,int y){
	double dis1=sqrt((f[x][1]-f[y][1])*(f[x][1]-f[y][1])+(f[x][0]-f[y][0])*(f[x][0]-f[y][0]));
	return dis1;
}
int main(){
	int n,m;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>f[i][0]>>f[i][1];
	}
	cin>>m;
	int a,b;
	for(int i=1;i<=m;i++){
		cin>>a>>b;
		re[a][b]=re[b][a]=1;
	}
	int sor,des;
	cin>>sor>>des;
	for(int i=1;i<=n;i++){
		if(i==sor) dis[i]=0;
		else dis[i]=0x3f3f3f3f;
	}
	queue<int> q;
	q.push(sor);
	sign[sor]=1;
	while(!q.empty()){
		int point=q.front();
		q.pop();
		for(int i=1;i<=n;i++){
			if(i==point) continue;
			if(re[point][i]){
				if(dis[i]>dis[point]+cal(point,i))
				{
					dis[i]=dis[point]+cal(point,i);
					q.push(i);
				}
			}
		}
	}
	printf("%.2lf\n",dis[des]);
	return 0;
}

知识点：SPFA算法

复杂度：O( ke )   k:小常数  e:边数

适用：单源最短路

           允许负权边

详解：是Bellman-Ford算法的优化版

           图用临阶表存储

           区别是该算法是对从当前点走出的边进行更新判定

           而“当前点” 是之前距离更新后的终点，存到队列中（关键点）

           对负环的判定：一个点如果入队的次数超过n次，则表示有负