首页 > 其他 > 详细

SPFA算法求最短路径

时间:2014-02-22 09:21:19      阅读:411      评论:0      收藏:0      [点我收藏+]

SPFA算法求最短路径

题目描述:
给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的。
输入:
输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p。最后一行是两个数 s,t;起点s,终点t。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)
输出:
输出 一行有两个数, 最短距离及其花费。
样例输入:
3 2
1 2 5 6
2 3 4 5
1 3
0 0
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无法处理带负环的图)
(“算法编程后实际运算情况表明m一般没有超过2n.事实上顶点入队次数m是一个不容易事先分析出来的数,但它确是一个随图的不同而略有不同的常数.所谓常数,就是与e无关,与n也无关,仅与边的权值分布有关.一旦图确定,权值确定,原点确定,m就是一个确定的常数.所以SPFA算法复杂度为O(e)(证毕)[1]”——SPFA的论文
事实上这个证明是非常不严谨甚至错误的,事实上在bellman算法的论文中已有这方面的内容,所以国际上一般不承认SPFA算法)(摘自百度百科)
AC代码:
#include<cstdio>
#include<vector>
#include<queue>
#define MAX 1010
#define INF 0x0FFFFFFF
using namespace std;

typedef struct Node
{
	int adjvertex;
	int len;
	int cost;
}Node;

int visited[MAX];
int distances[MAX];
int costs[MAX];
vector<Node> map[MAX];

void SPFA(int start,int n)
{
	int i,j;
	queue<int> q;
	q.push(start);
	for(i=1;i<=n;i++)
	{
		distances[i]=costs[i]=INF;
		visited[i]=0;
	}
	distances[start]=costs[start]=0;
	while(!q.empty())
	{
		int index;
		index=q.front();
		q.pop();
		visited[index]=1;
		for(i=0;i<map[index].size();i++)
		{
			int t=map[index][i].adjvertex;
			int dis=map[index][i].len;
			int cost=map[index][i].cost;
			if(distances[t]==INF||distances[t]>distances[index]+dis)
			{
				distances[t]=distances[index]+dis;
				costs[t]=costs[index]+cost;
				if(!visited[t])
				{
					q.push(t);
					visited[t]=1;//剪枝作用
				}
			}
			else if(distances[t]==distances[index]+dis)
			{
				if(costs[t]>costs[index]+cost)
				{
					costs[t]=costs[index]+cost;
					if(!visited[t])
					{
						q.push(t);
						visited[t]=1;
					}
				}
			}
		}
	}
}

int main(int argc,char *argv[])
{
	int i,n,m;
	int start,end;
	while(scanf("%d%d",&n,&m)&&n&&m)
	{
		for(i=0;i<MAX;i++)
			map[i].clear();
		for(i=0;i<m;i++)
		{
			Node p,q;
			int index;
			scanf("%d",&index);
	        scanf("%d%d%d",&(p.adjvertex),&(p.len),&(p.cost));
    	    map[index].push_back(p);
	        q.adjvertex=index;
	        q.len=p.len;
	        q.cost=p.cost;
	        map[p.adjvertex].push_back(q);
    	}
	    scanf("%d%d",&start,&end);
	    SPFA(start,n);
    	printf("%d %d\n",distances[end],costs[end]);
	}

	return 0;
}
Dijkstra算法也可以解决:
#include<cstdio>
#include<vector>
#define MAX 1010
#define INF 0x0FFFFFFF
using namespace std;

typedef struct Node
{
	int adjvertex;
	int len;
	int cost;
}Node;

int visited[MAX];
int distances[MAX];
int costs[MAX];
vector<Node> map[MAX];

void Dijkstra(int start,int n)
{
	int i,j,k,t;
	int dis,cost;
	int min=INF,t_cost;
	for(i=1;i<=n;i++)
	{
		distances[i]=INF;
		costs[i]=0;
		visited[i]=0;
	}
	for(i=0;i<map[start].size();i++)
	{
		int index;
		index=map[start][i].adjvertex;
		distances[index]=map[start][i].len;
		costs[index]=map[start][i].cost;
	}
	distances[start]=0;
	visited[start]=1;
	for(i=1;i<n;i++)
	{
		min=INF;
		for(j=1;j<=n;j++)
		{
			if(!visited[j]&&distances[j]<min)
			{
				k=j;
				min=distances[j];
				t_cost=costs[j];
			}
		}
		visited[k]=1;
		for(j=1;j<=n;j++)
		{
			for(t=0;t<map[k].size();t++)
			{
				if(map[k][t].adjvertex!=j)
					continue;
				else
					break;
			}
			if(t!=map[k].size())
			{
				dis=map[k][t].len;
				cost=map[k][t].cost;
			}
			else
			{
				dis=INF;
				cost=INF;
			}
			if(!visited[j]&&distances[j]>dis+min)
			{
				distances[j]=dis+min;
				costs[j]=t_cost+cost;
			}
			else if(!visited[j]&&distances[j]==dis+min&&costs[j]>cost+t_cost)
			{
				distances[j]=dis+min;
				costs[j]=t_cost+cost;
			}
		}
	}
}

int main(int argc,char *argv[])
{
	int i,n,m;
	int start,end;
	while(scanf("%d%d",&n,&m)&&n&&m)
	{
		for(i=0;i<MAX;i++)
			map[i].clear();
		for(i=0;i<m;i++)
		{
			Node p,q;
			int index;
			scanf("%d",&index);
	        scanf("%d%d%d",&(p.adjvertex),&(p.len),&(p.cost));
    	    map[index].push_back(p);
	        q.adjvertex=index;
	        q.len=p.len;
	        q.cost=p.cost;
	        map[p.adjvertex].push_back(q);
    	}
	    scanf("%d%d",&start,&end);
	    Dijkstra(start,n);
    	printf("%d %d\n",distances[end],costs[end]);
	}

	return 0;
}
用二维数组解决Dijkstra问题会比较方便,用STL使程序看起来略显繁琐,算了,不想再优化了,就这样吧。。。

SPFA算法求最短路径

原文:http://blog.csdn.net/cstopcoder/article/details/19625455

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!