Roads and Planes【Tarjan+拓扑+Dijkstra】

题目链接

---

  有N个点，R条无向边，P条有向边，再给出起点S，问从起点S到达1～N各点的最短距离，如果无法到达，按题目输出。

  很明显的，这就是不能直接用任意一个最短路的算法来解决该问题，容错的SPFA可以卡（玄学）。

  这里用一个比较稳的做法，复杂度就是。

  首先，我们构造一个DAG图，然后利用拓扑的思路解决这个问题，拓扑的复杂度是O(N)的，怎样构成DAG呢？基础的Tarjan缩点问题，O(N)。剩下的，对于环内跑Dijkstra保证复杂度是，环与环之间就是DAG了，直接拓扑序即可。

  一个基本的细节，我们只用在Tarjan的时候跑S能到的点，如果dfn为空的点，说明是到不了的。为什么只跑S呢？是为了构造拓扑图的时候，避免发生有环指向S所在的环，这样的问题。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2.5e4 + 7, maxM = 2e5 + 7;
int N, R, P, S;
struct Graph
{
    int head[maxN], cnt;
    struct Eddge
    {
        int nex, to; int val;
        Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), val(c) {}
    }edge[maxM];
    inline void addEddge(int u, int v, int w)
    {
        edge[cnt] = Eddge(head[u], v, w);
        head[u] = cnt++;
    }
    inline void _add(int u, int v, int w) { addEddge(u, v, w); addEddge(v, u, w); }
    inline void init()
    {
        cnt = 0;
        for(int i=1; i<=N; i++) head[i] = -1;
    }
} Old, Now;
int dfn[maxN], low[maxN], tot, Stap[maxN], Stop, Belong[maxN], Bcnt;
bool instack[maxN] = {false};
vector<int> Bpoint[maxN];
void Tarjan(int u)
{
    dfn[u] = low[u] = ++tot;
    instack[u] = true; Stap[++Stop] = u;
    for(int i=Old.head[u], v; ~i; i=Old.edge[i].nex)
    {
        v = Old.edge[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instack[v]) low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u])
    {
        Bcnt++;
        int v;
        do
        {
            v = Stap[Stop--];
            instack[v] = false;
            Belong[v] = Bcnt;
            Bpoint[Bcnt].push_back(v);
        } while(u ^ v);
    }
}
int du[maxN] = {0}, ith[maxN], _Index;
void tp_sort()
{
    queue<int> Q;
    Q.push(Belong[S]);
    while(!Q.empty())
    {
        int u = Q.front(); Q.pop(); ith[++_Index] = u;
        for(int i=Now.head[u], v; ~i; i=Now.edge[i].nex)
        {
            v = Now.edge[i].to;
            du[v]--;
            if(!du[v]) Q.push(v);
        }
    }
}
int dis[maxN];
struct node
{
    int id; int val;
    node(int a=0, int b=0):id(a), val(b) {}
    friend bool operator < (node e1, node e2) { return e1.val > e2.val; }
};
priority_queue<node> Q;
void Dijkstra(int Bid)
{
    while(!Q.empty()) Q.pop();
    for(auto u : Bpoint[Bid]) Q.push(node(u, dis[u]));
    while(!Q.empty())
    {
        node now = Q.top(); Q.pop();
        int u = now.id;
        if(dis[u] < now.val) continue;
        for(int i=Old.head[u], v; ~i; i=Old.edge[i].nex)
        {
            v = Old.edge[i].to;
            if(dis[v] > dis[u] + Old.edge[i].val)
            {
                dis[v] = dis[u] + Old.edge[i].val;
                if(Belong[v] == Bid) Q.push(node(v, dis[v]));
            }
        }
    }
}
inline void init()
{
    tot = Stop = Bcnt = _Index = 0;
    Old.init(); Now.init();
    for(int i=1; i<=N; i++) { dis[i] = INF; dfn[i] = du[i] = 0; instack[i] = false; }
}
int main()
{
    scanf("%d%d%d%d", &N, &R, &P, &S);
    init();
    for(int i=1, u, v, w; i<=R; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        Old._add(u, v, w);
    }
    for(int i=1, u, v, w; i<=P; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        Old.addEddge(u, v, w);
    }
    Tarjan(S);  //only S!!!
    for(int u=1; u<=N; u++)
    {
        if(!dfn[u]) continue;
        for(int i=Old.head[u], v; ~i; i=Old.edge[i].nex)
        {
            v = Old.edge[i].to;
            if(Belong[u] == Belong[v]) continue;
            Now.addEddge(Belong[u], Belong[v], 0); du[Belong[v]] ++;
        }
    }
    tp_sort();
    dis[S] = 0;
    for(int i=1, its_id; i<=_Index; i++)
    {
        its_id = ith[i];
        Dijkstra(its_id);
    }
    for(int i=1; i<=N; i++)
    {
        if(dis[i] == INF) printf("NO PATH\n");
        else printf("%d\n", dis[i]);
    }
    return 0;
}