| 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无法处理带负环的图）
- */
- // 该注意的是有些点可能重复入队，所以出队的点也要重新置未标记
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
