描述
万圣节的晚上，小Hi和小Ho在吃过晚饭之后，来到了一个巨大的鬼屋！
鬼屋中一共有N个地点，分别编号为1..N，这N个地点之间互相有一些道路连通，两个地点之间可能有多条道路连通，但是并不存在一条两端都是同一个地点的道路。
不过这个鬼屋虽然很大，但是其中的道路并不算多，所以小Hi还是希望能够知道从入口到出口的最短距离是多少？
提示：Super Programming Festival Algorithm。
“唔……地点很多，道路很少，这个鬼屋是一个稀疏图，既然这一点被特地标注出来，那么想来有其作用的咯？”小Ho道。
“是的，正好有一种最短路径算法，它的时间复杂度只和边的条数有关，所以特别适合用来解决这种边的数量很少的最短路问题！”小Hi点了点头道：“它就是SPFA算法，即Shortest Path Faster Algorithm。”
“听上去很厉害的样子，但是实际上怎么做的呢？”小Ho问道。
“你会用宽度优先搜索写这道题么？”小Hi反问道。
“这个当然会啊，构造一个队列，最开始队列里只有(S, 0)——表示当前处于点S，从点S到达该点的距离为0，然后每次从队首取出一个节点(i, L)——表示当前处于点i，从点S到达该点的距离为L，接下来遍历所有从这个节点出发的边(i, j, l)——表示i和j之间有一条长度为l的边，将(j, L+l)加入到队尾，最后看所有遍历的(T, X)节点中X的最小值就是答案咯~”小Ho对于搜索已经是熟稔于心，张口便道。
“SPFA算法呢，其实某种意义上就是宽度优先搜索的优化——如果你在尝试将(p, q)加入到队尾的时候，发现队列中已经存在一个(p, q’)了，那么你就可以比较q和q’：如果q>=q’，那么(p, q)这个节点实际上是没有继续搜索下去的必要的——算是一种最优化剪枝吧。而如果q<q’，那么(p, q’)也是没有必要继续搜索下去的——但是它已经存在于队列里了怎么办呢？很简单，将队列中的(p, q’)改成(p, q)就可以了！”
“那我该怎么知道队列中是不是存在一个(p, q’)呢？” <额，维护一个position[1..n]的数组就可以了，如果不在队列里就是-1，否则就是所在的位置！”< p>
“所以说这本质上就是宽度优先搜索的剪枝咯？”小Ho问道。
小Hi笑道：“怎么可能！SPFA算法其实是BELLMAN-FORD算法的一种优化版本，只不过在成型之后可以被理解成为宽度优先搜索的！这个问题，我们会在之后好好讲一讲的！”
输入
每个测试点（输入文件）有且仅有一组测试数据。
在一组测试数据中：
第1行为4个整数N、M、S、T，分别表示鬼屋中地点的个数和道路的条数，入口（也是一个地点）的编号，出口（同样也是一个地点）的编号。
接下来的M行，每行描述一条道路：其中的第i行为三个整数u_i, v_i, length_i，表明在编号为u_i的地点和编号为v_i的地点之间有一条长度为length_i的道路。
对于100%的数据，满足N<=10^5，M<=10^6, 1 <= length_i <= 10^3, 1 <= S, T <= N, 且S不等于T。
对于100%的数据，满足小Hi和小Ho总是有办法从入口通过地图上标注出来的道路到达出口。
输出
对于每组测试数据，输出一个整数Ans，表示那么小Hi和小Ho为了走出鬼屋至少要走的路程。
Sample Input
5 10 3 5 1 2 997 2 3 505 3 4 118 4 5 54 3 5 480 3 4 796 5 2 794 2 5 146 5 4 604 2 5 63
Sample Output
172
代码：）
用数组实现邻接表存图
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int M=2000010;
const int N=100010;
int u[M],v[M],w[M];//表示顶点u[i]到v[i]的边权值为w[i]
int first[N];//表示顶点u[i]的第一条边
int next1[M];//表示顶点u[i]的下一条边
int dis[N];//源点到各个点的距离
int in[N];//标记顶点是否在队列
queue<int> q;
int dex1=1;
void add(int u1,int v1,int w1)
{
u[dex1]=u1;
v[dex1]=v1;
w[dex1]=w1;
//最关键两步，不要把下标写错了...:(
next1[dex1]=first[u1];
first[u1]=dex1;
dex1++;
}
int main(void)
{
int n,m,s,t;
while(~scanf("%d %d %d %d",&n,&m,&s,&t))
{
int i,j;
memset(in,0,sizeof(in));
memset(first,-1,sizeof(first));
dex1=1;
int u1,v1,w1;
for(i=1;i<=m;i++)
{
scanf("%d %d %d",&u1,&v1,&w1);
//下面两句邻接表关键，不懂的在《啊哈算法》里有详细解释
add(u1,v1,w1);//无向
add(v1,u1,w1);
}
memset(dis,0x3f,sizeof(dis));//把全部赋值为INF
dis[s]=0;
q.push(s);
in[s]=1;
int k;
while(q.size())
{
k=first[q.front()];//写错就玩了如k=q.front;。。。 :(
while(k!=-1)
{
if(dis[v[k]]>dis[u[k]]+w[k])
{
dis[v[k]]=dis[u[k]]+w[k];
if(in[v[k]]==0)
{
q.push(v[k]);
in[v[k]]=1;
}
}
k=next1[k];
}
in[q.front()]=0;//
q.pop();//注意顺序
}
printf("%d\n",dis[t]);
}
return 0;
} 代码：)
用结构体实现邻接表
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
const int M=1e6+10;
const int N=1e5+10;
int dis[N],first[N],dex;
bool in[N];
struct nono
{
int val,to,next;
}a[2*M];
void add(int from,int to,int val)
{
a[dex].to=to;
a[dex].val=val;
//邻接表最关键的两步
a[dex].next=first[from];
first[from]=dex++;
}
int main(void)
{
int start,over,n,m;
scanf("%d %d %d %d",&n,&m,&start,&over);
memset(dis,0x3f,sizeof(dis));
memset(in,0,sizeof(in));
memset(first,-1,sizeof(first));
int i,j;
int u,v,w;
for(i=1;i<=m;i++)
{
scanf("%d %d %d",&u,&v,&w);
add(u,v,w);//无向图记得弄两次不然WA得很惨。。。
add(v,u,w);
}
queue<int> q;
q.push(start);
dis[start]=0;
//in[start]=1;//这个不加也ac了,但记得要加，有些数据能把这测出来WA
int k;
while(q.size())
{
k=q.front();
q.pop();
in[k]=0;
for(j=first[k];j+1;j=a[j].next)
{
int to=a[j].to;
if(dis[to]>dis[k]+a[j].val)
{
dis[to]=dis[k]+a[j].val;
if(in[to]==0)
{
in[to]=1;
q.push(to);
}
}
}
}
printf("%d\n",dis[over]);
return 0;
}