HDU 5458 Stability (2015 ACM/ICPC Asia Regional Shenyang Online)

题目分析

这道题真的不是很好写，树链剖分本来就是个很恶心的东西，这个程序里面还要倒着来，调bug调了一上午发现自己的while写成了if。整个人都不好了，不过也还好，才一上午。树链剖分可以处理2点之间路径上的一些东西，而且速度很快，本题也不例外，同样是处理这些东西。因为最初给你一些边，但是这些边组成的图可能不是一棵树因此没有办法做树链剖分，很明显我们要想办法将图转化为树，这道题我们首先将所有边塞到一个multiset中，因为这个集合允许存放相同元素，然后我们将Q个操作同时存到一个结构体中，如果该操作是删除操作，那么我们就从multiset中删除对应的边，因为题目已经说了无论如何删除总是保证剩下的边将所有节点连接起来（即构成一棵树）。因为对于删除后的multiset中找出一些边建立一棵树，很明显用并查集再好不过了，它还可以保证不会存在环。这样我们就可以进行树链剖分了。我们将multiset中剩下的边找出来。如果边为a到b，很明显我们就讲a到b路径上的所有边变为0，为什么呢，因为这个时候a到b路径上所有点均有2条路径可以互相达到，这时候2点之间所有点的stablity肯定就是0了。就这样我们再对所有操作进行逆向操作，如果删除了一条边，很明显我们需要加入一条边，如果为查找操作那么我们就对当前树的情况进行查找，然后用stack存一下，这个一点也不难。还有一点就是线段树维护的时候可以不用pushdown操作了，一旦遇到lazy有值直接返回就可以了，这样查找效率会更高。还有一点我想说一下，如果你的multiset中使用到了结构体，那么一定要重载小于运算符，但是因为pair已经重载了小于运算符，因此我的程序中就少了这一步。

#include <set>
#include <stack>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 30005;
const int maxm = 100005;
#define mid (L+R)/2
#define lson o<<1, L, mid
#define rson o<<1|1, mid+1, R
typedef pair<int,int> PII;

multiset <PII> M1,M2;
//线段树作查询用
int sum[maxn<<2],lazy[maxn<<2];

void build(int o,int L,int R){
    if(L == R){
        sum[o] = 1;
        return ;
    }
    build(lson);
    build(rson);
    sum[o] = sum[o<<1] + sum[o<<1|1];
}

void update(int o,int L,int R,int l,int r){
    if(lazy[o]) return ;
    if(l <= L && R <= r){
        lazy[o] = 1;
        sum[o] = 0;
        return ;
    }
    if(l <= mid) update(lson, l, r);
    if(r > mid) update(rson, l, r);
    sum[o] = sum[o<<1] + sum[o<<1|1];
}

int query(int o,int L,int R,int l,int r){
    if(lazy[o]) return 0;
    if(l <= L && R <= r){
        return sum[o];
    }
    int ret = 0;
    if(l <= mid) ret += query(lson, l, r);
    if(r > mid) ret += query(rson, l, r);
    return ret;
}

struct Edge{
    int to,next;
}e[maxm<<2];

int head[maxn],fa[maxn],siz[maxn],dep[maxn],son[maxn],top[maxn],w[maxn],cnt,tot;

void addedge(int from,int to){
    e[cnt].to = to;
    e[cnt].next = head[from];
    head[from] = cnt++;
}

void dfs1(int now){
    siz[now] = 1;
    son[now] = 0;
    for(int u = head[now]; u != -1; u = e[u].next){
        int v = e[u].to;
        if(v != fa[now]){
            dep[v] = dep[now]+1;
            fa[v] = now;
            dfs1(v);
            siz[now] += siz[v];
            if(siz[son[now]] < siz[v]) son[now] = v;
        }
    }
}

void dfs2(int now,int tp){
    w[now] = ++tot;
    top[now] = tp;
    if(son[now]) dfs2(son[now], top[now]);
    for(int u = head[now]; u != -1; u = e[u].next){
        int v = e[u].to;
        if(v != fa[now] && v != son[now])
            dfs2(v, v);
    }
}

void change(int a,int b){
    int f1 = top[a],f2 = top[b];
    while(f1 != f2){
        if(dep[f1] < dep[f2]){
            swap(f1, f2);
            swap(a, b);
        }
        update(1, 1, tot, w[f1], w[a]);
        a = fa[f1];
        f1 = top[a];
    }
    if(a == b) return;
    if(dep[a] > dep[b]) swap(a,b);
    update(1, 1, tot, w[son[a]], w[b]);
}

int solve(int a,int b){
    int f1 = top[a],f2 = top[b],ret = 0;
    while(f1 != f2){
        if(dep[f1] < dep[f2]){
            swap(f1, f2);
            swap(a, b);
        }
        ret += query(1, 1, tot, w[f1], w[a]);
        a = fa[f1];
        f1 = top[a];
    }
    if(a == b) return ret;
    if(dep[a] > dep[b]) swap(a,b);
    ret += query(1, 1, tot, w[son[a]], w[b]);
    return ret;
}

int father[maxn];

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

inline void init(){
    tot = cnt = 0;
    memset(dep, 0, sizeof(dep));
    memset(head, -1, sizeof(head));
    memset(fa, 0, sizeof(fa));
    memset(sum, 0, sizeof(sum));
    memset(lazy, 0, sizeof(lazy));
    memset(siz, 0, sizeof(siz));
    memset(son, 0, sizeof(son));
    for(int i = 0; i < maxn; i++) father[i] = i;
    M1.clear();
    M2.clear();
}

struct OP{
    int op,a,b;
}que[maxm];

int main(){
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++){
        init();
        int n,m,q,from,to;
        scanf("%d%d%d", &n, &m, &q);
        for(int i = 1; i <= m; i++){
            scanf("%d%d", &from, &to);
            if(from > to) swap(from, to);
            M1.insert(make_pair(from,to));
        }
        for(int i = 1; i <= q; i++){
            scanf("%d%d%d", &que[i].op, &que[i].a, &que[i].b);
            if(que[i].a > que[i].b) swap(que[i].a, que[i].b);
            if(que[i].op == 1){
                multiset<PII>::iterator it = M1.find(make_pair(que[i].a, que[i].b));
                M1.erase(it);
            }
        }
        for(multiset<PII>::iterator it = M1.begin(); it != M1.end(); it++){
            int xx = Find(it->first),yy = Find(it->second);
            if(xx != yy){
                addedge(it->first, it->second);
                addedge(it->second, it->first);
                father[xx] = yy;
                M2.insert(*it);
            }
        }
        dfs1(1);
        dfs2(1, 1);
        build(1, 1, tot);
        for(multiset<PII>::iterator it = M1.begin(); it != M1.end(); it++)
            if(M2.find(*it) == M2.end())
                change(it->first, it->second);
        stack <int> S;
        for(int i = q; i >= 1; i--){
            if(que[i].op == 1)
                change(que[i].a, que[i].b);
            else
                S.push(solve(que[i].a, que[i].b));
        }
        printf("Case #%d:\n", kase);
        while(!S.empty()){
            printf("%d\n", S.top());
            S.pop();
        }
    }
    return 0;
}