【洛谷】P3371单源最短路径

【洛谷】P3371单源最短路径

题目背景

本题测试数据为随机数据，在考试中可能会出现构造数据让SPFA不通过。

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入格式

第一行包含三个整数 n,m,s，分别表示点的个数、有向边的个数、出发点的编号。

接下来 m 行每行包含三个整数 u,v,w，表示一条 u→v 的，长度为 w 的边。

输出格式

输出一行 n 个整数，第 i 个表示 s 到第 i 个点的最短路径，若不能到达则输出 2³¹−1。

输入输出样例

输入

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出

0 2 4 3

说明/提示

【数据范围】
对于 20%20% 的数据：1≤n≤5，1≤m≤15；
对于 40%40% 的数据：1≤n≤100，1≤m≤10⁴
对于 70%70% 的数据：1≤n≤1000，1≤m≤10⁵
对于 100%100% 的数据：1≤n≤10⁴ 1≤m≤5×10⁵ ，保证数据随机。

思路

用SPFA做单源最短路径；
SPFA是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
主要思想是：
初始时将起点加入队列。每次从队列中取出一个元素，并对所有与它相邻的点进行修改，若某个相邻的点修改成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford，利用了每个点不会更新次数太多的特点发明的此算法。
SPFA 在形式上和广度优先搜索非常类似，不同的是广度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是说一个点修改过其它的点之后，过了一段时间可能会获得更短的路径，于是再次用来修改其它的点，这样反复进行下去。
算法时间复杂度：O(kE)，E是边数。K是常数，平均值为2。

注意到Bellman-Ford算法实际上做了很多无用功。因为每次它都把所有的边枚举一次，而有一些边在上一次枚举中，起始端顶点都没有更新，那么在这一次枚举中，肯定不会进行松弛。那么我们可以使用一个队列来进行活跃点的维护。我们定义在这个队列里的每个元素x都必须满足：d[x]被更新，但是未利用d[x]去更新其它的点。那么初始时把起始点1放进队列里面，然后对它进行松弛操作，并把d值被更新的点放入队列之中，最后把当前这个做完松弛操作的点出队。重复这个操作直到队列中没有元素，那么所有点的d值都被确定了。
这个算法同样可用于有负权边的情况之中。此外，该算法也可以用来判断负权环，具体方法就是如果某一个点入队超过n次,那么判断有负权环。
时间复杂度O(kE),其中k为一个小常数，大致在[3,5]这个范围内。

算法实现：
dis[i]记录从起点s到i的最短路径，w[i][j]记录连接i，j的边的长度。pre[v]记录前趋。
team[1…n]为队列，头指针head，尾指针tail。
布尔数组exist[1…n]记录一个点是否现在存在在队列中。
初始化：dis[s]=0,dis[v]=∞（v≠s），memset(exist,false,sizeof(exist));
起点入队team[1]=s; head=0; tail=1;exist[s]=true;
do
{
1、头指针向下移一位，取出指向的点u。
2、exist[u]=false;已被取出了队列
3、for与u相连的所有点v //注意不要去枚举所有点，用数组模拟邻接表存储
if (dis[v]>dis[u]+w[u][v])
{
dis[v]=dis[u]+w[u][v];
pre[v]=u;
if (!exist[v]) //队列中不存在v点，v入队。
{
//尾指针下移一位，v入队;
exist[v]=true;
}
｝
}
while (head < tail);
循环队列：
　　采用循环队列能够降低队列大小，队列长度只需开到2*n+5即可。

代码

#include<iostream>
#include<cstdio>
#include<cstring> 
#include<queue>
using namespace std;
bool d[10010];
int n,m,st,dis[10010],head[10010],tot=0;
struct jgt
{
	int x,y,nxt,s;
}f[500010];
queue<int> q;
void input()//建边 
{
	int i,x,y,z;
	scanf("%d%d%d",&n,&m,&st);
	for(i=1;i<=m;i++)
	{
		tot++;
		scanf("%d%d%d",&f[tot].x,&f[tot].y,&f[tot].s);
		f[tot].nxt=head[f[tot].x];
		head[f[tot].x]=tot;
	}
	return;
}
void SPFA()
{
	int l,r,i;
	memset(d,0,sizeof(d));
	for(i=0;i<=n;i++)
		dis[i]=2147483647;
	dis[st]=0;
	for(q.push(st),d[st]=1;!q.empty();q.pop())//队列优化 
	{
		for(i=head[q.front()];i;i=f[i].nxt)
			if(dis[f[i].y]>dis[q.front()]+f[i].s)//松弛 
			{
				dis[f[i].y]=dis[q.front()]+f[i].s;
				if(!d[f[i].y])
				{
					q.push(f[i].y);//加入队列 
					d[f[i].y]=1;
				}
			}
		d[q.front()]=0;//退出队列 
	}
	return;
}
void output()
{
	int i;
	for(i=1;i<=n;i++)
		printf("%d ",dis[i]);
	return;
}
int main()
{
	input();
	SPFA();
	output();
	return 0;
}