HDU 3686 Traffic Real Time Query System（双连通分量缩点+LCA）（2010 Asia Hangzhou Regional Contest）

Problem Description

City C is really a nightmare of all drivers for its traffic jams. To solve the traffic problem, the mayor plans to build a RTQS (Real Time Query System) to monitor all traffic situations. City C is made up of N crossings and M roads, and each road connects two crossings. All roads are bidirectional. One of the important tasks of RTQS is to answer some queries about route-choice problem. Specifically, the task is to find the crossings which a driver MUST pass when he is driving from one given road to another given road.

 

Input

There are multiple test cases.
For each test case:
The first line contains two integers N and M, representing the number of the crossings and roads.
The next M lines describe the roads. In those M lines, the i^th line (i starts from 1)contains two integers X_i and Y_i, representing that road_i connects crossing X_i and Y_i (X_i≠Y_i).
The following line contains a single integer Q, representing the number of RTQs.
Then Q lines follows, each describing a RTQ by two integers S and T(S≠T) meaning that a driver is now driving on the roads and he wants to reach roadt . It will be always at least one way from roads to roadt.
The input ends with a line of “0 0”.
Please note that: 0<N<=10000, 0<M<=100000, 0<Q<=10000, 0<X_i,Y_i<=N, 0<S,T<=M 

 

Output

For each RTQ prints a line containing a single integer representing the number of crossings which the driver MUST pass.

 

题目大意：给一个N个点M条边的无向图，然后有Q个询问X，Y，问第X条边到第Y条边必需要经过的点有多少个。

思路：对于两条边X，Y，若他们在同一个双连通分量中，那他们之间至少有两条路径可以互相到达。

那么，对于两条不在同一个分量中的边X，Y，显然从X到Y必须要经过的的点的数目等于从X所在的边双连通分量到Y所在的双连通分量中的割点的数目。

于是，可以找出所有双连通分量，缩成一个点。对于 双连通分量A - 割点 - 双连通分量B，重构图成3个点 A - 割点 - B。

那么，所有的双连通分量缩完之后，新图G‘成了一棵树（若存在环，那么环里的点都在同一个双连通分量中，矛盾）

那么题目变成了：从X所在的G'中的点，到Y所在的G’中的点的路径中，有多少点是由割点变成的。

由于图G‘中的点都是 双连通分量 - 割点 - 双连通分量 - 割点 - 双连通分量……的形式（两个双连通分量不会连在一起）

那么X到Y的割点的数目就等于两点距离除以2，暨(dep[x] + dep[Y] - dep[LCA(X, Y)]) / 2，其中dep是深度，lca是最近公共祖先。

其中LCA用tarjan也好，用RMQ也好，随意。我用的是离线的tarjan。

 

细节：因为找边双连通分量的思路错了跪了一整天……写一下正确又优美的姿势是怎么样的>_<

类似于tarjan求强联通的算法，用一个vis[]数组记录某条边是否被访问过。

每次第一次访问一条边，把这条边压入栈中，在遍历完某条边指向的点之后，若pre[u] <= lowlink[v]（见code），把栈中的边都设为同一个边双连通分量。

仔细想想觉得应该是对的。我不会证明>_<

 

PS：新图G’中点的数目可能会高达2*n的等级，试想一下原图恰好是一条链的情况，由于存在重边，边数也最好要2*m。

 

代码（178MS）：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
typedef long long LL;

typedef pair<int, int> PII;

const int MAXV = 10010;
const int MAXE = 200010;

int ans[MAXV];
vector<PII> query[MAXV << 1];

struct SccGraph {
    int head[MAXV << 1], fa[MAXV << 1], ecnt;
    bool vis[MAXV << 1];
    int to[MAXE << 1], next[MAXE << 1];
    int dep[MAXV << 1];

    void init(int n) {
        memset(head, -1, sizeof(int) * (n + 1));
        memset(vis, 0, sizeof(bool) * (n + 1));
        for(int i = 1; i <= n; ++i) fa[i] = i;
        ecnt = 0;
    }

    int find_set(int x) {
        return fa[x] == x ? x : fa[x] = find_set(fa[x]);
    }

    void add_edge(int u, int v) {
        to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
        to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
    }

    void lca(int u, int f, int deep) {
        dep[u] = deep;
        for(int p = head[u]; ~p; p = next[p]) {
            int &v = to[p];
            if(v == f || vis[v]) continue;
            lca(v, u, deep + 1);
            fa[v] = u;
        }
        vis[u] = true;
        for(vector<PII>::iterator it = query[u].begin(); it != query[u].end(); ++it) {
            if(vis[it->first]) {
                ans[it->second] = (dep[u] + dep[it->first] - 2 * dep[find_set(it->first)]) / 2;
            }
        }
    }
} G;

int head[MAXV], lowlink[MAXV], pre[MAXV], ecnt, dfs_clock;
int sccno[MAXV], scc_cnt;
int to[MAXE], next[MAXE], scc_edge[MAXE];
bool vis[MAXE], iscut[MAXV];
int stk[MAXE], top;
int n, m, q;

void init() {
    memset(head, -1, sizeof(int) * (n + 1));
    memset(pre, 0, sizeof(int) * (n + 1));
    memset(iscut, 0, sizeof(bool) * (n + 1));
    memset(vis, 0, sizeof(bool) * (2 * m));
    ecnt = scc_cnt = dfs_clock = 0;
}

void add_edge(int u, int v) {
    to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
    to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
}

void tarjan(int u, int f) {
    pre[u] = lowlink[u] = ++dfs_clock;
    int child = 0;
    for(int p = head[u]; ~p; p = next[p]) {
        if(vis[p]) continue;
        vis[p] = vis[p ^ 1] = true;
        stk[++top] = p;
        int &v = to[p];
        if(!pre[v]) {
            ++child;
            tarjan(v, u);
            lowlink[u] = min(lowlink[u], lowlink[v]);
            if(pre[u] <= lowlink[v]) {
                iscut[u] = true;
                ++scc_cnt;
                while(true) {
                    int t = stk[top--];
                    scc_edge[t] = scc_edge[t ^ 1] = scc_cnt;
                    if(t == p) break;
                }
            }
        } else lowlink[u] = min(lowlink[u], pre[v]);
    }
    if(f < 1 && child == 1) iscut[u] = false;
}

void build() {
    G.init(scc_cnt);
    for(int p = 0; p != ecnt; ++p) {
        int &v = to[p];
        if(iscut[v]) G.add_edge(sccno[v], scc_edge[p]);
    }
}

void solve() {
    for(int i = 1; i <= n; ++i)
        if(!pre[i]) tarjan(i, 0);
    for(int u = 1; u <= n; ++u)
        if(iscut[u]) sccno[u] = ++scc_cnt;
}

int main() {
    while(scanf("%d%d", &n, &m) != EOF) {
        if(n == 0 && m == 0) break;
        init();
        for(int i = 1; i <= m; ++i) {
            int u, v;
            scanf("%d%d", &u, &v);
            add_edge(u, v);
        }
        solve();
        build();
        for(int i = 0; i <= scc_cnt; ++i) query[i].clear();
        scanf("%d", &q);
        for(int i = 0; i < q; ++i) {
            int x, y;
            scanf("%d%d", &x, &y);
            x = scc_edge[x * 2 - 2]; y = scc_edge[y * 2 - 2];
            query[x].push_back(make_pair(y, i));
            query[y].push_back(make_pair(x, i));
        }
        for(int i = 1; i <= scc_cnt; ++i) if(!G.vis[i]) G.lca(i, 0, 0);
        for(int i = 0; i < q; ++i) printf("%d
", ans[i]);
    }
}