HDU 3790 最短路径问题

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3790

SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：


设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。


维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。


每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。


SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。


SPFA算法（Shortest Path Faster Algorithm），也是求解单源最短路径问题的一种算法，用来解决：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算，他的基本算法和Bellman-Ford一样，并且用如下的方法改进： 1、第二步，不是枚举所有节点，而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环，还可以通过下面的方法： 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。


SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define INF 0xffffff
struct node
{
	int len;
	int cost;
};
node map[1005][1005];
node dis[1005];
bool vis[1005];
node spfa(int s, int e, int n)
{
	int i;
	for(i = 1; i <= n; i++)
	{
		dis[i].len = INF;
		dis[i].cost = INF;
	}
	dis[s].len = 0;
	dis[s].cost = 0;
	queue<int>Q;
	Q.push(s);
	vis[s] = true;
	while(!Q.empty())
	{
		int mid = Q.front();
		Q.pop();
		vis[mid] = false;
		for(i = 1; i <= n ; i++)
		{
			if(map[mid][i].len + dis[mid].len < dis[i].len)
			{
				dis[i].len = map[mid][i].len + dis[mid].len;
				dis[i].cost = map[mid][i].cost + dis[mid].cost;
				if(!vis[i])
				{
					Q.push(i);
					vis[i] = true;
				}
			}
			if(map[mid][i].len + dis[mid].len == dis[i].len && dis[i].cost > map[mid][i].cost + dis[mid].cost)
			{
				dis[i].cost = map[mid][i].cost + dis[mid].cost;
			}
		}
	}
	return dis[e];
}
int main()
{
	int n, m;
	int a, b, c, d, s, e;
	while(scanf("%d%d", &n, &m) && (n || m))
	{
		for(int i = 1; i <= n; i++)
		{
			for(int j = 1; j <= n; j++)
			{
				map[i][j].len = INF;
				map[i][j].cost = INF;
			}
		}
		memset(vis, false, sizeof(vis));
		for(int i = 1; i <= m ; i++)
		{
			scanf("%d%d%d%d", &a, &b, &c, &d);
			if(c < map[a][b].len)
			{
				map[a][b].len = c;
				map[b][a].len = c;
				map[a][b].cost = d;
				map[b][a].cost = d;
			}
		}
		scanf("%d%d", &s, &e);
		node ans = spfa(s, e, n);
		printf("%d %d\n", ans.len, ans.cost);
	}
	return 0;
}