spfa算法

题目：

bellman_ford算法是在每次遍历所有的边，然后更新有效边，spfa可以对其进行优化，只需要枚举该点所连的边即可，而不需要去枚举所有的边，用一个队列来记录目前所枚举到的点。

与dijkstra不同的是：dijkstra用堆来存储，每次取出的是最小值，，st数组用于标记某个点是否被确定到源点的最短距离，而且一旦确定某个点的最小值后就是不可逆的。而spfa算法在每次入队后先打上标记表示该点在队列中，当去遍历它的邻点的时候，判断其邻点是否可被更新，如果能被更新看看该点是否在队列里，如果不在队列里，就入队。这样队列里不会存放多个相同的点，又能保证在某个点出队后，又能再次入队，能退回去寻找最优的解，解决负权边的问题。而dij会对能更新的所有点都入队，对已经确定的点进行预判，被确定过就跳出本次循环。

时间复杂度： 一般O(m), 最坏O(nm)

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 1e5 + 10;
int h[N], e[N], ne[N], w[N], idx;
int d[N];
bool st[N];
int n, m;


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

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

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);
    }
    
    spfa();
    
    if(d[n] == 0x3f3f3f3f)  puts("impossible");
    else cout << d[n] << endl;
    return 0;
}

spfa算法判负环： 在更新某个点到源点距离的同时将cnt[]更新，cnt[]表示某个点到到源点的边数，如果边数大于等于n，那么就存在负环。
但是由于该图不一定所有的点都连通，因此要将所有的点加入队列。

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

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

bool spfa()
{
    queue<int> q;
    for(int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] > d[t] + w[i])
            {
                d[j] = d[t] + w[i];
                cnt[j] = cnt[t] + 1;
                
                if(cnt[j] >= n) return true;
                
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    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;
}