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）：

  1 #include <cstdio>
  2 #include <iostream>
  3 #include <algorithm>
  4 #include <cstring>
  5 #include <vector>
  6 using namespace std;
  7 typedef long long LL;
  8 
  9 typedef pair<int, int> PII;
 10 
 11 const int MAXV = 10010;
 12 const int MAXE = 200010;
 13 
 14 int ans[MAXV];
 15 vector<PII> query[MAXV << 1];
 16 
 17 struct SccGraph {
 18     int head[MAXV << 1], fa[MAXV << 1], ecnt;
 19     bool vis[MAXV << 1];
 20     int to[MAXE << 1], next[MAXE << 1];
 21     int dep[MAXV << 1];
 22 
 23     void init(int n) {
 24         memset(head, -1, sizeof(int) * (n + 1));
 25         memset(vis, 0, sizeof(bool) * (n + 1));
 26         for(int i = 1; i <= n; ++i) fa[i] = i;
 27         ecnt = 0;
 28     }
 29 
 30     int find_set(int x) {
 31         return fa[x] == x ? x : fa[x] = find_set(fa[x]);
 32     }
 33 
 34     void add_edge(int u, int v) {
 35         to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
 36         to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
 37     }
 38 
 39     void lca(int u, int f, int deep) {
 40         dep[u] = deep;
 41         for(int p = head[u]; ~p; p = next[p]) {
 42             int &v = to[p];
 43             if(v == f || vis[v]) continue;
 44             lca(v, u, deep + 1);
 45             fa[v] = u;
 46         }
 47         vis[u] = true;
 48         for(vector<PII>::iterator it = query[u].begin(); it != query[u].end(); ++it) {
 49             if(vis[it->first]) {
 50                 ans[it->second] = (dep[u] + dep[it->first] - 2 * dep[find_set(it->first)]) / 2;
 51             }
 52         }
 53     }
 54 } G;
 55 
 56 int head[MAXV], lowlink[MAXV], pre[MAXV], ecnt, dfs_clock;
 57 int sccno[MAXV], scc_cnt;
 58 int to[MAXE], next[MAXE], scc_edge[MAXE];
 59 bool vis[MAXE], iscut[MAXV];
 60 int stk[MAXE], top;
 61 int n, m, q;
 62 
 63 void init() {
 64     memset(head, -1, sizeof(int) * (n + 1));
 65     memset(pre, 0, sizeof(int) * (n + 1));
 66     memset(iscut, 0, sizeof(bool) * (n + 1));
 67     memset(vis, 0, sizeof(bool) * (2 * m));
 68     ecnt = scc_cnt = dfs_clock = 0;
 69 }
 70 
 71 void add_edge(int u, int v) {
 72     to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
 73     to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
 74 }
 75 
 76 void tarjan(int u, int f) {
 77     pre[u] = lowlink[u] = ++dfs_clock;
 78     int child = 0;
 79     for(int p = head[u]; ~p; p = next[p]) {
 80         if(vis[p]) continue;
 81         vis[p] = vis[p ^ 1] = true;
 82         stk[++top] = p;
 83         int &v = to[p];
 84         if(!pre[v]) {
 85             ++child;
 86             tarjan(v, u);
 87             lowlink[u] = min(lowlink[u], lowlink[v]);
 88             if(pre[u] <= lowlink[v]) {
 89                 iscut[u] = true;
 90                 ++scc_cnt;
 91                 while(true) {
 92                     int t = stk[top--];
 93                     scc_edge[t] = scc_edge[t ^ 1] = scc_cnt;
 94                     if(t == p) break;
 95                 }
 96             }
 97         } else lowlink[u] = min(lowlink[u], pre[v]);
 98     }
 99     if(f < 1 && child == 1) iscut[u] = false;
100 }
101 
102 void build() {
103     G.init(scc_cnt);
104     for(int p = 0; p != ecnt; ++p) {
105         int &v = to[p];
106         if(iscut[v]) G.add_edge(sccno[v], scc_edge[p]);
107     }
108 }
109 
110 void solve() {
111     for(int i = 1; i <= n; ++i)
112         if(!pre[i]) tarjan(i, 0);
113     for(int u = 1; u <= n; ++u)
114         if(iscut[u]) sccno[u] = ++scc_cnt;
115 }
116 
117 int main() {
118     while(scanf("%d%d", &n, &m) != EOF) {
119         if(n == 0 && m == 0) break;
120         init();
121         for(int i = 1; i <= m; ++i) {
122             int u, v;
123             scanf("%d%d", &u, &v);
124             add_edge(u, v);
125         }
126         solve();
127         build();
128         for(int i = 0; i <= scc_cnt; ++i) query[i].clear();
129         scanf("%d", &q);
130         for(int i = 0; i < q; ++i) {
131             int x, y;
132             scanf("%d%d", &x, &y);
133             x = scc_edge[x * 2 - 2]; y = scc_edge[y * 2 - 2];
134             query[x].push_back(make_pair(y, i));
135             query[y].push_back(make_pair(x, i));
136         }
137         for(int i = 1; i <= scc_cnt; ++i) if(!G.vis[i]) G.lca(i, 0, 0);
138         for(int i = 0; i < q; ++i) printf("%d
", ans[i]);
139     }
140 }

View Code

相关阅读:
如何在自定义端口上运行 Spring Boot 应用程序
 如何重新加载Spring Boot 上的更改，而无需重新启动服务器
 JavaConfig
常用的linux指令
 接口绑定有几种实现方式,分别是怎么实现的?
JDK,JRE,JVM三者关系
 final finally finalize区别
 execute，executeQuery，executeUpdate的区别是什么？
相对于Statement，PreparedStatement的优点是什么？
JDBC访问数据的基本步骤是什么
原文地址：https://www.cnblogs.com/oyking/p/3645984.html