园龄：3年6个月粉丝：31 关注：34

SPFA 的优化

引

众所周知，SPFA作为一种暴力单源最短路算法，卡掉它并不是什么难事，毕竟，毕竟。

如果想卡 SPFA 见：「笔记」如何优雅地卡 Spfa - Luckyblock

但是我们可以优化……

~~但是优化也可以卡~~

SLF 优化

$Small \ Label \ First$ 优化（小标签优先）。用双端队列 $deque$ 实现，常用。

就是更新完之后比较其 $dis$ 值与 $dis[q.front()]$ 的大小，如果较小则放前面，反之放后面。

原理就是 $dis$ 值小的更容易更新其他节点的 $dis$ ，使队列后面的节点尽量不满足 $dis[v]>dis[u]+w$ ，这样就避免了一部分的重复入队。

复杂度 $\mathcal{O(\text{玄学})}$ 。

本来是不准备写代码的，但是有人要求那我就放上别人的代码吧(((((

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<deque>
#define MAXN 10010
#define MAXM 500010
#define MAX 2147483647
using namespace std;
int n,m,s,t,c=1;
int head[MAXN],path[MAXN];
bool vis[MAXN];
struct node{
    int next,to,w;
}a[MAXM<<1];
inline int read(){
    int date=0,w=1;char c=0;
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
    return date*w;
}
inline int relax(int u,int v,int w){
    if(path[v]>path[u]+w){
        path[v]=path[u]+w;
        return 1;
    }
    return 0;
}
inline void add(int u,int v,int w){
    a[c].to=v;a[c].w=w;a[c].next=head[u];head[u]=c++;
}
void spfa(){
    int u,v;
    deque<int> q;
    for(int i=1;i<=n;i++){path[i]=MAX;vis[i]=false;}
    path[s]=0;
    vis[s]=true;
    q.push_back(s);
    while(!q.empty()){
        u=q.front();
        q.pop_front();
        vis[u]=false;
        for(int i=head[u];i;i=a[i].next){
            v=a[i].to;
            if(relax(u,v,a[i].w)&&!vis[v]){
                vis[v]=true;
                if(!q.empty()&&path[v]<path[q.front()])q.push_front(v);
                else q.push_back(v);
            }
        }
    }
    for(int i=1;i<=n;i++)printf("%d ",path[i]);
    printf("\n");
}
int main(){
    int u,v,w;
    n=read();m=read();s=read();
    for(int i=1;i<=m;i++){
        u=read();v=read();w=read();
        add(u,v,w);
    }
    spfa();
    return 0;
}

LLL 优化

$Large\ Label\ Last$ 优化（大标签最后）。

设队首元素为 $temp$ ，每次松弛时进行判断，队列中所有 $dis$ 值的和为 $sum$ ，队列元素个数为 $num$ 。

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

和 SLF 优化原理差不多，因为比平均值小的 $dis$ 更容易更新别的 $dis$ 从而减少入队次数。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<list>
#define MAXN 10010
#define MAXM 500010
#define MAX 2147483647
using namespace std;
int n,m,s,t,c=1;
int head[MAXN],path[MAXN];
bool vis[MAXN];
struct node{
    int next,to,w;
}a[MAXM<<1];
inline int read(){
    int date=0,w=1;char c=0;
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
    return date*w;
}
inline int relax(int u,int v,int w){
    if(path[v]>path[u]+w){
        path[v]=path[u]+w;
        return 1;
    }
    return 0;
}
inline void add(int u,int v,int w){
    a[c].to=v;a[c].w=w;a[c].next=head[u];head[u]=c++;
}
void spfa(){
    int u,v,num=0;
    long long x=0;
    list<int> q;
    for(int i=1;i<=n;i++){path[i]=MAX;vis[i]=false;}
    path[s]=0;
    vis[s]=true;
    q.push_back(s);
    num++;
    while(!q.empty()){
        u=q.front();
        q.pop_front();
        num--;x-=path[u];
        while(num&&path[u]>x/num){
            q.push_back(u);
            u=q.front();
            q.pop_front();
        }
        vis[u]=false;
        for(int i=head[u];i;i=a[i].next){
            v=a[i].to;
            if(relax(u,v,a[i].w)&&!vis[v]){
                vis[v]=true;
                if(!q.empty()&&path[v]<path[q.front()])q.push_front(v);
                else q.push_back(v);
                num++;x+=path[v];
            }
        }
    }
    for(int i=1;i<=n;i++)printf("%d ",path[i]);
    printf("\n");
}
int main(){
    int u,v,w;
    n=read();m=read();s=read();
    for(int i=1;i<=m;i++){
        u=read();v=read();w=read();
        add(u,v,w);
    }
    spfa();
    return 0;
}

SLF + LLL 优化

因为这俩玩意互不影响，一个判出队，一个判入队，结合起来一样用。

DFS优化

这玩意可以判环，因为依靠队列判环至少需要一个点重复进队 $n$ 次，所以极易 GG。

DFS 优化可以凭借一个 $vis$ 数组将判环的复杂度降到到 $\mathcal{O(\text{E})}$

蛋是，要是没环，见 LB 如何卡 SPFA 。

复杂度指数级。


bool dfs_SPFA(int u){
    vis[u]=true;
    for(int i=head[u];i;i=e[i].nxt){
        int v=e[i].v;
        if(dis[v]<dis[u]+e[i].w){
            dis[v]=dis[u]+e[i].w;
            if(vis[v]) return true;
            else if(dfs_SPFA(v)) return true;
        }
    }
    vis[u]=false;
    return false;
}