Hdu 5458 Stability (LCA + 并查集 + 树状数组 + 缩点)

题目链接：

　　Hdu 5458 Stability

题目描述：

　　给出一个还有环和重边的图G，对图G有两种操作：

　　1 u v, 删除u与v之间的一天边 (保证这个边一定存在)

　　2 u v, 查询u到v的路径上有几条桥。

解题思路：

　　这个题目有很多次操作，包含查询和删边两类，首先想到的是连通分量加缩点。如果按照顺序来，删边时候求桥就是问题了。所以可以离线处理，然后一边记录答案一边加边缩点。

　　对于一个图，把连通分量缩成一个点后，这个图就成为了一棵树， 然后深度差就等于桥的数目。查询的时候对于(u, v)桥的数目等于(设定deep[x]为x的深度，LCA(x, y)为(x, y)的父节点) deep[u] + deep[v] - 2 * deep[LCA(u, v)];

　　现在问题就成了怎么才能更快的缩点和维护点的深度。

　　缩点问题：在树上加上一条边就会形成一个环，然后这个环(强连通分量)上点就会被缩成一个点，然后用并查集来维护强联通分量，每次只需要合并父节点(每个点只能被缩一次，复杂度被平摊还是很可观的)。

　　维护节点深度：每次儿子节点合并到父亲节点的时候，儿子节点的子孙节点的深度都要减一。在这里我们可以用dfs序 + 树状数组来维护节点的深度。利用树状数组的区间更改点查询优化维护深度的操作。

　　还有最后一个问题就是计算(u, v)节点之间桥数目的时候，需要用到LCA，可以利用树上倍增LCA来优化时间复杂度。

这个题目还是很值得本扎扎练手的，考察了很多东西，真是把压箱底的东西都翻出来晒了晒，仰慕当场ac的聚聚们。

 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 const int maxn = ;
 const int N = ;
 const int M = ;

 struct node
 {
     int to, del;
     node(int x):to(x),del() {}
     bool operator < (const node & a) const
     {
         if (to != a.to) return to < a.to;
         return del > a.del;
     }
 };
 vector <node> vec[maxn];

 struct Query
 {
     int op, u, v;
     void read ()
     {
         scanf ("%d %d %d", &op, &u, &v);
         if (op == )
         {
             lower_bound (vec[u].begin(), vec[u].end(), node(v)) -> del = true;
             lower_bound (vec[v].begin(), vec[v].end(), node(u)) -> del = true;
         }
     }
 } query[N];

 int n, m, q;

 void init ()
 {
     for (int i=; i<=n; i++)
         vec[i].clear();
 }

 struct bit_tree
 {
     int tree[maxn];

     void init()
     {
         memset (tree, , sizeof(tree));
     }

     int lowbit (int x)
     {
         return x & (-x);
     }

     void change (int x, int num)
     {
         while (x <= n)
         {
             tree[x] += num;
             x += lowbit (x);
         }
     }

     void update (int x, int y, int num)
     {
         change (x, num);
         change (y+, -num);
     }

     int query (int x)
     {
         int res = ;
         while (x)
         {
             res += tree[x];
             x -= lowbit (x);
         }
         return res;
     }

 }Bit_tree;

 int begin_id[maxn], end_id[maxn], deep[maxn], ntime;
 int fa[maxn][M];
 void dfs (int u, int father, int dep)
 {
     if (father > )
         vec[u].erase (lower_bound(vec[u].begin(), vec[u].end(), node(father)));

     fa[u][] = father;
     begin_id[u] = ++ntime;
     deep[u] = dep;

     for (int i=; i<vec[u].size(); i++)
     {
         node p = vec[u][i];
         if (p.del || begin_id[p.to]) continue;
         vec[u][i].del = true;
         dfs (p.to, u, dep+);
     }

     end_id[u] = ntime;
     Bit_tree.update (begin_id[u], end_id[u], );
 }

 struct Lca
 {
     void init ()
     {
         for (int i=; i<M; i++)
             for (int j=; j<=n; j++)
                 fa[j][i] = fa[fa[j][i-]][i-];
     }

     int lca (int u, int v)
     {
         if (deep[u] < deep[v])   swap (u, v);
         int num = deep[u] - deep[v];
         for (int i=; i<M; i++)
             if ((<<i) & num)   u = fa[u][i];
         if (u == v) return u;
         for (int i=M-; i>=; i--)
             if (fa[u][i] != fa[v][i])
             {
                 u = fa[u][i];
                 v = fa[v][i];
             }
         return fa[u][];
     }

 }LCA;

 int father[maxn];
 struct UNion
 {
     void init()
     {
         for (int i=; i<=n; i++)
             father[i] = i;
     }

     int find (int x)
     {
         if (x != father[x]) father[x] = find (father[x]);
         return father[x];
     }

     void merge_fa (int x, int y)
     {
         x = find (x);
         while (x != y)
         {
             int t = find(fa[x][]);
             father[x] = t;
             Bit_tree.update(begin_id[x], end_id[x], -);
             x = t;
         }
     }

     void merge (int x, int y)
     {
         int l = find (LCA.lca (x, y));
         merge_fa (x, l);
         merge_fa (y, l);
     }

 }Union;

 int ans[N], res;
 void solve ()
 {
     Bit_tree.init ();
     ntime = res = ;
     memset (begin_id, , sizeof(begin_id));
     dfs (, , );
     LCA.init ();
     Union.init();

     for (int i=; i<=n; i++)
     {
         for (int j=; j<vec[i].size(); j++)
         {
             node p = vec[i][j];
             if (p.del)  continue;
             Union.merge (p.to, i);
         }
     }

     for (int i=q; i>; i--)
     {
         Query p = query[i];
         int u = begin_id[p.u];
         int v = begin_id[p.v];
         int x = begin_id[LCA.lca(p.u, p.v)];
         if (p.op == )
             Union.merge(p.u, p.v);
         else
             ans[++ res] = Bit_tree.query(u) + Bit_tree.query(v) - *Bit_tree.query(x);
     }

     while(res)
         printf ("%d\n", ans[res --]);
 }

 int main ()
 {
     int t, u, v;
     scanf ("%d", &t);

     for (int i=; i<=t; i++)
     {
         scanf("%d %d %d", &n, &m, &q);
         init ();

         for (int j=; j<m; j++)
         {
             scanf ("%d %d", &u, &v);
             vec[u].push_back (node(v));
             vec[v].push_back (node(u));
         }

         for (int j=; j<=n; j++)
             sort (vec[j].begin(), vec[j].end());

         for (int j=; j<=q; j++)
             query[j].read();

         printf ("Case #%d:\n", i);
         solve ();

     }
     return ;
 }