浅谈spfa几个优化

优化一：每次更新节点时，记录当前走的这条路径的节点数，当节点数大于n时，有负环，退出。注意，这里与常规的节点被更新n次以上退出不一样，效率比常规高。

优化二：双端队列SLF优化。当当前节点到起点距离小于队首的时候，将此点插入队首，否则，正常插入队尾。可能咋一看感觉这种优化可能被用到的机会很少，但很可能正好解决掉了专门卡spfa的数据以及网格图。

优化三：与优化二类似，但改为小于队列元素平均数时加入队首，还没试过。

附上一道用spfa但以上优化效果很明显的一道题

http://codeforces.com/gym/101498/problem/L

不加优化2500ms左右（TLE边缘），加入优化一和优化二后311ms。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int T, n, m, u, v, c;
map<pii, int> mmp;
struct edge {
    int v, c;
    edge () {}
    edge (int v, int c) : v(v), c(c) {}
    bool operator < (const edge &e) const {
        return c < e.c;}
};
vector<edge> E[2015];
ll spfa(int &flag) {
    bool in_que[2015];
    ll dis[2015];
    int cnt[2015];

    clr(in_que, 0);
    clr(cnt, 0);
    for (int i = 1; i <= n; ++i) {
        dis[i] = 1e18;
    }
    dis[0] = 0;
    deque<int> que;
    que.push_front(0);

    while (que.size()) {
        int x = que.front(); que.pop_front();
        in_que[x] = 0;
        for (int i = 0; i < E[x].size(); ++i) {
            int v = E[x][i].v, c = E[x][i].c;
            if (dis[v] > dis[x] + c) {
                dis[v] = dis[x] + c;
                if (!in_que[v]) {
                    if (que.size() && dis[v] < dis[que.front()] + 1) {
                        que.push_front(v);
                    } else {
                        que.push_back(v);
                    }
                    in_que[v] = 1;
                    cnt[v] = cnt[x] + 1;
                    if (n < cnt[v]) {
                        flag = 1;
                        return 2333;
                    }
                }
            }
        }
    }

    ll ans = 1e18;
    for (int i = 1; i <= n; ++i) {
        ans = min(ans, dis[i]);
    }
    return ans;
}
int main() {
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        mmp.clear();
        int mi = 1e18;
        for (int i = 1; i <= m; ++i) {
            scanf("%d%d%d", &u, &v, &c);
            if (mmp.count(pii(u, v))) {
                int x = mmp[pii(u, v)];
                c = min(x, c);
            }
            mmp[pii(u, v)] = c;
            mi = min(mi, c);
        }
        if (mi >= 0) {
            printf("%d
", mi);
            continue;
        }
        for (int i = 1; i <= n; ++i) E[i].clear();
        for (map<pii, int>::iterator it = mmp.begin(); it != mmp.end(); ++it) {
            int u = (*it).first.first, v = (*it).first.second, c = (*it).second;
            E[u].pb(edge(v, c));
        }
        for (int i = 1; i <= n; ++i) {
            E[0].pb(edge(i, 0));
        }
        for (int i = 0; i <= n; ++i) {
            sort(E[i].begin(), E[i].end());
        }
        int flag = 0;
        ll ans = spfa(flag);
        if (flag) {
            puts("-inf");
        } else {
            printf("%lld
", ans);
        }
    }
    return 0;
}