Spfa 最短路 HDU 2544

本文介绍了一个最短路径问题的解决方案,使用SPFA算法来找出从起点到终点的最短路径。该问题背景设定为帮助工作人员找到从商店到赛场的最短路线。

最短路

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 42211 Accepted Submission(s): 18474


Problem Description
在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?


Input
输入包括多组数据。每组数据第一行是两个整数N、M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1<=A,B<=N,1<=C<=1000),表示在路口A与路口B之间有一条路,我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output
对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间

Sample Input
2 1 1 2 3 3 3 1 2 5 2 3 5 3 1 2 0 0

Sample Output
3 2
#include <iostream>
#include <cstdio>
#include <string.h>
#include <deque>
#include <vector>
const int N=100+10;
const int M=N*100+10;
const int INF=1000000000;
using namespace std;
deque<int> q;
struct Edge{ 
	int to,v;
}edge;
bool book[N][N];  //去重边 
bool done[N];  //是否进队列 
int cnt[N];    //进了几次队列 
vector<Edge> ve[N];
int dis[N];
int V,E;  //V点  E边 
inline void Init(int n){
	int i,j;
	V=n; 
	for(i=1;i<=n;i++){
		ve[i].clear();
		done[i]=0;
		cnt[i]=0;
		dis[i]=INF;
		for(j=1;j<=n;j++)
		book[i][j]=0;
	}
	while(!q.empty()) q.pop_front();
}
bool Spfa(int x){
	dis[x]=0;
	cnt[x]=1;
	done[x]=1;
	q.push_back(x);
	while(!q.empty()){
		int tmp=q.front();
		q.pop_front();
		for(int i=0;i<ve[tmp].size();i++){
			Edge *e=&ve[tmp][i];
			if(dis[(*e).to]>dis[tmp]+(*e).v){
					dis[(*e).to]=dis[tmp]+(*e).v;
				if(done[(*e).to]!=1){  //不在队列里 
					if(!q.empty()){
						if(dis[(*e).to]>q.front())
						   q.push_back((*e).to);
						else
						q.push_front((*e).to);
					}
					else
					  q.push_back((*e).to); 
					  cnt[(*e).to]++;
					  done[(*e).to]=1;
				}
				if(cnt[(*e).to]>V)
			        return false;
			}	        
		}
		done[tmp]=0;
	}
	return true;
}
int main(){
	int i,a,b,t, n,m;
	Edge edge;
	while(scanf("%d%d",&n,&m)==2){
		if(n==0&&m==0)
		break;
		Init(n);
		for(i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&t);
			if(book[a][b]==1)
			continue;
			book[a][b]=1;
			book[b][a]=1;
			edge.to=b;
			edge.v=t;
			ve[a].push_back(edge);
			edge.to=a;
			ve[b].push_back(edge);
		}
		if(Spfa(1)==0)
		printf("\n");
		else
		printf("%d\n",dis[n]);		
	}
	return 0;
}


SPFA(Shortest Path Faster Algorithm)是一种用于计算单源短路径的算法,特别适用于图中存在负权边的情况。它本质上是Bellman-Ford算法的一种优化版本,通过使用队列来减少不必要的松弛操作。在SPFA中,只有那些在上一轮松弛操作中被更新的点才会参与到下一轮的松弛操作中,从而减少了计算量。 ### SPFA算法的基本思想 SPFA算法的核心在于利用广度优先搜索(BFS)的方式对图进行遍历,并且通过松弛操作来逐步找到从起点到其他所有顶点的短路径。该算法能够处理带有负权边的图,但不能处理存在负权环的情况。如果图中存在负权环,则算法可能会陷入无限循环[^3]。 ### SPFA算法的实现步骤 1. 初始化距离数组`dist[]`,将起点的距离设为0,其余顶点的距离设为无穷大。 2. 创建一个队列,并将起点加入队列。 3. 使用一个布尔数组`visit[]`来记录顶点是否已经在队列中,以避免重复入队。 4. 当队列不为空时,取出队首顶点,对其所有的邻接顶点进行松弛操作。 5. 如果某个邻接顶点的距离可以通过当前顶点得到更小的值,则更新该邻接顶点的距离,并将其加入队列(如果它不在队列中)。 6. 重复上述过程直到队列为空。 ### SPFA算法的C++实现 以下是一个简单的C++实现示例,展示了如何使用SPFA算法来求解单源短路径问题: ```cpp #include <iostream> #include <queue> #include <vector> #include <climits> using namespace std; struct Edge { int to, weight; }; void spfa(int start, vector<vector<Edge>>& graph, vector<int>& dist) { int n = graph.size(); vector<bool> inQueue(n, false); queue<int> q; dist[start] = 0; q.push(start); inQueue[start] = true; while (!q.empty()) { int u = q.front(); q.pop(); inQueue[u] = false; for (auto& edge : graph[u]) { int v = edge.to; int w = edge.weight; if (dist[v] > dist[u] + w) { dist[v] = dist[u] + w; if (!inQueue[v]) { q.push(v); inQueue[v] = true; } } } } } int main() { int n, m; cin >> n >> m; vector<vector<Edge>> graph(n); vector<int> dist(n, INT_MAX); for (int i = 0; i < m; ++i) { int u, v, w; cin >> u >> v >> w; graph[u].push_back({v, w}); } int start; cin >> start; spfa(start, graph, dist); for (int i = 0; i < n; ++i) { cout << "Distance from " << start << " to " << i << " is " << dist[i] << endl; } return 0; } ``` ### SPFA算法的时间复杂度分析 SPFA算法的时间复杂度在平均情况下为O(m),其中m是图中的边数。然而,在坏的情况下,时间复杂度可以达到O(n*m),其中n是顶点数。这是因为每个顶点可能被多次加入队列,每次加入队列后都需要对其所有邻接边进行检查[^1]。 ### SPFA算法的应用场景 - **网络路由**:SPFA可以用于计算网络中的短路径,特别是在存在负权边的情况下。 - **交通规划**:在交通网络中,可能存在某些路段因为施工等原因导致通行时间减少,这时可以使用SPFA来计算短路径。 - **社交网络分析**:在分析社交网络中的关系强度时,SPFA可以帮助找到短的关系链。 ### SPFA算法的优缺点 #### 优点 - **处理负权边**:相比Dijkstra算法,SPFA能够处理含有负权边的图。 - **效率较高**:相对于Bellman-Ford算法,SPFA通过队列优化减少了不必要的松弛操作,提高了效率。 #### 缺点 - **无法处理负权环**:如果图中存在负权环,SPFA算法可能会陷入无限循环。 - **坏情况下的性能较差**:虽然在平均情况下表现良好,但在坏情况下,SPFA的时间复杂度可能不如Dijkstra算法[^4]。 ### SPFA算法与Dijkstra算法的对比 - **适用范围**:Dijkstra算法只能处理非负权图,而SPFA可以处理含有负权边的图。 - **实现复杂度**:Dijkstra算法通常使用优先队列实现,而SPFA使用普通队列即可。 - **时间复杂度**:Dijkstra算法的时间复杂度为O((n + m) log n),其中n是顶点数,m是边数;而SPFA的平均时间复杂度为O(m),但在坏情况下为O(n*m)[^3]。 ### SPFA算法的变种 - **DFS版本的SPFA**:在某些特定情况下,如检测负权环时,可以使用深度优先搜索(DFS)版本的SPFA来提高效率[^2]。 通过以上介绍,可以看出SPFA算法在处理单源短路径问题时具有一定的优势,尤其是在存在负权边的情况下。然而,需要注意其局限性,特别是在处理负权环时的表现。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值