Spfa算法（可以求有负权的图）

$Spfa$

$spfa$ 通常用于求含负权边的单源最短路径，以及判负权环。$spfa$ 最坏情况下复杂度和朴素 $Bellman-Ford$ 相同，为$O(VE)$。

$spfa求最短路$

$spfa$是$Bellman\_ford$算法的优化。优化的是:$dist[b]=min(dist[b],dist[a]+w)$这一步。因为如果 $dist[b]$想要变小，那么 $dist[a]$一定要变小，用宽搜队列来优化，队列里存储的是每次都变小了的点。
1、每一次把起点放入队列
2.1 $while(Q.size())$只要队列不空
2.2 取出队头$t=Q.front()$，然后弹出队头$Q.pop()$，所有以t相邻的点的距离才有可能变小
2.3 更新 $t$ 的所有出边的距离，比如$t\to b$，如果更新成功，那么就把 $b$ 加入队列。如果队列里有 $b$ 那么就不用重复加入了。更新过谁，那么就拿它来更新别人

模板题：AcWing 851.spfa 求最短路

邻接表存图

int e[MAXN], ne[MAXN], h[MAXN], idx, w[MAXN];
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;//那第一个元素状态设置为true
    while(Q.size())//只要队列不空
    {
        int t = Q.front();
        Q.pop();
        st[t] = false;//这里要设置成false，因为一个点可能会被更新多次
        for(int i = h[t]; i != -1; i = ne[i])//邻接表那一套
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])//这里的i相当于idx
            {
                dist[j] = dist[t] + w[i];
                if(!st[j])//如果这个点没有在队列中就把它放进队列
                {
                    Q.push(j);
                    st[j] = true;//状态设置为true
                }
            }
        }
    }

    if(dist[n] == 0x3f3f3f3f)
        printf("impossible");
    else
        printf("%d", dist[n]);
}

$spfa判断是否存在负环$

模板题链接：AcWing 852.判断负环

$spfa$ 判断是否存在负环是在求最短路（因为存在负环就没有最短路，会一直求下去）的过程中，维护一个 $cnt$ 数组， $cnt[j]$ 表示从 $1-j$ 这个最短路的路径中的边数，如果边数大于等于 $n$ 说明至少有 $n+1$ 个点，说明存在负环。如果有正环则不会加进队列。注意最开始要把所有的点都加入队列，因为可能存在孤立的环

核心代码如下：

int dis[MAXN], flag[MAXN],cnt[MAXN];

bool spfa()
{
    queue<int> Q;
    for(int i=1;i<=n;++i)
    {
        flag[i]=true;
        Q.push(i);
    }
    while(Q.size())
    {
        int t = Q.front();
        Q.pop();
        flag[t]=false;
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dis[j] > dis[t] + w[i])
            {
                dis[j] = dis[t] + w[i];
                if(!flag[j])
                {
                    Q.push(j);
                    flag[j]=true;
                }
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n)
                    return true;
            }
        }
    }

    return false;
}