图论 最短路 SPFA + 前向星存边

本文详细介绍了一种基于Bellman-Ford算法的改进版本——SPFA算法,该算法适用于含有负权边的单源最短路径问题及负权环的判断。文章通过链式前向星数据结构实现了高效的边存储方式,并提供了完整的SPFA算法代码实现。

SPFA模板题

  • 介绍
    ====
  • SPFA

SPFA已死

SPFA是基于Bellman - Ford的一种贼快的算法, 用队列来实现。
通常用于求含负权边的单源最短路径,以及判负权环。
SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同,为 O(VE)。
(参考百度百科)

毒瘤数据免谈

  • 前向星

一个数据结构,里面的成员可以存储起点,终点和权值。
要有一个数组维护每点连出去的边的起点。

1.链式前向星构造

这里我们使用的是链式前向星,用结构体储存每一条边:

struct Edge
{
	 //其实还可以记录这条边的起点,但这题没必要
     int next;  //表示这条边所指向的下一条边
     int to;  //这条边的终点
     int w;  //权值
};

再开个first数组

first[i] 表示以i为起点的第一条边

2.加边

first[i]其实就是以i为起点的边所组成的链表的第一个元素。

每次加边,我们让first[i]这条边指向要加的边,再将所加的边更新为first[i]。

因此,我们每次遍历是倒着遍历的:

void AddEdge(int begin, int end, int w)
{
	len++; //第len条边
	e[len] = Edge{first[begin], end, w};   
    //first[begin]是当前所加的边指向的下一条边 
	first[begin] = len;  //first是保存下标的   
};

3.遍历

从第一条边开始,e[i].[next] 即为下一条边的编号,从而遍历以s为起点的所有边,当边的编号为0时即跳出循环

for (int i = first[s]; i; i = e[i].next)
  • 算法
    ======
    这里写图片描述

思想:
我们先将起点入队, 将所有与起点相连的点进行松弛操作。
如果松弛成功的点不在队列里,就把它进队。
最后队空即结束。

上代码:

#include <bits/stdc++.h>
#define INF 2147483647
#define MAXN 10000
#define MAXM 500000
using namespace std;

struct Edge { //前向星存边 
	int next, to, w;  
	//next:下一条边, to, w:此边终点和此边权值 
}e[500030];
int n, m, s, x, y, w, len;
int first[MAXN + 30], d[MAXN + 30], vis[MAXN + 30];
//d[i]:起点到i的最短路, first[i]:i的第一条出边, vis[i]:记录i是否在队列里 

void AddEdge(int a, int b, int v) {  //加边 
	len++;         
	e[len] = Edge{first[a], b, v};
	first[a] = len;
}
void SPFA() {
	for (int i = 1; i <= n; ++i)
		d[i] = INF;
	d[s] = 0;  
	queue < int > q;
	q.push(s); 
	vis[s] = 1;
	//初始化
	
	while (!q.empty() ) {
		x = q.front(); 
		q.pop();  
		vis[x] = 0;
		for (int i = first[x]; i != 0; i = e[i].next) { //前向星遍历 
			y = e[i].to;
			if (d[x] + e[i].w < d[y]) {  // 松弛
				d[y] = d[x] + e[i].w;
				if (vis[y] == 0){
					q.push(y);
					vis[y] = 1;  //标记在队列里 
				}
			}
		}
	} 
}

int main() 
{
	scanf ("%d%d%d", &n, &m, &s);
	for (int i = 1; i <= m; ++i) {
		scanf ("%d%d%d", &x, &y, &w);
		AddEdge(x, y, w);
	}
	
	SPFA();
	
	for (int i = 1; i <= n; ++i) 
		printf("%d ", d[i]);
	printf("\n");
	return 0;
}

撒花结束

### SPFA算法概述 SPFA(Shortest Path Faster Algorithm)是一种基于Bellman-Ford算法的改进版本,主要用于求解含有负权的单源短路径问题。它通过引入队列来加速松弛操作的过程,在实际应用中表现出了较高的效率[^2]。 SPFA的核心思想是对图中的每条进行松弛操作,直到无法进一步更新为止。与传统的Bellman-Ford相比,SPFA仅对那些可能会影响其他节点距离值的顶点执行松弛操作,从而减少了不必要的计算开销[^3]。 --- ### SPFA算法实现 以下是SPFA算法的一个基本实现: #### 邻接表建图 SPFA通常采用邻接表的方式储图结构,这有助于减少空间消耗并提高访问速度。 ```cpp #include <iostream> #include <queue> #include <vector> #include <cstring> using namespace std; const int INF = 0x3f3f3f3f; struct Edge { int to, weight; }; int n, m, s; // 节点数、数、起点编号 vector<Edge> adj[1000]; // 邻接表 bool inQueue[1000]; long long dist[1000]; void spfa(int start) { queue<int> q; memset(dist, 0x3f, sizeof(dist)); // 初始化为无穷大 memset(inQueue, false, sizeof(inQueue)); dist[start] = 0; q.push(start); inQueue[start] = true; while (!q.empty()) { int u = q.front(); q.pop(); inQueue[u] = false; for (auto &edge : adj[u]) { // 对u的所有邻居进行遍历 if (dist[edge.to] > dist[u] + edge.weight) { // 松弛条件 dist[edge.to] = dist[u] + edge.weight; if (!inQueue[edge.to]) { // 如果未入队则加入队列 q.push(edge.to); inQueue[edge.to] = true; } } } } } ``` 上述代码实现了SPFA的基本逻辑,其中`adj[]`是一个邻接表数组,用于记录每个节点的相邻关系及其权重;`dist[]`保从起始节点到各节点的当短距离;`inQueue[]`标记某个节点是否已经在队列中以防止重复入队[^4]。 --- ### 算法优化策略 尽管SPFA在许多场景下表现出色,但在极端情况下其时间复杂度退化至O(VE),因此需要采取一些措施加以优化: 1. **SLF(Small Label First)** 在每次将新节点压入队列之,优先考虑将其插入队首而非队尾。具体来说,如果待插入节点的距离小于等于队头元素的距离,则应插于队首;反之则正常追加到队尾。这种方法能够显著提升某些特定测试用例下的性能。 2. **LLL(Large Label Last)** 当发现某次迭代后的小距离大于某一阈值时,可以跳过后续部分运算过程,因为这些较大的数值很可能不会影响终结果。不过需要注意的是,这种剪枝方式可能会破坏正确性,需谨慎使用。 3. **多端点检测机制** 若在多个候选终点,则可在程序结束终止搜索流程一旦确认任意目标可达即可返回相应答案而无需继续完成整个遍历工作流[^1]。 --- ### 复杂度分析 理论上讲,SPFA的时间复杂度介于O(E)和O(VE)之间,取决于输入数据的具体特性以及所选优化手段的效果如何。对于稀疏图而言,由于平均下来每个结点只会经历有限次数进出队列的动作,因而整体耗时往往接近线性级别;然而当面对稠密网络或者特殊构造的数据集时,就有可能触发差情形下的平方级增长趋势。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值