SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）

SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）

若读者还不太了解SPFA算法，指路一篇博客：https://blog.csdn.net/hzf0701/article/details/107691013
关于SPFA算法，它已经死了，很多出题人都会故意卡SPFA算法，所以我们若进行优化，说不定就能过呢。但u1s1，对于正权图来说，还是老老实实用Dijkstra算法吧，贼香！

进入正题：我们以vector模拟邻接表存储为例。（哪种都一样，只是存储方式不同而已，主要是算法中心思想）

先介绍基本结构信息：

const int maxn=105;//顶点最大数
const int M=1e4;//边最大数
const int inf=0x3f3f3f3f;
int S,E;//起点与终点。
int n,m;//顶点数与边数。
int cnt[maxn];//cnt[i]记录的是i顶点的入队次数。若大于n，则必然存在负环。
typedef struct Edge{
	int to;//边的终端节点
	int w;//边权值。
	Edge(int to,int w):to(to),w(w){}//构造函数
}Edge;
vector<Edge> graph[maxn];//用vector模拟邻接表
int dis[maxn];//存储所有顶点到源点的距离。
bool visited[maxn];//判断是否在队列中。
void init(){
    //初始化函数。
	memset(cnt,0,sizeof(cnt));
	memset(dis,inf,sizeof(dis));
	memset(visited,false,sizeof(visited));
}

基础SPFA算法

int spfa(int S){
	queue<int> q;
	dis[S]=0;
	int temp;
	q.push(S);
	cnt[S]++;
	visited[S]=true; //入队即true。
	int flag=0;         //标志，若为真，则表示存在负环。
	while(!q.empty()){
		temp=q.front();
		q.pop();
		visited[temp]=false; //出队则false。
		int v,w;
		int t=graph[temp].size();//避免多次调用此函数。
        //松弛操作
        for(int i=0;i<t;i++){
			v=graph[temp][i].to;
			w=graph[temp][i].w;
			if(dis[v]>dis[temp]+w){
				dis[v]=dis[temp]+w;//更新最短路径
				if(!visited[v]){
					//判断是否在队列中
					q.push(v);
					cnt[v]++;
					if(cnt[v]>n){flag=1;return flag;}
					visited[v]=true;
				}
			}
        }
	}
	return flag;
}

SLF优化

SLF优化，即Small Label First策略，使用STL中的双端队列deque容器来实现，较为常用。

这个顾名思义就是在原有的SPFA算法中每次出队进行判断扩展出的点与队头元素进行判断，若小于进队头，否则入队尾。即：对要加入队列的点 u，如果 dist[u] 小于队头元素 v 的 dist[v]，将其插入到队头，否则插入到队尾。

注：队列为空时直接插入队尾。

int spfa_slf(int S){
	deque<int> q;
	dis[S]=0;
	int temp;
	q.push_back(S);
	cnt[S]++;
	visited[S]=true; //入队即true。
	int flag=0;         //标志，若为真，则表示存在负环。
	while(!q.empty()){
		temp=q.front();
		q.pop_front();
		visited[temp]=false; //出队则false。
		int v,w;
		int t=graph[temp].size();//避免多次调用此函数。
        //松弛操作
        for(int i=0;i<t;i++){
			v=graph[temp][i].to;
			w=graph[temp][i].w;
			if(dis[v]>dis[temp]+w){
				dis[v]=dis[temp]+w;//更新最短路径
				if(!visited[v]){
					//判断是否在队列中
					if(!q.empty()&&dis[v]>dis[q.front()]){
						//和队头元素进行比较。
						q.push_back(v);
					}
					else q.push_front(v);
					cnt[v]++;
					if(cnt[v]>n){flag=1;return flag;}
					visited[v]=true;
				}
			}
        }
	}
	return flag;
}

LLL优化

LLL优化即：Large Label Last策略。顾名思义就是大的放后面，这个不是针对要入队的元素，而是针对要出队的元素，我们是这样子来处理的：设队首元素为 temp ，每次松弛时进行判断，队列中所有 dis 值的和为sum，队列元素为num 。

若 dist[ temp] *num>sum ，则将 temp 取出插入到队尾，查找下一元素，直到找到某一个 temp 使得 dis[ temp ]*sum <= x ，则将 temp出队进行松弛操作。

int spfa_lll(int S){
	queue<int> q;
	int sum,num;//队列中dis总和和顶点数
	dis[S]=0;
	int temp;
	q.push(S);
	sum=S,num=1;
	cnt[S]++;
	visited[S]=true; //入队即true。
	int flag=0;         //标志，若为真，则表示存在负环。
	while(!q.empty()){
		temp=q.front();
		while(dis[temp]*num>sum){
			//LLL优化关键在这。
			q.pop();
			q.push(temp);
			temp=q.front();
		}
		q.pop();
		//更新队列中dis总和和顶点数目。
		num--;
		sum-=dis[temp];
		visited[temp]=false; //出队则false。
		int v,w;
		int t=graph[temp].size();//避免多次调用此函数。
        //松弛操作
        for(int i=0;i<t;i++){
			v=graph[temp][i].to;
			w=graph[temp][i].w;
			if(dis[v]>dis[temp]+w){
				dis[v]=dis[temp]+w;//更新最短路径
				if(!visited[v]){
					//判断是否在队列中
					q.push(v);
					//更新队列中dis总和和顶点数目。
					sum+=dis[v];
					num++;
					cnt[v]++;
					if(cnt[v]>n){flag=1;return flag;}
					visited[v]=true;
				}
			}
        }
	}
	return flag;
}

SLF+LLL优化

我们根据前面得知SLF是对入队顶点进行判断，LLL是对出队顶点判断的，两者互不影响，那么不就可以结合了吗？

int spfa_slf_lll(int S){
	deque<int> q;
	dis[S]=0;
	int temp;
	q.push_back(S);
	int sum=dis[S];int num=1;
	cnt[S]++;
	visited[S]=true; //入队即true。
	int flag=0;         //标志，若为真，则表示存在负环。
	while(!q.empty()){
		temp=q.front();
		while(dis[temp]*num>sum){
			//lll优化
			q.pop_front();
			q.push_back(temp);
			temp=q.front();
		}
		q.pop_front();
		sum-=dis[temp];
		num--;
		visited[temp]=false; //出队则false。
		int v,w;
		int t=graph[temp].size();//避免多次调用此函数。
        //松弛操作
        for(int i=0;i<t;i++){
			v=graph[temp][i].to;
			w=graph[temp][i].w;
			if(dis[v]>dis[temp]+w){
				dis[v]=dis[temp]+w;//更新最短路径
				if(!visited[v]){
					//判断是否在队列中
					if(!q.empty()&&dis[v]>dis[q.front()]){
						//和队头元素进行比较。
						q.push_back(v);//大于入队尾
					}
					else q.push_front(v); //小于入队头
					sum+=dis[v];
					num++;
					cnt[v]++;
					if(cnt[v]>n){flag=1;return flag;}
					visited[v]=true;
				}
			}
        }
	}
	return flag;
}

DFS优化

我们知道SPFA算法是利用BFS的思想的，由于采用广度优先的思想，每当我们扩展出一个新的节点，总是把它放到队列的末尾，其缺点是中断了迭代的连续性。而实际上如果采用深度优先的思想，我们可以直接从这个新节点继续往下扩展，则我们就可以不断递归进行求解。我们用DFS的思想来代替BFS，这就是DFS优化。可这样优化真的好吗？这种优化常常用于判断正/负环，时间复杂度可以达到O(m)（m是边）。思路是，我们每一次dfs的时候如果走回之前dfs过的点，那就是有环，除了这个dfs的标记，我们还可以打另一个vis数组记录更新过权值的节点，以后就不必重复更新，大大降低复杂度。如果只是要求最短路径，还是使用前三种优化吧。用DFS优化我们要使用一个访问数组来判断一个点是否再次走过，不同于上面的visited。

我们先要进行初始化，注意：绝对不能放在spfa_dfs函数中。

bool visited[maxn];//判断是否访问过。
dis[S]=0;
memset(visited,false,sizeof(visited));
int flag=0;//标志位，判断是否存在负环。

---

void spfa_dfs(int temp){
	int v,w;
	int t=graph[temp].size();
	for(int i=0;i<t;i++){
		v=graph[temp][i].to;
		w=graph[temp][i].w;
		if(dis[v]>dis[temp]+w){
			if(visited[v]){
				//判断是否在一条路径上出现了多次。
				flag=true;
				return;
			}
			else{
				dis[v]=dis[temp]+w;
				visited[v]=true;
				spfa_dfs(v);//顺着这条路继续扩展。
			}
		}
	}
}

以上为博主自己整理，自己测试都没有问题的。若有任何疑问都可以私信我或者在评论区留言，我都会给予回复，愿能帮助到你。