spfa算法

一、概述：

（1）spfa实质上是用队列优化的bellman-ford算法，在bellman-ford中，我们每一轮的松弛操作都需要遍历所有的边，但是有些边是不需要遍历的，所以我们把需要更新的边的起点放入队列中，更新队列里面存在的就行了

（2）虽然bellman-ford也可以判断负环，但是一般用spfa

 

二、实现步骤：        

1.spfa求最短路（没有负环） 

（1）初始化dist数组（求最短路一定要初始化）

（2）把所有点都入队，入队的点都用一个bool数组标记为true，表示在队列中（需要更新）

（3）取出队首的点，将该点标记为false，遍历它的出边，更新其他点

（4）其他点被更新后，如果不在队列中，就入队，并标记为true

（5）重复上述步骤，直到队列为空

2.spfa判断是否存在负环（需要多设置一个cnt数组）

（1）初始化dist数组（虽然不初始化也可以）

（2）把所有点都入队，入队的点都用一个bool数组标记为true，表示在队列中（需要更新）

（3）取出队首的点，将该点标记为false，遍历它的出边，更新其他点

（4）更新cnt数组，如果某个点的cnt>=n，那么就i说明有负环

（5）其他点被更新后，如果不在队列中，就入队，并标记为true

（6）重复上述步骤，直到队列为空

三、代码示例：        

（1）求最短路

例题：        AcWing 851. spfa求最短路 - AcWing（已做笔记）

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=10010;
int n,m;
int dist[N];
int h[N],ne[N],e[N],w[N],idx;
bool st[N];

void add(int a,int b,int c){
    e[idx]=b;
    ne[idx]=h[a];
    w[idx]=c;
    h[a]=idx++;
}

void spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int> q;
    q.push(1);
    st[1]=true;
    while(!q.empty()){
        int t=q.front();
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){
                    st[j]=true;
                    q.push(j);
                }
            }
        }
        q.pop();
        st[t]=false;
    }
    if(dist[n]>0x3f3f3f3f/2) cout << "impossible";//这里不是判断dist[n]==0x3f3f3f3f是因为有负边权
    else cout << dist[n];
}

int main()
{
    memset(h,-1,sizeof h);
    cin >> n >> m;
    while(m--){
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
    }
    spfa();
    return 0;
}

 

（2）判断是否存在负环

例题：        AcWing 852. spfa判断负环 - AcWing（已做笔记）

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=10010;
int n,m;
int dist[N],cnt[N];
int h[N],ne[N],e[N],w[N],idx;
bool st[N];

void add(int a,int b,int c){
    e[idx]=b;
    ne[idx]=h[a];
    w[idx]=c;
    h[a]=idx++;
}

bool spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(1);
        st[i]=true;
    }
    
    while(!q.empty()){
        int t=q.front();
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n) return true;
                if(!st[j]){
                    st[j]=true;
                    q.push(j);
                }
            }
        }
        q.pop();
        st[t]=false;
    }
    return false;
}

int main()
{
    memset(h,-1,sizeof h);
    cin >> n >> m;
    while(m--){
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
    }
    if(spfa()) puts("Yes");
    else puts("No");
    return 0;
}