图的单源最短路算法：SPFA

SPFA算法

SPFA算法是在Bellman-Ford算法的基础上优化而来。在对边松弛的过程中，只考虑那些之前更新过的点。因此可以使用队列来记录之前更新过最短路径的点。

时间复杂度

SPFA一般情况复杂度是$O(m)$，最坏情况下复杂度和朴素 Bellman-Ford 相同，为$O(n\times m)$。

算法应用

1. 求没有负权环的单源最短路径
2. 判断是否有负权环

练习1：spfa求最短路

#include 

using namespace std;
const int N = 100010, MAXN = 0x3f3f3f3f;

int n, m;

int h[N], e[N], ne[N], w[N], idx;

//dis[i]表示起点到i点的最短距离
//st[i]表示点i是否在队列中
int dis[N], st[N];

//m、n范围相同，稀疏图，使用邻接表存储图
void add(int a, int b, int d){
    e[idx] = b;
    w[idx] = d;
    ne[idx] = h[a];
    h[a] = idx ++;
}

void spfa(){
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0; //初始化起点
    queue<int> q; //使用队列记录哪些点在松弛操作中更新了
    q.push(1), st[1] = 1; //起点入队

    while(q.size()){
        int u = q.front(); q.pop(); //出队一个待扩展的点
        st[u] =  0; //出队即将该点标记为不在队列中
        
        for(int i = h[u]; i != -1; i = ne[i]){
            int v = e[i];
            //注意，先判断是否可以松弛，在考虑是否已经在队列中了
            if(dis[v] > dis[u] + w[i]){
                //更新起点到v点的最短距离
                dis[v] = dis[u] + w[i];
                //如果v点已经在队列中了，就不要重复加入队列了
                if(!st[v]){
                    q.push(v); st[v] = 1;
                }
            }
        }
    }
}

int main(){
    
    //将表头初始化为-1，表示链表为空
    memset(h, -1, sizeof h);
    
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++){
        int a,b,d;
        scanf("%d%d%d", &a, &b, &d);
        add(a, b, d);
    }
    spfa();
    if(dis[n] < INF / 2) cout << dis[n] << endl;
    else puts("impossible");
    return 0;
}

练习2：spfa判断负环

#include 
#include 

using namespace std;

const int N = 100010;
int n, m;
int h[N], e[N], w[N], ne[N], idx;
int dist[N], q[N], st[N], cnt[N]; 
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

bool spfa()
{
    int hh = 0, tt = 0;
    for(int i = 1; i <= n; i ++)
    {
        q[tt ++] = i;
        st[i] = 1;
    }
    
    while(hh != tt)
    {
        int u = q[hh ++];
        if(hh == N) hh = 0;
        st[u] = 0;

        for(int i = h[u]; ~i; i = ne[i])
        {
            int v = e[i];

            if(dist[v] > dist[u] + w[i])
            {
                dist[v] = dist[u] + w[i];
                cnt[v] = cnt[u] + 1;
                if(cnt[v] >= n) return true;
                if(!st[v])
                {
                    q[tt ++] = v, st[v] = 1;
                    if(tt == N) tt = 0;
                }
            }
        }
    }
    
    return false;
}

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