存在负权边的单源汇最短路（Ballman-Ford、SPFA）

（一）Ballman-Ford

• Bellman-Ford算法是求负权图的单源最短路径的一种算法，效率较低，代码难度小。其原理为连续进行松弛，在每次松弛时吧每条边都更新一下，若在n-1次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
• 优点：可以计算有边数限制的最短路问题；但是处理负权图时往往使用SPFA。
• 具体步骤：

  for(int i = 0; i < n; i ++ )
  		for(所有边 a, b, w)     <-松弛操作
  			dist[b] = min(dist[b], back[a] + w)
  

  注意：back[ ]数组是上一次迭代后的dist数组的备份，防止发生串联效应，影响后续结点的更新。

例题：

题目描述
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过 10000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3

AC代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 510, M = 10010;

struct Edge
{
    int a, b, w;
}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 ++ )
    {
        memcpy(last, dist, sizeof last);
        for(int j = 0; j < m; j ++ )
        {
            auto e = edges[j];
            dist[e.b] = min(dist[e.b], last[e.a] + e.w);
        }
    }
}

int main()
{
    cin >> n >> m >> k;

    for(int i = 0; i < m; i ++ )
    {
        int x, y, w;
        cin >> x >> y >> w;
        edges[i] = {x, y, w};
    }

    bellman_ford();

    if(dist[n] > 0x3f3f3f3f / 2)    cout << "impossible" << endl;
    else    cout << dist[n] << endl;

    return 0;
}

（二）spfa

• spfa算法是对Bellman_ford的一个优化版本。Bellman_ford算法会遍历所有的边，但是有很多的边遍历了其实没有意义，我们只用遍历那些到源点距离变小的点所连接的边即可，只有当一个点的前驱结点更新了，该结点才会更新。因此，我们将创建一个队列每一次加入距离被更新的结点。
• st数的作用：判断当前的点是否已经加入到队列当中；已经加入队列的结点就不需要反复的把该点加入到队列中，就算此次还是会更新到源点的距离，那只用更新一下数值而不用加入到队列中。
• spfa算法看上去与Dijkstra算法长得有一些像，但是其中的意义还是相差甚远的：

  1] Dijkstra算法中的st数组保存的是当前确定了到源点距离最小的点，且一旦确定了最小那么就不可逆了（不可标记为true后改编为false）；SPFA算法中的st数组仅仅只是表示的当前发生过更新的点，且spfa中的st数组可逆。顺带一提，BFS中的st数组记录的是当前已经被遍历过的点。
  2] Dijkstra算法里使用的是优先队列保存的是当前没确定最小距离的点，目的是快速的去除当前到源点距离最小的点；SPFA算法中使用的是队列，目的只是记录一下当前发生过更新的点。

• 求负环一般使用SPFA算法，方法使用一个cnt数组记录每个点到源点的边数，一个点被更新一次就+1，一旦有点的边数达到了n那就证明存在负环。

(1) spfa求最短路例题

题目描述
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 impossible。
数据范围
1≤n,m≤105,
图中涉及边长绝对值均不超过 10000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

AC代码：

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>

using namespace std;

const int N = 100010;

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

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

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[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(dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return dist[n];
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for(int i = 0; i < m; i ++ )
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }

    int t = spfa();
    if(t == 0x3f3f3f3f) puts("impossible");
    else    cout << t << endl;

    return 0;
}