HDU 5458 Stability (树链剖分+并查集+set)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5458

给你n个点，m条边，q个操作，操作1是删边，操作2是问u到v之间的割边有多少条。

这题要倒着做才容易，倒着加边。

因为这题最后保证所有的点一定连通，所以可以构建一棵树，树链剖分一下。要是u到v之间只有一条边，那便是一条割边。而加边的话，就是将u到v之间的边权都+1，边权等于1的话是桥，大于1的话就不是了。所以我们初始化树的时候，可以将边权初始化为1，加边操作将边权赋值为0。求u到v的割边个数的话，就是求u到v的和。

中间存边我用multiset( map 超时)，然后用并查集判断是不是一棵完整的树从而看情况加边。

 //#pragma comment(linker, "/STACK:102400000, 102400000")
 #include <algorithm>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <vector>
 #include <cmath>
 #include <ctime>
 #include <list>
 #include <set>
 #include <map>
 using namespace std;
 typedef long long LL;
 typedef pair <int, int> P;
 const int N = 1e5 + ;
 struct Edge {
     int next, to;
 }edge[N << ];
 multiset <P> myset; //存 构建的树的边
 int head[N], tot;
 int pre[N], son[N], dep[N], size[N], cnt; //son:重儿子
 int top[N], id[N];
 int uu[N], vv[N], c[N]; //q个操作c uu vv
 int x[N], y[N]; //开始输入的m条边x y
 int ans[N]; //答案
 int par[N]; //并查集

 void init(int n) {
     for(int i = ; i <= n; ++i) {
         par[i] = i;
         head[i] = -;
     }
     tot = cnt = ;
     myset.clear();
 }

 inline void add(int u, int v) {
     edge[tot].next = head[u];
     edge[tot].to = v;
     head[u] = tot++;
 }

 inline int search(int n) {
     if(n == par[n])
         return n;
     return par[n] = search(par[n]);
 }

 void dfs1(int u, int p, int d) {
     dep[u] = d, size[u] = , son[u] = u, pre[u] = p;
     for(int i = head[u]; ~i; i = edge[i].next) {
         int v = edge[i].to;
         if(v == p)
             continue;
         dfs1(v, u, d + );
         if(size[v] >= size[son[u]])
             son[u] = v;
         size[u] += size[v];
     }
 }

 void dfs2(int u, int p, int t) {
     top[u] = t, id[u] = ++cnt;
     if(son[u] != u)
         dfs2(son[u], u, t);
     for(int i = head[u]; ~i; i = edge[i].next) {
         int v = edge[i].to;
         if(v == p || v == son[u])
             continue;
         dfs2(v, u, v);
     }
 }

 struct SegTree {
     int l, r, val, lazy, mid;
 }T[N << ];

 void build(int p, int l, int r) {
     T[p].mid = (l + r) >> ;
     T[p].l = l, T[p].r = r, T[p].lazy = ;
     if(l == r) {
         T[p].val = ;
         return ;
     }
     build(p << , l, T[p].mid);
     build((p << )|, T[p].mid + , r);
     T[p].val = T[p << ].val + T[(p << )|].val;
 }

 inline void pushdown(int p) {
     int ls = p << , rs = (p << )|;
     T[ls].lazy = T[rs].lazy = T[ls].val = T[rs].val = ;
     T[p].lazy = ;
 }

 void update(int p, int l, int r) {
     if(T[p].val == )
         return ;
     if(T[p].l == l && T[p].r == r) {
         T[p].lazy = T[p].val = ;
         return ;
     }
     if(!T[p].lazy) {
         pushdown(p);
     }
     if(r <= T[p].mid) {
         update(p << , l, r);
     }
     else if(l > T[p].mid) {
         update((p << )|, l, r);
     }
     else {
         update(p << , l, T[p].mid);
         update((p << )|, T[p].mid + , r);
     }
     T[p].val = T[p << ].val + T[(p << )|].val;
 }

 int query(int p, int l, int r) {
     if(T[p].val == )
         return ;
     if(T[p].l == l && T[p].r == r) {
         return T[p].val;
     }
     if(!T[p].lazy) {
         pushdown(p);
     }
     if(r <= T[p].mid) {
          return query(p <<  , l , r);
      }
      else if(l > T[p].mid) {
          return query((p << )| , l , r);
      }
      else {
          return query(p <<  , l , T[p].mid) + query((p << )| , T[p].mid +  , r);
      }
 }

 void change(int u, int v) {
     int fu = top[u], fv = top[v];
     while(fu != fv) {
         if(dep[fu] >= dep[fv]) {
             update(, id[fu], id[u]);
             u = pre[fu];
             fu = top[u];
         }
         else {
             update(, id[fv], id[v]);
             v = pre[fv];
             fv = top[v];
         }
     }
     if(u == v)
         return ;
     else if(dep[u] >= dep[v])
         update(, id[son[v]], id[u]);
     else
         update(, id[son[u]], id[v]);
 }

 int find(int u, int v) {
     int fu = top[u], fv = top[v], res = ;
     while(fu != fv) {
         if(dep[fu] >= dep[fv]) {
             res += query(, id[fu], id[u]);
             u = pre[fu];
             fu = top[u];
         }
         else {
             res += query(, id[fv], id[v]);
             v = pre[fv];
             fv = top[v];
         }
     }
     if(u == v)
         return res;
     else if(dep[u] >= dep[v])
         return res + query(, id[son[v]], id[u]);
     else
         return res + query(, id[son[u]], id[v]);
 }

 int main()
 {
     int t, n, m, q, u, v;
     scanf("%d", &t);
     for(int ca = ; ca <= t; ++ca) {
         scanf("%d %d %d", &n, &m, &q);
         init(n);
         for(int i = ; i <= m; ++i) {
             scanf("%d %d", x + i, y + i);
             if(x[i] > y[i])
                 swap(x[i], y[i]);
             myset.insert(make_pair(x[i], y[i])); //先存边
         }
         for(int i = ; i <= q; ++i) {
             scanf("%d %d %d", c + i, uu + i, vv + i);
             if(uu[i] > vv[i])
                 swap(uu[i], vv[i]);
             if(c[i] == ) {
                 auto pos = myset.find(make_pair(uu[i], vv[i])); //去除要删的边
                 myset.erase(pos);
             }
         }
         int f = ;
         for(auto i = myset.begin(); i != myset.end(); ++i) {
             u = search(i->first), v = search(i->second);
             if(u == v) { //不成环
                 ++f;
                 x[f] = i->first, y[f] = i->second; //此时的x y存的是非树也非删的边
                 continue;
             }
             par[u] = v;
             add(i->first, i->second);
             add(i->second, i->first);
         }
         dfs1(, -, );
         dfs2(, -, );
         printf("Case #%d:\n", ca);
         build(, , n);
         for(int i = ; i <= f; ++i) {
             change(x[i], y[i]);
         }
         f = ;
         for(int i = q; i >= ; --i) {
             if(c[i] == ) {
                 change(uu[i], vv[i]);
             }
             else {
                 ans[++f] = find(uu[i], vv[i]);
             }
         }
         for(int i = f; i >= ; --i) {
             printf("%d\n", ans[i]);
         }
     }
     return ;
 }

写的我比较头痛，调试了比较久...