SPFA的两种优化方法——SLF和LLL

原创 已于 2024-09-10 17:01:12 修改 · 4.4k 阅读 · 37 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络流

于 2019-05-25 17:18:24 首次发布
本文介绍了SPFA算法的两种优化方法——SLF(Small Label First)和LLL(Large Label Last)，并详细解释了它们的优化思路。SLF通过双端队列根据距离值决定插入位置，而LLL则在出队时调整节点位置，确保队头元素的距离不大于队列中点的平均距离。两者可以结合使用，并通过实际题目案例展示了优化后的效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Content:

一、SLF(Small Label First) 优化

优化思路：将原队列改成双端队列，对要加入队列的点 p，如果 dist[p] 小于队头元素 u 的 dist[u]，将其插入到队头，否则插入到队尾。

//SLF优化
void spfa_slf(int s,int t,GH *G)//起点s，终点t，图G
{
	//节点编号从0开始
	int n=G->vexnum;//节点个数
	int *dist=new int[n];//距离数组
	bool *visit=new bool[n];//访问标记数组
	int *pre=new int[n];;//前驱
	AR *p;

	//初始化
	memset(dist,0x3f,n*sizeof(int));
	memset(visit,0,n*sizeof(bool));
	memset(pre,-1,n*sizeof(int));
	deque<int>Q;//建立双端队列，并将起点入队
	visit[s]=1;
	dist[s]=0;
	Q.push_back(s);
	//进行操作
	while (!Q.empty())
	{
		int cur=Q.front();
		Q.pop_front();
		visit[cur]=0;//出队节点取消标记
		p=G->N[cur].next;
		while (p)//遍历出队节点的直接后继
		{
			if (dist[p->index] > dist[cur] + (p->weight))//需要进行松弛操作
			{
				dist[p->index]=dist[cur] + (p->weight);
				pre[p->index]=cur;
				if (!visit[p->index])
				{
					visit[p->index]=1;
					if(!Q.empty() && dist[p->index] < dist[Q.front()])//根据dist[p->index]与dist[Q.front()]的大小关系，决定p->index插入到队头还是队尾
						Q.push_front(p->index);
					else
						Q.push_back(p->index);
				}
			}
			p=p->next;
		}
	}

	if (dist[t] == INF)
		cout<<"两点不连通."<<endl;
	else//输出最短路径
	{
		cout<<"存在长度为"<<dist[t]<<"的最短路径:"<<endl;
		int *path=new int[n];//存放路径
		int top=-1;
		int q=t;
		while (q != -1)//将前驱入栈
		{
			top++;
			path[top]=q;
			q=pre[q];
		}
		for (; top > 0; top--)
			cout<<G->vexname[path[top]]<<"-->";
		cout<<G->vexname[path[0]]<<endl;
		delete []path;
	}

	delete []dist;
	delete []visit;
	delete []pre;
}

二、LLL(Large Label Last) 优化

优化思路：对每个要出队的队头元素 u，比较 dist[u] 和队列中点的 dist 的平均值，如果 dist[u] 更大，将其弹出放到队尾，然后取队首元素进行相同操作，直到队头元素的 dist 小于等于平均值。

//LLL优化
void spfa_lll(int s,int t,GH *G)//起点s，终点t，图G
{
	//节点编号从0开始
	int n=G->vexnum;//节点个数
	int *dist=new int[n];//距离数组
	bool *visit=new bool[n];//访问标记数组
	int *pre=new int[n];//前驱数组
	int num;//队列中点的个数
	int sum;//队列中点的dist之和
	AR *p;

	//初始化
	memset(dist,0x3f,n*sizeof(int));
	memset(visit,0,n*sizeof(bool));
	memset(pre,-1,n*sizeof(int));
	queue<int>Q;//建立队列，并将起点入队
	visit[s]=1;
	dist[s]=0;
	Q.push(s);
	num=1;
	sum=dist[s];
	while (!Q.empty())
	{
		int cur = Q.front();
		//LLL优化
		while (num*dist[cur] > sum)//表示队首元素的dist高于平均值，将其放到队尾
		{
			Q.pop();
			Q.push(cur);
			cur = Q.front();
		}
		Q.pop();
		visit[cur] = 0;//出队，并取消标记
		num--;
		sum -= dist[cur];
		p=G->N[cur].next;
		while (p)
		{
			if (dist[p->index] > dist[cur] + (p->weight))//需要进行松弛操作
			{
				dist[p->index]=dist[cur] + (p->weight);
				pre[p->index]=cur;
				if (!visit[p->index])
				{
					visit[p->index]=1;
					Q.push(p->index);//直接入队
					num++;//更新相关参数
					sum+=dist[p->index];
				}
			}
			p=p->next;
		}
	}

	if (dist[t] == INF)
		cout<<"两点不连通."<<endl;
	else//输出最短路径
	{
		cout<<"存在长度为"<<dist[t]<<"的最短路径:"<<endl;
		int *path=new int[n];//存放路径
		int top=-1;
		int q=t;
		while (q != -1)//将前驱入栈
		{
			top++;
			path[top]=q;
			q=pre[q];
		}
		for (; top > 0; top--)
			cout<<G->vexname[path[top]]<<"-->";
		cout<<G->vexname[path[0]]<<endl;
		delete []path;
	}

	delete []dist;
	delete []visit;
	delete []pre;
}

三、SLF+LLL

这两种优化方法并不相互干扰，故可同时使用，下附代码。

//SLF+LLL优化
void spfa_slf_lll(int s, int t, GH *G)//起点s，终点t，图G
{
	//节点编号从0开始
	int n=G->vexnum;//节点个数
	int *dist=new int[n];//距离数组
	bool *visit=new bool[n];//访问标记数组
	int *pre=new int[n];//前驱数组
	int num;//队列中点的个数
	int sum;//队列中点的dist之和
	AR *p;

	//初始化
	memset(dist,0x3f,n*sizeof(int));
	memset(visit,0,n*sizeof(bool));
	memset(pre,-1,n*sizeof(int));
	deque<int>Q;//建立双端队列，并将起点入队
	visit[s]=1;
	dist[s]=0;
	Q.push_back(s);
	num=1;
	sum=dist[s];
	while (!Q.empty())
	{
		int cur=Q.front();
		//LLL优化
		while (num*dist[cur] > sum)//表示队首元素的dist高于平均值，将其放到队尾
		{
			Q.pop_front();
			Q.push_back(cur);
			cur=Q.front();
		}
		Q.pop_front();
		visit[cur]=0;//出队，并取消标记
		num--;
		sum-=dist[cur];
		//SLF优化
		p=G->N[cur].next;//遍历出队节点的直接后继
		while (p)
		{
			if (dist[p->index] > dist[cur] + (p->weight))//需要进行松弛操作
			{
				dist[p->index]=dist[cur] + (p->weight);
				pre[p->index]=cur;
				if (!visit[p->index])
				{
					visit[p->index]=1;
					if(!Q.empty() && dist[p->index]<dist[Q.front()])//根据dist[p->index]与dist[Q.front()]的大小关系，决定p->index插入到队头还是队尾
						Q.push_front(p->index);
					else
						Q.push_back(p->index);
					num++;//更新相关参数
					sum+=dist[p->index];
				}
			}
			p=p->next;
		}
	}

	if (dist[t] == INF)
		cout<<"两点不连通."<<endl;
	else//输出最短路径
	{
		cout<<"存在长度为"<<dist[t]<<"的最短路径:"<<endl;
		int *path=new int[n];//存放路径
		int top=-1;
		int q=t;
		while (q != -1)//将前驱入栈
		{
			top++;
			path[top]=q;
			q=pre[q];
		}
		for (; top > 0; top--)
			cout<<G->vexname[path[top]]<<"-->";
		cout<<G->vexname[path[0]]<<endl;
		delete []path;
	}

	delete []dist;
	delete []visit;
	delete []pre;
}

四、优化效果

以洛谷上的题目 P3381【模板】最小费用最大流 为例比较优化结果。

1.没有进行优化的结果

2.SLF优化的结果

3.LLL优化的结果

4.SLF+LLL优化的结果

五、其余代码

#include<cstdio>
#include<iostream>
#include<fstream>
#include<cstring>
#include<queue>
using namespace std;
#define maxN 1000
#define INF 0x3f3f3f3f
#pragma warning(disable:4996)

typedef struct arc//弧
{	
	int index;//指向节点编号
	int weight;//边的权值
	struct arc *next;
}AR;

typedef struct MyGraph//图(包含邻接矩阵和邻接表)
{
	int type;//0表示无向图，1表示有向图
	int arcnum,vexnum;//边的个数、顶点个数
	char **vexname;//存放顶点名称的二维数组	
	AR *N;//表头数组
	int **A;//邻接矩阵
}GH;

int findvex(char *s,GH *G);//找到图G中名称为s的节点编号，并将其返回
void createGraph(GH *G);//创建图G
void showGraph(GH *G);//以邻接表的形式显示图G
void spfa(int s,int t,GH *G);//起点s，终点t，图G
void spfa_slf(int s,int t,GH *G);//起点s，终点t，图G
void spfa_lll(int s,int t,GH *G);//起点s，终点t，图G
void spfa_slf_lll(int s, int t, GH *G);//起点s，终点t，图G

int main(void)
{
	int s,t;
	GH *G;
	G=new GH;
	createGraph(G);
	cout<<"图的邻接表形式:"<<endl;
	showGraph(G);
	cout<<"请输入起点和终点编号(空格间隔):";
	cin>>s>>t;

	cout<<"\n===========================无优化的SPFA=========================="<<endl;
	spfa(s,t,G);
	cout<<"\n===========================SLF优化的SPFA========================="<<endl;
	spfa_slf(s,t,G);
	cout<<"\n===========================LLL优化的SPFA========================="<<endl;
	spfa_lll(s,t,G);
	cout<<"\n=========================SLF+LLL优化的SPFA======================="<<endl;
	spfa_slf_lll(s,t,G);
	
	delete G;
	return 0;
}


int findvex(char *s,GH *G)//找到图G中名称为s的节点编号，并将其返回
{
	for(int i=0;i<G->vexnum;i++)
	{
		if(strcmp(s,G->vexname[i])==0)//找到匹配节点
			return i;
	}
	cout<<"该点不存在."<<endl;
	exit(-1);
}

void createGraph(GH *G)//创建图G
{
	int i,j,n,edge;
	char filename[]="graph.txt";//存放图的数据文件
	char str[10],str1[10];
	fstream file;
	AR *p;

	file.open(filename,ios::in);
	if(!file)
	{
		cout<<"打开文件失败!"<<endl;
		exit(-1);
	}

	file>>(G->type)>>n;//读取图的类型和节点数量
	G->arcnum=0;
	G->vexnum=n;

	//为动态数组分配空间
	G->vexname=new char*[n];
	G->N=new AR[n];
	G->A=new int*[n];

	//对头结点数组和邻接矩阵初始化
	for (i = 0; i < n; i++)
	{
		G->N[i].next = NULL;
		G->A[i] = new int[n];
		for (j = 0; j < n; j++)
			G->A[i][j]=INF;
	}

	//读取顶点名称
	for(i=0;i<n;i++)
	{
		file>>str;
		G->vexname[i]=new char[strlen(str)];
		strcpy(G->vexname[i],str);
	}

	//读取边
	while(!file.eof())
	{
		file>>str>>str1>>edge;
		i=findvex(str,G);
		j=findvex(str1,G);
		//邻接表
		p=new AR;
		p->index=j;
		p->weight=edge;
		p->next=G->N[i].next;
		G->N[i].next=p;
		//邻接矩阵
		G->A[i][j]=edge;
		G->arcnum++;//边的个数增加
		if(G->type==0)//如果是无向图
		{
			//邻接表
			p=new AR;
			p->index=i;
			p->weight=edge;
			p->next=G->N[j].next;
			G->N[j].next=p;
			//邻接矩阵
			G->A[j][i]=edge;
		}
	}
	file.close();//关闭文件
}

void showGraph(GH *G)//以邻接表的形式显示图G
{	
	AR *p;//用于遍历
	for (int i = 0; i < G->vexnum; i++)
	{
		cout<<G->vexname[i];
		p=G->N[i].next;
		while (p)
		{
			if (G->type == 1)
				cout<<"-->";
			else//无向图没有箭头
				cout<<"--";
			cout<<G->vexname[p->index]<<"("<<(p->weight)<<")";
			p=p->next;
		}
		cout<<endl;
	}
	cout<<endl;
}

//无优化
void spfa(int s,int t,GH *G)//起点s，终点t，图G
{
	//节点编号从0开始
	int n=G->vexnum;//节点个数
	int *dist=new int[n];//距离数组
	bool *visit=new bool[n];//访问标记数组
	int *pre=new int[n];;//前驱
	AR *p;

	//初始化
	memset(dist,0x3f,n*sizeof(int));
	memset(visit,0,n*sizeof(bool));
	memset(pre,-1,n*sizeof(int));
	queue<int>Q;//建立队列，并将起点入队
	visit[s]=1;
	dist[s]=0;
	Q.push(s);
	//进行操作
	while (!Q.empty())
	{
		int cur=Q.front();
		Q.pop();
		visit[cur]=0;//出队节点取消标记
		p=G->N[cur].next;
		while (p)//遍历出队节点的直接后继
		{
			if (dist[p->index] > dist[cur] + (p->weight))//需要进行松弛操作
			{
				dist[p->index]=dist[cur] + (p->weight);
				pre[p->index]=cur;//更新前驱
				if (!visit[p->index])
				{
					visit[p->index]=1;
					Q.push(p->index);
				}
			}
			p=p->next;
		}
	}

	if (dist[t] == INF)
		cout<<"两点不连通."<<endl;
	else//输出最短路径
	{
		cout<<"存在长度为"<<dist[t]<<"的最短路径:"<<endl;
		int *path=new int[n];//存放路径
		int top=-1;
		int q=t;
		while (q != -1)//将前驱入栈
		{
			top++;
			path[top]=q;
			q=pre[q];
		}
		for (; top > 0; top--)
			cout<<G->vexname[path[top]]<<"-->";
		cout<<G->vexname[path[0]]<<endl;
		delete []path;
	}

	delete []dist;
	delete []visit;
	delete []pre;
}
SPFA的两个优化
扩展の灰(Extended Ash/Cooevjnz)
09-08 2306
最近看到知乎上面有人讨论怎么卡spfa并给出了这道题作为实战地点 于是我就搞了两个优化把出台人精心构造的数据过了 优化1： 这个优化不是我想出来的，如果没错应该是Menci的做法 本来这个优化已经可以过掉原来的五个数据的，让后fstqwq（出题人）搞了一个新数据把这个优化卡T了 其实就是每次入队，如果队头比队尾大那么就交换（感觉很像SLF但是比SLF强） 让后为了Ac我就加了第二...
【智能算法】SPFA算法
大雨的博客
09-29 1761
SPFA算法，全称Shortest Path Faster Algorithm，是Bellman-Ford算法的一种队列优化形式，由西南交通大学段凡丁于1994年提出（尽管其证明存在错误，且队列优化的概念在Bellman-Ford算法提出后不久即已存在）。SPFA算法主要用于求解含有负权边的单源最短路径问题，并具备判断负权环的能力。
SPFA的两种优化
C Y
10-05 390
转自：https://blog.youkuaiyun.com/oranges_c/article/details/64124235 这个博客写的比较清楚 SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j) &lt; dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，...
spfa算法
最新发布
zshsrn123456的博客
07-15 266
SPFA（Shortest Path Faster Algorithm）是一种用来解决单源最短路径问题的算法，它是Bellman-Ford算法的优化版本。SPFA算法通过限制队列中的节点被加入的次数，避免了Bellman-Ford算法在某些情况下可能出现的所有边都被多次松弛的问题，从而提高了算法的效率。
SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）
pursuit的博客
07-30 7433
SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）
SPFA的优化
weixin_30437481的博客
06-14 235
【为什么要优化】 关于SPFA，他死了（懂的都懂） 进入正题。。。 一般来说，我们有三种优化方法。 SLF优化： SLF优化，即 Small Label First 策略，使用 双端队列 进行优化。 一般可以优化15%~20%，在竞赛中比较常用。 设从 u 扩展出了 v ，队列中队首元素为 k ，若 dis[ v ] < dis[ k ] ，则将 v 插入队...
SPFA以及其优化
LzyRapX
03-16 5507
SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。 SPFA，要从Bellman-ford的优化说起。在n个点m条边的图中，Bellman-ford的复杂度是n*m，依次对每条边进行松弛操作，重复这个操作n-1次后则一定得到最短路，如果还能继续松弛，则有负环。这是因为最长的没有环路的路，也只不
SPFA之FFF优化
01-01
为了进一步提升SPFA的表现效果，引入了三种常见的优化手段： ##### SLF(Small Label First) 当新节点进入队首前判断其估计值是否小于等于队尾元素对应的估计值，若是则将其插入至队头位置，反之正常追加到队尾。此...
spfa算法的优化
03-08
### SPFA算法优化方法 SPFA算法（Shortest Path Faster Algorithm）用于解决单源最短路径问题，尤其适合处理带负权边的图。该算法基于队列实现，利用动态逼近法对图进行松弛操作，不断更新节点的最短路径估计值直到...
最短路径算法总结（floyd及其优化，dijkstra，SPFA及其优化，A*）
sinat_28853941的博客
12-11 2750
在网上看大家写的算法详解非常详细、篇幅很长，但是讲来讲去有点绕。 这里对几个经典的算法用尽可能少的几句话概括一下,写代码的时候不容易绕晕。 floyd算法及优化 时间复杂度是O(n**3)，代码超级简洁（但运行起来也超慢），会得到所有点两两之间最小距离，python示例代码如下： for k in range(n): for i in range(n): for ...
SPFA 算法和Bellman-Ford 算法与Dijkstra 算法、Floyd 算法有什么异同以及创新性改进或应用
06-03
SPFA算法和Bellman-Ford算法与Dijkstra算法、Floyd算法有以下异同和创新性改进或应用： 异同点： 1. Dijkstra算法、Floyd算法和...4. SPFA算法的改进：SLF算法和LLL算法，对队列的优化方式不同，使得算法更加高效。
spfa算法的一些优化
dance in th dark的博客
11-14 2471
SLF优化：对于一个要加入到队列中的点j，假如有dist[j]< dist[i] (i表示队首元素)，那么则把当前元素插入到队首，否则插入到队尾。 SLF 可使速度提高 15 ~ 20%LLL优化：我们将当前队列中的所有元素的dist取个平均数x，假如当前取出的队首元素i的dist[i]>x，那么将i插入到队尾，继续查找下一元素，直到找到dist[i]<=x。SLF + LLL 可提高约 50%个人
SPFA及SLF优化
weixin_30781107的博客
08-12 184
算法简介SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。 算法流程SPFA对Bellman-Ford算法优化的关键之处在于意识到：只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。因此，...
spfa优化 SLF LLL
弱弱的jxy
12-05 4476
SPFA 是按照 FIFO 的原则更新距离的, 没有考虑到距离标号的作用. 实现中 SPFA 有两个非常著名的优化: SLF 和 LLL. 　　SLF: Small Label First 策略. 　　实现方法是, 设队首元素为 , 队列中要加入节点 , 在 时加到队首而不是队尾, 否则和普通的 SPFA 一样加到队尾. 这可以用个优先级队列维护 　　LLL: La
spfa 的优化
now_ing的博客
08-27 610
SPFA 与堆优化的 Dijkstra 的速度之争不是一天两天了，不过从这次 USACO 月赛题来看，SPFA 用在分层图上会比较慢。标程是堆优化的 Dijkstra，我写了一个非常朴素的 SPFA，只能过 6/11 个点。SPFA 是按照 FIFO 的原则更新距离的，没有考虑到距离标号的作用。实现中 SPFA 有两个非常著名的优化：SLF 和 LLL。　　SLF：Small Label First
关于SPFA的优化
weixin_30892037的博客
09-07 112
SPFA两个著名优化（SLF和LLL）：SPFA 是按照 FIFO 的原则更新距离的, 没有考虑到距离标号的作用。实现中 SPFA 有两个非常著名的优化: SLF 和 LLL。SLF: Small Label First 策略. （比较常用）实现方法：设队首元素为, 队列中要加入节点, 在时加到队首而不是队尾, 否则和普通的 SPFA 一样加到队尾.LLL: Large Label ...
spfa SLF优化
wzw-yali的博客
09-25 466
#include #include #include #include #include #include #include using namespace std; typedef long long LL; #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i) #define
【最短路径】 SPFA算法优化
weixin_30783913的博客
02-16 255
　　首先先明确一个问题，SPFA是什么？（不会看什么看，一边学去，传送门），SPFA是bellman-ford的队列优化版本，只有在国内才流行SPFA这个名字，大多数人就只知道SPFA就是一个顶尖的高效算法，却不知道还能继续优化，这个优化虽然也没有你想的那么麻烦，只不过多了几个判断语句罢了，5分钟就能学会，但是这也得运用到分类讨论，其实SPFA有三种优化方法，效果并不是很明显。 ...
slf优化spfa
03-09
### SPFA算法中的SLF优化 SPFA（Shortest Path Faster Algorithm）是在Bellman-Ford基础上改进而来的一种高效最短路径算法[^1]。为了进一步提升性能，可以采用多种优化方法，其中一种常见的优化方式就是SLF (Small Label First)策略。 #### SLF优化原理 在标准的SPFA实现中，节点按照进入队列的时间顺序被处理。然而，在某些情况下这种简单的先进先出(FIFO)机制并不是最优的选择。SLF优化的核心思想在于优先处理距离较小的顶点，从而减少不必要的入队操作并加速收敛过程。具体来说： - 当新加入队列的一个结点`u`时，如果该结点当前估计的距离小于队首元素，则将其插入到队头位置；否则正常地追加至队尾。 这种方法使得更有可能成为最终解的部分尽早得到扩展，进而提高了整体搜索效率。 #### 实现细节 下面给出一段Python代码来展示带有SLF优化特性的SPFA算法的具体实现: ```python from collections import deque, defaultdict def spfa_slf(graph, start_node): n = len(graph) dist = [float('inf')] * n in_queue = [False] * n queue = deque() dist[start_node] = 0 queue.append(start_node) while queue: u = queue.popleft() in_queue[u] = False for v, weight in graph[u]: if dist[v] > dist[u] + weight: dist[v] = dist[u] + weight if not in_queue[v]: in_queue[v] = True # Apply SLF optimization here if not queue or dist[v] < dist[queue[0]]: queue.appendleft(v) else: queue.append(v) return dist ``` 此版本不仅实现了基本的SPFA逻辑，还加入了对于每个即将入队的新节点执行一次简单判断——依据其最新计算出来的临时最短路径长度决定是否应该调整它在整个等待序列里的相对位序。这样的改动虽然看似微不足道，但在实际应用环境中却往往能带来意想不到的效果改善[^2]。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值