HDU 5458（树链剖分）

(http://acm.hust.edu.cn/vjudge/contest/view.action?cid=106364#problem/B)
题意：给一个无向图，两种操作，删除一条边，询问两点之间关键路径的数目。
关键路径，即删除这条边，两点就不联通了。保证图一直联通。
解法：先在最后的图上跑一颗生成树。每有一条其他的边，就对路径上的所有边+1。所以就存在两种操作，对某一段-1，查询某一段上0的个数，就可以用线段树做了。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <queue>
//#include <tr1/unordered_set>
#include <tr1/unordered_map>
#include <bitset>
//#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define inf 1e9
#define debug(a) cout << #a" = " << (a) << endl;
#define debugarry(a, n) for (int i = 0; i < (n); i++) { cout << #a"[" << i << "] = " << (a)[i] << endl; }
#define clr(x, y) memset(x, y, sizeof x)
#define ll long long
#define ull unsigned long long
#define FOR(i,a,b) \
    for(i=a;a<b?i<=b:i>=b;a<b?i++:i--)

const int maxn = 1e5+30;
struct sad{
    int to,next;
}G[maxn<<1];
int h[maxn],si;
void add(int u,int v){
    G[si].to = v;
    G[si].next = h[u];
    h[u] = si++;
}
int siz[maxn] , dep[maxn];
int fa[maxn] , son[maxn] , top[maxn];

int vis[maxn];
map<ll,int>us;
ll Hash(int u,int v){
    return (ll)min(u,v)*maxn+max(u,v);
}

void dfs1(int u,int f,int d)
{
//  printf("u %d f %d\n",u,f);
    vis[u] = 1;
    fa[u] = f;
    dep[u] = d;
    siz[u] = 1;
    son[u] = -1;
    for(int i=h[u];~i;i=G[i].next)
    {
        int v=G[i].to;
        if( us[Hash(u,v)] == 0 ) continue;
        if(!vis[v])
        {
            us[Hash(u,v)]--;
            dfs1(v,u,d+1);
            siz[u] += siz[v];
            if(son[u]==-1||siz[son[u]]<siz[v])
                son[u]=v;
        }
    }
}
int p[maxn],fp[maxn],pos;
void dfs2(int u,int sf)
{
    top[u]=sf;
    p[u]=pos++;
    fp[p[u]]=u;
    if(son[u]==-1) return ;
    dfs2(son[u],sf);
    for(int i=h[u];~i;i=G[i].next){
        int v=G[i].to;
        if(fa[v]==u&&v!=son[u])
            dfs2(v,v);
    }
}

int mi[maxn<<2],rs[maxn<<2],col[maxn<<2];
void pushup(int rt)
{
    mi[rt] = min(mi[rt<<1],mi[rt<<1|1]);
    rs[rt] = 0;
    if( mi[rt<<1] == mi[rt] ) rs[rt] += rs[rt<<1];
    if( mi[rt<<1|1] == mi[rt] ) rs[rt] += rs[rt<<1|1];
}
void pushdown(int rt)
{
    if(col[rt])
    {
        mi[rt<<1] += col[rt];
        col[rt<<1] += col[rt];
        mi[rt<<1|1] += col[rt];
        col[rt<<1|1] += col[rt];
        col[rt]=0;
    }
}
void build(int l,int r,int rt)
{
    col[rt] = 0;
    if( l == r ){
        mi[rt] = 0;
        rs[rt] = 1;
        return ;
    }
    int m=l+r>>1;
    build(lson);
    build(rson);
    pushup(rt);
}

void update(int L,int R,int d,int l,int r,int rt)
{
    if( L > R || L < 1 || R > pos )
        while(1);
    if( L <= l && r <= R )
    {
        col[rt] += d;
        mi[rt] += d;
        return ;
    }
    pushdown(rt);
    int m=l+r>>1;
    if( L <= m ) update(L,R,d,lson);
    if( m < R ) update(L,R,d,rson);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
    if( L > R || L < 1 || R > pos )
        while(1);
    if(L <= l && r <= R) return mi[rt]==0?rs[rt]:0;
    pushdown(rt);
    int m=l+r>>1,ret=0;
    if( L <= m ) ret += query(L,R,lson);
    if( m < R ) ret += query(L,R,rson);
    return ret;
}

int Query(int u,int v)
{
    int ret = 0,f1=top[u] ,f2 = top[v];
    while(f1 != f2)
    {
        if(dep[f1]<dep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        ret += query(p[f1],p[u],1,pos-1,1);
        u=fa[f1];
        f1=top[u];
    }
    if(u==v) return ret;
    if( dep[u] > dep[v] ) swap(u,v);
    ret += query(p[son[u]],p[v],1,pos-1,1);
    return ret;
}

void Change(int u,int v,int d)
{
//  printf("u %d v %d d %d\n",u,v,d);
    int f1=top[u] ,f2 = top[v];
    while(f1!=f2)
    {
        if(dep[f1]<dep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        update(p[f1],p[u],d,1,pos-1,1);
        u=fa[f1];
        f1=top[u];
    }
    if(u==v) return ;
    if( dep[u] > dep[v] ) swap(u,v);
    update(p[son[u]],p[v],d,1,pos-1,1);
}

void init()
{
    clr(h,-1);
    si=0;
    pos=1;
}

int a[maxn],b[maxn],c[maxn];

int main()
{
    //freopen("input.txt","r",stdin);
    int T,n,m,q,CASE=0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&q);
        init();
        clr(vis,0);
        us.clear();
        int u,v;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            if( us.count(Hash(u,v)) == 0 )
                us[Hash(u,v)] = 0;
            us[Hash(u,v)]++;
            add(u,v);
            add(v,u);
        }
        for(int i=0;i<q;i++)
        {
            scanf("%d%d%d",&a[i],&b[i],&c[i]);
            if(a[i]==1) us[Hash(b[i],c[i])]--;
        }
        dfs1(1,-1,1);
        dfs2(1,1);
        build(1,pos-1,1);
        for(int u=1;u<=n;u++)
        {
            for(int i=h[u];~i;i=G[i].next)
            {
                int v=G[i].to;
                while( us[Hash(u,v)] )
                {
                    Change(u,v,1);
                    us[Hash(u,v)]--;
                }
            }
        }
        printf("Case #%d:\n",++CASE);
        vector<int>ans;
        for(int i=q-1;i>=0;i--)
        {
            if(a[i]==1)
                Change(b[i],c[i],1);
            else
                ans.push_back(Query(b[i],c[i]));
        }
        for(int i=ans.size()-1;i>=0;i--)
            printf("%d\n",ans[i]);
    }
    return 0;
}