【算法】最短路 - SPFA

SPFA

即队列优化过的Bellman-Ford算法，可以处理带负权图。

应用于单源最短路。

此外还可以进行负权环的判定，即若第n次操作仍可降低花费，则一定存在负权环。

//Bellman-Ford算法
for (int i = 0; i < n; i++) d[i] = INF;
    d[0] = 0;
    for (int k = 0; k < n - 1; k++) {//迭代n-1次
        for (int i = 0; i < m; i++) {
            int x = u[i], y = v[i];
            if (d[x] < INF) d[y] = min(d[y], d[x] + w[i]);
        }
    }

bool spfa(int s) {
    queue<int>Q;
    memset(inq, 0, sizeof(inq));//标记结点是否在队列中
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; i++) d[i] = INF;
    d[s] = 0;
    inq[s] = true;//标记结点s已在队列中
    Q.push(s);
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        inq[u] = false;//标记已不在队列
        for (int i = 0; i < G[u].size(); i++) {
            Edge& e = Edges[G[u][i]];//遍历以结点u为起点的有向边
            if (d[u]<INF && d[u] + e.dist<d[e.to]) {
                d[e.to] = d[u] + e.dist;//松弛
                p[e.to] = G[u][i];//记录父节点
                if (!inq[e.to]) {//只要不在队列中就可以入队
                    Q.push(e.to);
                    inq[e.to] = true;
                    if (++cnt[e.to] > n) return false;
                    //如果某个点迭代了超过n次，说明存在可以无限缩短的最短路，即负环
                }
            }
        }
    }
    return true;
}