AcWing 851. spfa求最短路

一、(spfa)算法

(spfa)算法是 (bellman-ford)算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。

(bellman-ford)是一个很傻的算法，因为它一共进行(n)次，每次把每条边都遍历一次，不管是不是变小了，都判断一次 (dist[b]=min(dist[b],dist[a]+w)),其实，(dist[b])如果真的变小，是因为 (dist[a])变小了，它得到利益，换句话说就是前驱变小而受益,所以可以采用宽搜来做优化。

因为需要找到每个节点的下家，所以再用结构体就不方便了，这里使用了邻接表来存储。

二、关键问题

(st)数组的作用
1. 判断当前的点是否已经加入到队列当中了。
2. 已经加入队列的结点就不需要反复的把该点加入到队列中了，就算此次还是会更新到源点的距离，那只用更新一下数值而不用加入到队列当中。
3. 即便不使用(st)数组最终也没有什么关系，但是使用的好处在于可以提升效率。
(spfa)算法看上去和(Dijstra)算法长得有一些像但是其中的意义还是相差甚远的:
1. (Dijkstra)算法中的(st)数组保存的是当前确定了到源点距离最小的点，且一旦确定了最小那么就不可逆了(不可标记为(true)后改变为(false))；(spfa)算法中的(st)数组仅仅只是表示的当前发生过更新的点，且(spfa)中的(st)数组可逆(可以在标记为(true)之后又标记为(false))。顺带一提的是(bfs)中的(st)数组记录的是当前已经被遍历过的点。
2. (Dijkstra)算法里使用的是优先队列保存的是当前未确定最小距离的点，目的是快速的取出当前到源点距离最小的点；(spfa)算法中使用的是队列(你也可以使用别的数据结构),目的只是记录一下当前发生过更新的点。
3. (bellman-ford)算法里最后return -1的判断条件写的是dist[n]>0x3f3f3f3f/2;而(spfa)算法写的是dist[n]==0x3f3f3f3f;其原因在于(bellman-ford)算法会遍历所有的边，因此不管是不是和源点连通的边它都会得到更新；但是(spfa)算法不一样，它相当于采用了(bfs)，因此遍历到的结点都是与源点连通的，因此如果你要求的(n)和源点不连通，它不会得到更新，还是保持的0x3f3f3f3f。
4. (bellman-ford)算法可以存在负权回路，是因为其循环的次数是有限制的因此最终不会发生死循环；但是(spfa)算法不可以，由于用了队列来存储，只要发生了更新就会不断的入队，因此假如有负权回路请你不要用(spfa)否则会死循环。
5. 由于(spfa)算法是由(bellman-ford)算法优化而来，在最坏的情况下时间复杂度和它一样即时间复杂度为 (O(nm)) ，假如题目时间允许可以直接用(spfa)算法去解(Dijkstra)算法的题目。(好像(spfa)有点小小万能的感觉?)
6. 求负环一般使用(spfa)算法，方法是用一个(cnt)数组记录每个点到源点的边数，一个点被更新一次就+(1)，一旦有点的边数达到了(n)那就证明存在了负环。

三、C++ 代码

#include <bits/stdc++.h>
const int N = 100010;
const int INF = 0x3f3f3f3f;

using namespace std;
int n, m;                               // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];                            // 存储每个点到1号点的最短距离
bool st[N];                             // 存储每个点是否在队列中,防止存储重复的点，存储重复的点是没有意义的

//有负权边，无负权都可以，还比Dijkstra快
//SPFA很牛X的啊，速度好像比Dijkstra快，如果被卡了，只能用堆优化版本的Dijkstra
/**
 * 功能：链式前向星建图
 * @param a 结点a
 * @param b 结点b
 * @param c 边长为c
 */
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa() {
    //初始化距离
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    //声明一个队列，把1号结点放入
    queue<int> q;
    q.push(1);
    st[1] = true;
    //bfs
    while (q.size()) {
        //队列头弹出，就不在队列中了：st[t]=false
        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];
                // 如果队列中已存在j，则不需要将j重复插入
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    if (dist[n] == INF) return -1;
    return dist[n];
}

int main() {
    //读入优化
    ios::sync_with_stdio(false);
    cin >> n >> m;
    //初始化链式前向星头
    memset(h, -1, sizeof h);

    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    int t = spfa();
    if (t == -1) puts("impossible");
    else printf("%d
", t);
    return 0;
}