HDU 5458 Stability

Stability

Time Limit: 2000ms

Memory Limit: 102400KB

This problem will be judged on HDU. Original ID: 5458
64-bit integer IO format: %I64d      Java class name: Main

 

Given an undirected connected graph G with n nodes and m edges, with possibly repeated edges and/or loops. The stability of connectedness between node u and node v is defined by the number of edges in this graph which determines the connectedness between them (once we delete this edge, node u and v would be disconnected).

You need to maintain the graph G, support the deletions of edges (though we guarantee the graph would always be connected), and answer the query of stability for two given nodes.

Input
There are multiple test cases(no more than 3 cases), and the first line contains an integer t, meaning the totally number of test cases.

For each test case, the first line contains three integers n, m and q, where 1≤n≤3×104,1≤m≤105 and 1≤q≤105. The nodes in graph G are labelled from 1 to n.

Each of the following m lines contains two integers u and v describing an undirected edge between node u and node v.

Following q lines - each line describes an operation or a query in the formats:
⋅ 1 a b: delete one edge between a and b. We guarantee the existence of such edge.
⋅ 2 a b: query the stability between a and b.

Output
For each test case, you should print first the identifier of the test case.

Then for each query, print one line containing the stability between corresponding pair of nodes.

Sample Input
1
10 12 14
1 2
1 3
2 4
2 5
3 6
4 7
4 8
5 8
6 10
7 9
8 9
8 10
2 7 9
2 7 10
2 10 6
2 10 5
1 10 6
2 10 1
2 10 6
2 3 10
1 8 5
2 5 10
2 4 5
1 7 9
2 7 9
2 10 5

Sample Output
Case #1:
0
0
0
0
2
4
3
3
2
3
4

Source
2015 ACM/ICPC Asia Regional Shenyang Online

解题：树链剖分

逆向操作，把删边视为加边，除去删除的那些边，玩树链剖分，首先，你得有棵树，没树，什么都是扯淡。

我们把要删的那些边从图上统统删除，剩下的残图不一定就是树，所以用并查集在残图上找棵树，树的边权都设为1，然后把残图中不在树上的边都加到树上，这样形成环了，那么把环上的树边全部置0.

现在开始删边（实际是加边，因为逆序操作）和查询，是的，逆序的，每次加边，就把形成的环，环上的树边都置成0，查询就查询这条路径上的边权和即可

 #include <iostream>
 #include <stdio.h>
 #include <set>
 #include <algorithm>
 #include <cstring>
 using namespace std;
 typedef pair<int,int> PII;
 const int maxn = ;
 struct arc {
     int to,next;
     arc(int x = ,int y = -) {
         to = x;
         next = y;
     }
 } e[maxn<<];
 struct node {
     int lt,rt,sum,lazy;
 } tree[maxn<<];
 int head[maxn],tot;
 void add(int u,int v) {
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
 }
 inline void pushup(int v) {
     tree[v].sum = tree[v<<].sum + tree[v<<|].sum;
 }
 inline void pushdown(int v) {
     if(~tree[v].lazy) {
         tree[v<<].sum = (tree[v<<].rt - tree[v<<].lt + )*tree[v].lazy;
         tree[v<<].lazy = tree[v].lazy;
         tree[v<<|].sum = (tree[v<<|].rt - tree[v<<|].lt + )*tree[v].lazy;
         tree[v<<|].lazy = tree[v].lazy;
         tree[v].lazy = -;
     }
 }
 void build(int lt,int rt,int v) {
     tree[v].lt = lt;
     tree[v].rt = rt;
     tree[v].lazy = -;
     if(lt == rt) {
         tree[v].sum = ;
         return;
     }
     int mid = (lt + rt)>>;
     build(lt,mid,v<<);
     build(mid + ,rt,v<<|);
     pushup(v);
 }
 void update(int lt,int rt,int val,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt) {
         tree[v].sum = (tree[v].rt - tree[v].lt + )*val;
         tree[v].lazy = val;
         return;
     }
     pushdown(v);
     if(lt <= tree[v<<].rt) update(lt,rt,val,v<<);
     if(rt >= tree[v<<|].lt) update(lt,rt,val,v<<|);
     pushup(v);
 }
 int query(int lt,int rt,int v) {
     if(lt == tree[v].lt && rt == tree[v].rt) return tree[v].sum;
     pushdown(v);
     int mid = (tree[v].lt + tree[v].rt)>>;
     if(rt <= mid) return query(lt,rt,v<<);
     if(lt > mid) return query(lt,rt,v<<|);
     return query(lt,mid,v<<) + query(mid + ,rt,v<<|);
 }
 int fa[maxn],dep[maxn],top[maxn],siz[maxn],son[maxn],loc[maxn],cnt;
 void FindHeavyEdge(int u,int father,int depth) {
     fa[u] = father;
     dep[u] = depth;
     siz[u] = ;
     son[u] = -;
     for(int i = head[u]; ~i; i = e[i].next) {
         if(e[i].to == father) continue;
         FindHeavyEdge(e[i].to,u,depth + );
         siz[u] += siz[e[i].to];
         if(son[u] == - || siz[son[u]] < siz[e[i].to])
             son[u] = e[i].to;
     }
 }
 void ConnectHeavyEdge(int u,int ancestor) {
     top[u] = ancestor;
     loc[u] = ++cnt;
     if(son[u] != -) ConnectHeavyEdge(son[u],ancestor);
     for(int i = head[u]; ~i; i = e[i].next) {
         if(e[i].to == fa[u] || e[i].to == son[u]) continue;
         ConnectHeavyEdge(e[i].to,e[i].to);
     }
 }
 void UPDATE(int u,int v,int val = ) {
     while(top[u] != top[v]) {
         if(dep[top[u]] < dep[top[v]]) swap(u,v);
         update(loc[top[u]],loc[u],val,);
         u = fa[top[u]];
     }
     if(u == v) return;
     if(dep[u] > dep[v]) swap(u,v);
     update(loc[son[u]],loc[v],val,);
 }
 int QUERY(int u,int v,int ret = ) {
     while(top[u] != top[v]) {
         if(dep[top[u]] < dep[top[v]]) swap(u,v);
         ret += query(loc[top[u]],loc[u],);
         u = fa[top[u]];
     }
     if(u == v) return ret;
     if(dep[u] > dep[v]) swap(u,v);
     return ret + query(loc[son[u]],loc[v],);
 }
 int u,v,ans[maxn],uf[maxn],op[maxn],x[maxn],y[maxn];
 bool used[maxn];
 int Find(int x) {
     if(x != uf[x]) uf[x] = Find(uf[x]);
     return uf[x];
 }
 multiset<PII>S,V;
 int main() {
     int kase,n,m,q,cs = ;
     scanf("%d",&kase);
     while(kase--) {
         S.clear();
         V.clear();
         scanf("%d%d%d",&n,&m,&q);
         for(int i = tot = cnt = ; i < m; ++i) {
             scanf("%d%d",&u,&v);
             if(u > v) swap(u,v);
             S.insert(PII(u,v));
         }
         for(int i = ; i <= n; ++i) {
             head[i] = -;
             used[i] = false;
             uf[i] = i;
         }
         for(int i = ; i < q; ++i) {
             scanf("%d%d%d",op + i,x + i,y + i);
             if(x[i] > y[i]) swap(x[i],y[i]);
             if(op[i] == ) S.erase(S.find(PII(x[i],y[i])));
         }
         for(auto &it:S) {
             int a = Find(it.first),b = Find(it.second);
             if(a != b) {
                 V.insert(it);
                 add(it.first,it.second);
                 add(it.second,it.first);
                 uf[a] = b;
             }
         }
         FindHeavyEdge(,,);
         ConnectHeavyEdge(,);
         build(,cnt,);
         for(auto &it:S)
             if(V.find(it) == V.end()) UPDATE(it.first,it.second);
         for(int i = q-; i >= ; --i)
             if(op[i] == ) UPDATE(x[i],y[i]);
             else if(op[i] == ) ans[i] = QUERY(x[i],y[i]);
         printf("Case #%d:\n",cs++);
         for(int i = ; i < q; ++i)
             if(op[i] == ) printf("%d\n",ans[i]);
     }
     return ;
 }