存在负权边的单源最短路问题—Bellman-Ford算法及其优化SPFA算法

1、Bellman-Ford算法是用来处理图中存在负权边的最短路情况，当图中有负权边时，Dijkstra()就不能用了，计算出的最短路会有问题。这里要注意若图中存在负权回路，最短路很可能不存在（在负权回路不影响我们想要走过的路径时，不影响结果），Bellman-Ford算法的思路是非常简单的，其应用场景也比较有限。

首先在进行松弛操作的时候，需要注意，要用上一次更新过的距离来更新其他节点，即需要对上一次的距离做一个保存，这样做的原因是在距离的更新过程中可能会发生串联，而BF算法一个重要的使用场景就是处理对经过的边数有限制的最短路问题，发生串联可能会导致错误。

这里对经过的边数有限制的最短路问题可以举一个具体的实例，比如我们在旅游时经常无法直达，需要换成，这里假设你可能要换乘的次数比较多，每一次的换乘就是一条边，价钱就是权重，你需要一条总价钱最小的换乘路线，但是又有一个因素会产生影响，就是每一次换乘都会影响你的心情，所以你希望换乘的次数是有限的，对应的就是对最短路的边数有限制。

代码实例：一个n个点，m条边的有向图，边权可能为负数，求出从一号点到n号点的最多经过k条边的最短距离。

这里使用结构体来存边

#include 
#include 
#include 

using namespace std;

const int N = 510, M = 10010;

struct Edge     //使用结构体存边
{
    int a, b, c;
}edges[M];

int n, m, k;
int dist[N];
int last[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;    //选一个起点
    
    for(int i = 0; i < k; i ++)         //k为限制的边数
    {
        memcpy(last, dist, sizeof dist);
        
        for(int j = 0; j < m; j ++)      //每次循环都会去更新一次所有边
        {
            auto e = edges[j];
            dist[e.b] = min(dist[e.b], last[e.a] + e.c);    //这里更新使用的上一次的状态
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 0; i < m; i ++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        edges[i] = {a, b, c};
    }
    
    bellman_ford();
    
    if(dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else cout << dist[n] << endl;
    
    return 0;
}

2、SPFA算法

这个算法是对BF算法的一个优化，在图中没有负环的情况下可用，从我们观察上面的代码可以看出每一次循环，都会更新所有的边，但其实这是不需要的，因为只有当前点的距离被更新，也就是说距离变小，才需要去更新这个的出边所连接的点，这个算法有些像是Dijkstra算法，事实上很多只有正权边的问题也可以用SPFA来做。它的时间复杂度为O（m），最坏情况下为O（nm）。

#include 
#include 
#include 
#include 

using namespace std;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];     //存储每个点是否在队列中

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

//时间复杂度O(m)
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    queue 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(dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if(!st[j])      //若队列中已经存在j，则不需要将j重复插入,避免重复入队
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);
    
    memset(h, -1, sizeof h);
    
    while(m --)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    
    int t = spfa();
    
    if(t == 0x3f3f3f3f) puts("impossible");
    else printf("%d\n", t);
    
    return 0;
}

SPFA的一个重要应用，判断图中是否存在负环

#include 
#include 
#include 
#include 

using namespace std;

const int N = 2010, M = 100010;

int n, m;
int h[N], w[M], e[M], ne[M], idx;
int dist[N], cnt[N];
bool st[N];

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

bool spfa()
{
    queue q;
    for(int i = 1; i <= n; i++)     //所有节点入队并进行标记
    {
        st[i] = true;
        q.push(i);
    }
    
    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(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])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

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