单源最短路SPFA

#include <bits/stdc++.h>
#define INF (1<<30)
#define MAX 200010

using namespace std;

struct edge { int to, next, w; };
edge es[MAX];
int v, e, cnt;
int head[MAX], d[MAX], in[MAX];
bool vis[MAX];

void add_edge(int u, int v, int w)
{
	es[++cnt].to = v;
	es[cnt].next = head[u];
	es[cnt].w = w;
	head[u] = cnt;
}

bool spfa(int st)
{
	queue<int> q;
	for (int i = 0; i < max(v, e); i++) {
		vis[i] = 0;
		d[i] = INF;
		in[i] = 0;
	}
	q.push(st);
	vis[st] = 1;
	d[st] = 0;
	while (!q.empty()) {
		int t = q.front();
		q.pop();
		vis[t] = 0;
		for (int i = head[t]; i; i = es[i].next) {
			int temp = es[i].to;
			if (d[temp] > d[t] + es[i].w) {
				d[temp] = d[t] + es[i].w;
				if (!vis[temp]) {
					q.push(temp);
					vis[temp] = 1;
					if (++in[temp] >= v) return false; //有环
				}
			}
		}
	}
	return true;
}

int main()
{
	int s, t;
	cin >> v >> e >> s >> t;
	cnt = 0;
	for (int i = 1; i <= e; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		add_edge(u, v, w);
	}
	if (spfa(s)) cout << d[t] << endl;
	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算法在处理单源短路问题时具有一定的优势,尤其是在存在负权边的情况下。然而,需要注意其局限性,特别是在处理负权环时的表现。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水能zai舟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值