图论-SPFA模板

测试题目：NKOJ1120 NKOJ3639

最常见的 BFS 实现

#include <stdio.h>
#include <queue>
#include <vector>

typedef long long LL;

using namespace std;

const int _N = 420000;
const LL INF = 99999999999999LL;


LL n, m;
LL dis[_N];
bool book[_N];

struct node {
    LL v, w;
    node(LL _v, LL _w):
        v(_v), w(_w) {}
};

queue<LL> Q;
vector<node> G[_N];

void SPFA(LL beg)
{
    LL i, p;
    for (i = 1; i <= n; ++i)
        dis[i] = INF, book[i] = false;
    dis[beg] = 0, Q.push(beg), book[beg] = true;
    while (!Q.empty()) {
        int p = Q.front();
        Q.pop(), book[p] = false;
        vector<node>::iterator it;
        for (it = G[p].begin(); it != G[p].end(); ++it) {
            if (dis[it->v] <= dis[p] + it->w) continue;
            dis[it->v] = dis[p] + it->w;
            if (book[it->v]) continue;
            Q.push(it->v), book[it->v] = true;
        }
    }
    return ;
}

int main()
{
    LL i, t1, t2, t3;
    scanf("%lld%lld", &n, &m);
    for (i = 1; i <= m; ++i) {
        scanf("%lld%lld%lld", &t1, &t2, &t3);
        G[t1].push_back(node(t2, t3));
    }
    scanf("%lld%lld", &t1, &t2);
    SPFA(t1);
    printf("%lld
", dis[t2]);
    return 0;
}

判负环

BFS 判负环

如果某点入队次数 > N(总点数) ，则存在负环。否则不存在。

DFS 判负环

1.朴素的 DFS 判负环

bool SPFA(int p)
{
    bool flag = false;
    mk[p] = true;
    for (int i = G[p].size()-1; i >= 0; --i) {
        edge v = G[p][i];
        if (dis[v.v] > dis[p]+v.w) {
            dis[v.v] = dis[p]+v.w;
            if (!mk[v.v]) {
                if (SPFA(v.v)) { flag = true; break; }
            } else {
                flag = true;
                break;
            }
        }
    }
    mk[p] = false;
    return flag;
}

从假设的原点（即假设的到某个点都有一条边的点）开始跑一次 SPFA 。注意先初始化 dis[i] = INF, dis[beg] = 0.

2.优化的 DFS 判负环

SPFA 部分代码同上。设置 dis[i] = 0，这样在 SPFA 过程中总是会选择负权边，提高了效率。然后从每个点开始跑 SPFA ，直到负环出现。

***优化

1.SLF(Small Label First) 当 i 入队时，如果 dis[i] < dis[Q.front()] 则加入队首，否则加入队尾。

2.LLL(Large Label Last) 当准备从队列中取出一个数讨论时，设 ave 为队列中 dis 平均值，如果 dis[Q.front()] > x ，就把队首的元素放到队尾，再次判断是否 dis[Q.front()] > x …… 直到 dis[Q.front()] <= x 。