BZOJ2200： [Usaco2011 Jan]道路和航线 拓扑排序+最短路

题面

挺好的题。
题意十分清晰， 求S出发到每个点的最短路。
由于负权边的存在，不可以直接用dijkstra求解， 考虑spfa。
spfa的理论复杂度为$O(T(R+P))$过不去，实际上也会TLE(好像加了SLF可以水过去

一开始想了一个非常naive的做法：用dijkstra，把每条边的边权+10001， 记录最短路上的边数，
统计答案时减掉即可 但正确性出问题了x WA

正确的思路是：

$如果有一条航线可以从A_i到B_i，那么保证不可能通过一些道路和航线从B_i回到A_i$

即不会存在使dijkstra在联通块内无限松弛的情况
根据题中的特殊性质，把所有无向边先加进图中，用dfs缩点，统计每个联通块的入度
这样把有向边加进来以后可以弄成一个DAG
然后在每个联通块内用dijkstra维护最短路 遍历领接表的时候判断一下边的两个端点是否属于同一个联通块
如果不是， 按照拓扑排序的方式更新入度并把入度为0的联通块入队即可

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
using namespace std;
const int maxn = 25007, maxm = 200007;
#define ll long long
#define Min(_A,_B) (_A>_B?_B:_A)
const ll inf = 1000000000000;
struct edge{
    int v, nxt; ll w;
}e[maxm];
int head[maxn], eid, tot, c[maxn], q[maxn], qh, qt, deg[maxn], T, R, P, S; 
int cnt;
ll dis[maxn], ans;
void init(){
    memset(head, -1, sizeof(head));
    eid = 0;
}
void insert(int u, int v, ll w) {
    e[eid].v = v; e[eid].nxt = head[u]; e[eid].w = w; head[u] = eid++;
}
void insert2(int u, int v, ll w) {
    insert(u, v, w); insert(v, u, w);
}
vector<int> belong[maxn];
void dfs(int u, int num) {
    c[u] = num;
    belong[num].push_back(u);
    for (int i = head[u]; ~i; i = e[i].nxt) {
        if (!c[e[i].v]) dfs(e[i].v, num);
    }
}
int read(){
    int s = 0, f = 1; char c = getchar();
    while (c > '9' || c < '0') {
        if (c == '-') f = -1; c = getchar();
    }
    while (c >= '0' && c <= '9') {
        s = s * 10 + c - '0';
        c = getchar();
    }
    return s * f;
}
typedef pair<ll, int> pii;
set<pii, less<pii> > min_heap;
int main(){
    T = read(), R = read(), P = read(), S = read();
    init();
    for (int i = 1; i <= R; i++) {
        int A = read(), B = read(), C = read();
        insert2(A, B, C);
    }
    for (int i = 1; i <= T; i++) {
        if (!c[i]) { dfs(i, ++cnt); }
    }
    for (int i = 1; i <= P; i++) {
        int A = read(), B = read(), C = read();
        insert(A, B, C); deg[c[B]]++;
    }
    memset(dis, 0x3f, sizeof(dis));
    dis[S] = 0; 
    for (int i = 1; i <= cnt; i++) {
        if (!deg[i]) q[qt++] = i;
    }
    while (qh ^ qt) {
        int u = q[qh++]; if(qh == maxn) qh = 0;
        for (int i = 0; i < belong[u].size();i++) {
            min_heap.insert(make_pair(dis[belong[u][i]], belong[u][i]));
        }
        while (!min_heap.empty()) {
            set<pii, less<pii> >::iterator it = min_heap.begin();
            int x = it->second;
            min_heap.erase(*it);
            for (int i = head[x]; ~i; i = e[i].nxt) {
                int v = e[i].v;
                if (dis[v] > dis[x] + e[i].w) {
                    if (c[x] == c[v]) {
                        min_heap.erase(make_pair(dis[v], v));
                        dis[v] = dis[x] + e[i].w;
                        min_heap.insert(make_pair(dis[v], v));
                    } 
                }
                if (c[x] != c[v]) {
                    dis[v] = Min(dis[v], dis[x] + e[i].w);
                    deg[c[v]]--; if(!deg[c[v]]) q[qt++] = c[v];
                    if (qt == maxn) qt = 0;
                }
            }
        }
    }
    for (int i = 1; i <= T; i++) {
        if (dis[i] >= 1000000000) puts("NO PATH");
        else printf("%lld\n", dis[i]);
    }
    return 0;
}