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 + 5;
struct Edge {
    int next, to;
}edge[N << 1];
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 = 1; i <= n; ++i) {
        par[i] = i;
        head[i] = -1;
    }
    tot = cnt = 0;
    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] = 1, 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 + 1);
        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 << 2];

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

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

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

int query(int p, int l, int r) {
    if(T[p].val == 0)
        return 0;
    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 << 1 , l , r);
     }
     else if(l > T[p].mid) {
         return query((p << 1)|1 , l , r);
     }
     else {
         return query(p << 1 , l , T[p].mid) + query((p << 1)|1 , T[p].mid + 1 , r);
     }
}

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

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

int main()
{
    int t, n, m, q, u, v;
    scanf("%d", &t);
    for(int ca = 1; ca <= t; ++ca) {
        scanf("%d %d %d", &n, &m, &q);
        init(n);
        for(int i = 1; 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 = 1; 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] == 1) {
                auto pos = myset.find(make_pair(uu[i], vv[i])); //去除要删的边
                myset.erase(pos);
            }
        }
        int f = 0;
        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(1, -1, 0);
        dfs2(1, -1, 1);
        printf("Case #%d:\n", ca);
        build(1, 2, n);
        for(int i = 1; i <= f; ++i) {
            change(x[i], y[i]);
        }
        f = 0;
        for(int i = q; i >= 1; --i) {
            if(c[i] == 1) {
                change(uu[i], vv[i]);
            }
            else {
                ans[++f] = find(uu[i], vv[i]);
            }
        }
        for(int i = f; i >= 1; --i) {
            printf("%d\n", ans[i]);
        }
    }
    return 0;
}

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