Time Limit: 1000MS | Memory Limit: 32768KB | 64bit IO Format: %I64d & %I64u |
Description
现在,已知起点和终点,请你计算出要从起点到终点,最短需要行走多少距离。
Input
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000),分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0~N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N),分别代表起点和终点。
Output
Sample Input
3 3 0 1 1 0 2 3 1 2 1 0 2 3 1 0 1 1 1 2
Sample Output
2 -1
Source
2008浙大研究生复试热身赛(2)――全真模拟
下面给出四种不同算法解决这个问题:
dijkstra算法求最短路问题,代码如下:
#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxm=0xfffffff;//让maxm=inf(一个很大的数),此处如果用max发生关键字冲突
const int maxn=200+5;
int map[maxn][maxn],vis[maxn],dist[maxn];
int n,m,sp,ep;
void getmap()
{
int i,j,a,b,c;
memset(vis,0,sizeof(vis));
for(i=0;i<n;i++)
dist[i]=maxm;//距离的初始值都设置为无穷大,得到各个孤立的点,互相之间没有边联系
for(i=0;i<n;i++)
for(j=0;j<n;j++)
map[i][j]=(i==j?0:maxm);//如果是不同的点,最短路设置为无穷大;如果是相同的点,最短路设置为0。其实此处直接map[i][j]=maxm也可以。但是前者更符合逻辑
for(i=0;i<m;i++)
{
scanf("%d%d%d",&a,&b,&c);
map[a][b]=map[b][a]=map[a][b]<c?map[a][b]:c;//得到两点之间的最短路,两个地方之间可能不止一条双向道路
}
}
void dij()
{
int i,cur,next,min;
dist[sp]=0;//起点最短路设置为0
cur=sp;//当前为起点
while(1)
{
vis[cur]=1;
min=maxm;
for(i=0;i<n;i++)
{
if(vis[i]==1) continue;//此处可以解释为什么直接map[i][j]=maxm也可以。(如果是同个点,会被跳过)
if(dist[i]-map[i][cur]>dist[cur])
dist[i]=map[i][cur]+dist[cur];//如果某点最短路大于该点到cur点的最短路+cur点的最短路,让该点的最短路等于后者的和。重点地方,注意理解!!
if(dist[i]<min)//如果某个点的最短路小于当前最短路,替换之,并将next改成这个点的下标
{
min=dist[i];
next=i;
}
}
cur=next;
if(cur==ep) break;//若能到达终点,结束
if(min==maxm) break;//若不能到达终点,也结束,此时最短路为无穷大
}
printf("%d\n",dist[ep]==maxm?-1:dist[ep]);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
getmap();
scanf("%d%d",&sp,&ep);
dij();
}
return 0;
}
floyd算法:
#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxm=0xfffffff;//让maxm=inf(一个很大的数),此处如果用max发生关键字冲突
const int maxn=200+5;
int map[maxn][maxn];
int n,m,sp,ep;
void getmap()
{
int i,j,a,b,c;
//memset(vis,0,sizeof(vis));
//for(i=0;i<n;i++)
//dist[i]=maxm;//距离的初始值都设置为无穷大,得到各个孤立的点,互相之间没有边联系
for(i=0;i<n;i++)
for(j=0;j<n;j++)
map[i][j]=(i==j?0:maxm);//如果是不同的点,最短路设置为无穷大;如果是相同的点,最短路设置为0
for(i=0;i<m;i++)
{
scanf("%d%d%d",&a,&b,&c);
map[a][b]=map[b][a]=map[a][b]<c?map[a][b]:c;//得到两点之间的最短路,注意体会
}
}
void floyd()//记住这种写法
{
int i,k,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
for(k=0;k<n;k++)
map[j][k]=min(map[j][k],map[j][i]+map[i][k]);//重点
printf("%d\n",map[sp][ep]==maxm?-1:map[sp][ep]);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
getmap();
scanf("%d%d",&sp,&ep);
floyd();
}
return 0;
}
最短路的Floyd算法,这个就简单得多了,就是在整个图中扫描,看点 i 到 j 的距离和(点 i 到点 k 的距离)+(点 k 到点 j 的距离)两者哪个较小,把小的存入map[i][j]中即可。Floyd算法优势在于可以处理负边权的图,而且函数计算的是图中任意两点间的最短路;但其效率不高,空间开销较大,对于密集点图较为实用。
Bellman-Ford算法:
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxx=0xfffffff;
const int maxn=2000+5;
const int maxm=200+5;
int n,m,sp,ep;
int dist[maxm];
struct Map
{
int x,y,w;
}map[maxn];
void getmap()
{
int i;
for(i=0;i<m;i++)
{
scanf("%d%d%d",&map[i].x,&map[i].y,&map[i].w);
map[i+m].x=map[i].y;
map[i+m].y=map[i].x;
map[i+m].w=map[i].w;
}
}
void Bellman_Ford()
{
int i,j;
for(i=0;i<n;i++)
dist[i]=maxx;
dist[sp]=0;
for(i=0;i<n;i++)
for(j=0;j<2*m;j++)
dist[map[j].x]=min(dist[map[j].x],dist[map[j].y]+map[j].w);
//每次松弛,至少可以多得到一个点到源点的最短路,且所有边都会被遍历
//if(dist[map[j].x]>dist[map[j].y]+map[j].w)
//dist[map[j].x]=dist[map[j].y]+map[j].w;
printf("%d\n",dist[ep]==maxx?-1:dist[ep]);
}
int main()
{
int i,j;
while(scanf("%d%d",&n,&m)!=EOF)//坑爹的hdu,没有!=EOF居然Time Limit Exceeded
{
getmap();
scanf("%d%d",&sp,&ep);
Bellman_Ford();
}
return 0;
}
Bellman-Ford基本思想:
即进行不停地松弛
每次松弛把每条边都更新一下
每次松弛操作,一定可以多确定一个点到源点的最短路
若n-1次松弛后还能更新?
则说明图中有负环!
SPFA算法,代码:
#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=205;
const int inf=0xfffffff;
int cost[maxn],visit[maxn],map[maxn][maxn],q[maxn];
int n,m,sp,ep;
void getmap()
{
int i,j,a,b,c;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
map[i][j]=inf;
//for(i=0;i<n;i++)
//map[i][i]=0;//这两行可以不用(但为了逻辑清晰,还是加上好,毕竟只有一重循环)
for(i=0;i<m;i++)
{
scanf("%d%d%d",&a,&b,&c);
map[a][b]=map[b][a]=min(map[a][b],c);
}
}
void spfa()
{
int front=0,rear=0,i,j,x;
q[++rear]=sp;//q从下标1开始
memset(visit,0,sizeof(visit));
visit[sp]=1;
for(i=0;i<n;i++)
cost[i]=inf;
cost[sp]=0;
while(front!=rear)
{
front=(front+1)%(n+1);//保证q从1到n
x=q[front];
visit[x]=0;//设置出队的点为未标志
for(i=0;i<n;i++)
if(cost[i]>cost[x]+map[i][x])//如果松弛成功
{
cost[i]=cost[x]+map[i][x];//更新路径,得到新的权值(新的最短路)
if(!visit[i])//如果未被标志,即未入队
{
rear=(rear+1)%(n+1);
q[rear]=i;//入队
visit[i]=1;//更新标志
}
}
}
printf("%d\n",cost[ep]==inf?-1:cost[ep]);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
getmap();
scanf("%d%d",&sp,&ep);
spfa();
}
return 0;
}
算法步骤:
用数组d记录每个结点的最短路径估计值
设立一个队列用来保存待优化的结点
优化时每次取出队首结点u
用d[u]来对离开u指向的节点v进行松弛操作
如果v点的最短路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾
不断从队列中取出结点来进行松弛操作,直至队列空为止
附录:
- /*
- 编辑本段SPFA算法
- 求单源最短路的SPFA算法的全称是:Shortest Path Faster Algorithm。 SPFA算法是西南交通大学段凡丁于1994年发表的. 从名字我们就可以看出,这种算法在效率上一定有过人之处。
- 很多时候,给定的图存在负权边,这时类似Dijkstra等算法便没有了用武之地,而Bellman-Ford算法的复杂度又过高,SPFA算法便派上用场了。 简洁起见,我们约定有向加权图G不存在负权回
- 路,即最短路径一定存在。当然,我们可以在执行该算法前做一次拓扑排序,以判断是否存在负权回路,但这不是我们讨论的重点。 我们用数组d记录每个结点的最短路径估计值,而且用邻接表来
- 存储图G。我们采取的方法是动态逼近法:设立一个先进先出的队列用来保存待优化的结点,优化时每次取出队首结点u,并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作,如果v
- 点的最短路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作,直至队列空为止。 定理: 只要最短路径存在,上述SPFA算法必定能求出最
- 小值。 证明:每次将点放入队尾,都是经过松弛操作达到的。换言之,每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路,
- 所以每个结点都有最短路径值。因此,算法不会无限执行下去,随着d值的逐渐变小,直到到达最短路径值时,算法结束,这时的最短路径估计值就是对应结点的最短路径值。(证毕) 期望的时间
- 复杂度O(ke), 其中k为所有顶点进队的平均次数,可以证明k一般小于等于2。 实现方法:建立一个队列,初始时队列里只有起始点,在建立一个表格记录起始点到所有点的最短路径(该表格的初
- 始值要赋为极大值,该点到他本身的路径赋为0)。然后执行松弛操作,用队列里有的点去刷新起始点到所有点的最短路,如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队
- 列为空 判断有无负环:如果某个点进入队列的次数超过N次则存在负环(SPFA无法处理带负环的图)
- */
- // 该注意的是有些点可能重复入队,所以出队的点也要重新置未标记