HDU 5458 Stability（双连通分量+LCA+并查集+树状数组）（2015 ACM/ICPC Asia Regional Shenyang Online）

  1 #include <cstdio>
  2 #include <algorithm>
  3 #include <iostream>
  4 #include <cstring>
  5 #include <vector>
  6 #include <cctype>
  7 using namespace std;
  8 typedef long long LL;
  9 
 10 const int MAXV = 30010;
 11 const int MAXQ = 100010;
 12 const int MAX_LOG = 16;
 13 const int INF = 0x3f3f3f3f;
 14 const int MOD = 1e9 + 7;
 15 
 16 int readint() {
 17     char c = getchar();
 18     while(!isdigit(c)) c = getchar();
 19     int res = 0;
 20     while(isdigit(c)) res = res * 10 + c - ‘0‘, c = getchar();
 21     return res;
 22 }
 23 
 24 struct Node {
 25     int to, del, f;
 26     Node(int to, int f = 0): to(to), del(0), f(f) {}
 27     bool operator < (const Node &rhs) const {
 28         if(to != rhs.to) return to < rhs.to;
 29         return del > rhs.del;
 30     }
 31 };
 32 vector<Node> adjs[MAXV];
 33 int n, m, q, T;
 34 
 35 void init() {
 36     for(int i = 1; i <= n; ++i) {
 37         adjs[i].clear();
 38     }
 39 }
 40 
 41 void add_edge(int u, int v) {
 42     adjs[u].push_back(Node(v, adjs[v].size()));
 43     adjs[v].push_back(Node(u, adjs[u].size() - 1));
 44 }
 45 
 46 struct Query {
 47     int op, a, b, apos, bpos;
 48     void read() {
 49         scanf("%d%d%d", &op, &a, &b);
 50         if(op == 1) {
 51             auto it = lower_bound(adjs[a].begin(), adjs[a].end(), Node(b));
 52             it->del = adjs[b][it->f].del = true;
 53         }
 54     }
 55 } query[MAXQ];
 56 int ans[MAXQ], acnt;
 57 
 58 struct BIT {
 59     int tree[MAXV];
 60     void init() {
 61         memset(tree + 1, 0, n * sizeof(int));
 62     }
 63     int lowbit(int x) {
 64         return x & -x;
 65     }
 66     void modify(int x, int val) {
 67         while(x <= n) {
 68             tree[x] += val;
 69             x += lowbit(x);
 70         }
 71     }
 72     void modify(int a, int b, int val) {
 73         modify(a, val);
 74         modify(b + 1, -val);
 75     }
 76     int get_val(int x) {
 77         int res = 0;
 78         while(x) {
 79             res += tree[x];
 80             x -= lowbit(x);
 81         }
 82         return res;
 83     }
 84 } bitree;
 85 
 86 int bid[MAXV], eid[MAXV];
 87 int dfs_clock;
 88 
 89 void dfs_id(int u) {
 90     bid[u] = ++dfs_clock;
 91     for(Node& p : adjs[u]) if(!p.del && !bid[p.to]) {
 92         p.del = adjs[p.to][p.f].del = 2;
 93         dfs_id(p.to);
 94     }
 95     eid[u] = dfs_clock;
 96     bitree.modify(bid[u], eid[u], 1);
 97 }
 98 void bit_init() {
 99     memset(bid + 1, 0, n * sizeof(int));
100     bitree.init();
101     dfs_id(1);
102 }
103 
104 struct LCA {
105     int fa[MAX_LOG][MAXV];
106     int dep[MAXV];
107 
108     void dfs_lca(int u, int f, int depth) {
109         dep[u] = depth;
110         fa[0][u] = f;
111         for(Node p : adjs[u]) if(p.del == 2 && p.to != f)
112             dfs_lca(p.to, u, depth + 1);
113     }
114 
115     void init_lca() {
116         dfs_lca(1, -1, 0);
117         for(int k = 0; k + 1 < MAX_LOG; ++k) {
118             for(int u = 1; u <= n; ++u) {
119                 if(fa[k][u] == -1) fa[k + 1][u] = -1;
120                 else fa[k + 1][u] = fa[k][fa[k][u]];
121             }
122         }
123     }
124 
125     int ask(int u, int v) {
126         if(dep[u] < dep[v]) swap(u, v);
127         for(int k = 0; k < MAX_LOG; ++k) {
128             if((dep[u] - dep[v]) & (1 << k)) u = fa[k][u];
129         }
130         if(u == v) return u;
131         for(int k = MAX_LOG - 1; k >= 0; --k) {
132             if(fa[k][u] != fa[k][v])
133                 u = fa[k][u], v = fa[k][v];
134         }
135         return fa[0][u];
136     }
137 } lca;
138 
139 int dsu[MAXV];
140 
141 int find_set(int x) {
142     return dsu[x] == x ? x : dsu[x] = find_set(dsu[x]);
143 }
144 
145 void mergeFa(int u, int gold) {
146     u = find_set(u);
147     while(u != gold) {
148         int t = find_set(lca.fa[0][u]);
149         dsu[u] = t;
150         bitree.modify(bid[u], eid[u], -1);
151         u = t;
152     }
153 }
154 
155 void merge(int u, int v) {
156     int l = find_set(lca.ask(u, v));
157     mergeFa(u, l);
158     mergeFa(v, l);
159 }
160 
161 void init_tree() {
162     for(int i = 1; i <= n; ++i)
163         dsu[i] = i;
164     for(int u = 1; u <= n; ++u)
165         for(Node p : adjs[u]) if(!p.del) {
166             merge(u, p.to);
167             p.del = adjs[p.to][p.f].del = 2;
168         }
169 }
170 
171 void solve() {
172     bit_init();
173     lca.init_lca();
174     init_tree();
175     for(int i = q - 1; i >= 0; --i) {
176         if(query[i].op == 1) {
177             merge(query[i].a, query[i].b);
178         } else {
179             int l = lca.ask(query[i].a, query[i].b);
180             ans[acnt++] = bitree.get_val(bid[query[i].a]) + bitree.get_val(bid[query[i].b]) - 2 * bitree.get_val(bid[l]);
181         }
182     }
183     for(int i = acnt - 1; i >= 0; --i)
184         printf("%d\n", ans[i]);
185 }
186 
187 int main() {
188     scanf("%d", &T);
189     for(int t = 1; t <= T; ++t) {
190         scanf("%d%d%d", &n, &m, &q);
191         init();
192         for(int i = 0, u, v; i < m; ++i) {
193             u = readint(), v = readint();
194             add_edge(u, v);
195         }
196         for(int i = 1; i <= n; ++i)
197             sort(adjs[i].begin(), adjs[i].end());
198 
199         acnt = 0;
200         for(int i = 0; i < q; ++i)
201             query[i].read();
202 
203         printf("Case #%d:\n", t);
204         solve();
205     }
206 }