hdu5458 2015沈阳赛区网络赛 树链剖分+并查集

题意:给你个图，然后给你m条边，然后有两种操作，第一种是1，删除两个点之间的一条边，第二种是2，问两个点之间的稳定性（稳定性的定义是删除一条边后这两个点就会不连通，这样的边有多少条它的稳定性就是多少，如果这样的边有无数条的话那么就是0），题目保证删到最后这个图也是连通的。

思路:一开始我想的是如果两个点是一个连通块里的两个点肯定是稳定性是0，然后不在一个连通块里的点的稳定性就是缩点后两个点的路径长度。然后每挨着删一些边都缩一下点，每挨着查询一些点对都用lca求一边路径长。但是这样做铁定会超时，学长想了一会儿给我否了，然后给了我一个思路，说让我倒着写，先建一棵树，然后倒着加边，而不是正着删边，给这棵树的每条边一个权值1.通过1操作每加一条边都会形成一个环（连通块）,使得这个连通块上的边的权值变为0，即两个点的路径上的边的权值变为0，意思就是说这条边是一个块里的边，缩点后是不会对路径长度有贡献的，所以置0；查询的时候直接统计两个点路径的权值和就可以了。

当时不太会写树链剖分，不会对两点之间的路径进行操作，今天花了一上午+一晚上的时间学习了一下树链剖分的原理跟写法，算是弄懂了，这道题也就当作模板了。

另外，这道题的mian里的内容是参考（粘贴）网上一篇博客的写法(太懒了，不想自己写了)。

还有就是这道题是对树的边进行操作，也就是说我们要把边的权值搞到这条边深度较大的那个点上，然后进行统计。就涉及到了修改查询里的这么一句话，就是两个点通过往上挪移后靠在了一条重链后的一次操作：

update(tid[x]+1,tid[y],1,tim,1);

ans+=Query(tid[x]+1,tid[y],1,tim,1);

tid[x]+1是x点下面的那个点，其实就相当于tid[son[x]].重链上点的编号是连续的且从小到大的，这样写就可以实现边权操作了。不明白的就自己画图想一想。`

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include<set>
#include<stdlib.h>
#define maxm 100005
#define maxn  30005
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

struct E
{
    int a,b;
    E() {}
    E(int aa,int bb):a(aa),b(bb) {}
    bool operator < (const E &c) const
    {
        if(a == c.a)
        {
            return b < c.b;
        }
        return a < c.a;
    }
};

struct Edge
{
    int v,next;
} edge[maxn<<2];

int siz[maxn],top[maxn],son[maxn];
int dep[maxn],tid[maxn],fa[maxn];
int head[maxn],cnt;
int sum[maxn<<2];
int lazy[maxn<<2];

struct node
{
    int kind,a,b,val;
};
node ans[maxm];

int n,m,q;
int tim;
int father[maxn];

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

multiset<E> S;
multiset<E> V;

void init()
{
    memset(head,-1,sizeof(head));
    memset(sum,0,sizeof(sum));
    for(int i=1; i<=n; i++)
        father[i]=i;
    S.clear();
    V.clear();
    tim=0;
    cnt=0;
}

void add(int a, int b)
{
    edge[cnt].v = b;
    edge[cnt].next = head[a];
    head[a] = cnt++;
}
//树链剖分部分
//siz[]数组，用来保存以x为根的子树节点个数
//top[]数组，用来保存当前节点的所在链的顶端节点
//son[]数组，用来保存重儿子
//dep[]数组，用来保存当前节点的深度
//fa[]数组，用来保存当前节点的父亲
//tid[]数组，用来保存树中每个节点剖分后的新编号
//Rank[]数组，用来保存当前节点在线段树中的位置
void dfs1(int u,int father,int d)
{
    dep[u]=d;
    fa[u]=father;
    siz[u]=1;
    son[u]=-1;
    for(int i=head[u]; ~i; i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==father) continue;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(son[u]==-1||siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++tim;
  //  Rank[tid[u]]=u;
    if(son[u]!=-1)
        dfs2(son[u],tp);
    for(int i=head[u]; ~i; i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==son[u]||v==fa[u]) continue;
            dfs2(v,v);
    }
}
//线段树部分
void pushup(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

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

void Change(int x,int y)
{
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(tid[top[x]],tid[x],1,tim,1);
        x=fa[top[x]];
    }
    if(x==y) return;
    if(dep[x]>dep[y]) swap(x,y);
    update(tid[x]+1,tid[y],1,tim,1);
}

int query(int x,int y)
{
    int ans=0;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);//保证x的top更深
        ans+=Query(tid[top[x]],tid[x],1,tim,1);//查询深的链，
        x=fa[top[x]];
    }
    if(x==y) return ans;
    if(dep[x]>dep[y]) swap(x,y);//保证x更浅
    ans+=Query(tid[x]+1,tid[y],1,tim,1);
    return ans;
}

int main()
{
    int t;
    int cas=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&q);
        init();
        for(int i=1;i<=m;i++)
        {
            E tmp;
            scanf("%d%d",&tmp.a,&tmp.b);
            if(tmp.a > tmp.b) swap(tmp.a,tmp.b);
            S.insert(tmp);
        }
        for(int i=1; i<=q; i++)
        {
            scanf("%d%d%d",&ans[i].kind,&ans[i].a,&ans[i].b);
            if(ans[i].a > ans[i].b) swap(ans[i].a,ans[i].b);
            //查询过程中删除的边先都删掉
            if(ans[i].kind == 1)
            {
                E tmp;
                tmp.a=ans[i].a,tmp.b=ans[i].b;
                multiset<E>::iterator Pos = S.find(tmp);
                S.erase(Pos);
            }
        }
        //从剩下的边中选出一棵树来，用并查集判断成不成环
        for(multiset<E>::iterator It = S.begin(); It != S.end(); ++It)
        {
            if(find_fa(It->a) != find_fa(It->b))
            {
                father[find_fa(It->a)] = find_fa(It->b);
                V.insert(*It);
            }
        }
        for(multiset<E>::iterator It = V.begin(); It != V.end(); ++It)
        {
            add(It->a,It->b);
            add(It->b,It->a);
        }
        dfs1(1,0,0);
        dfs2(1,1);
        build(1,tim,1);
        //S中剩下的边先更新了
        for(multiset<E>::iterator It = S.begin(); It != S.end(); ++It)
            if(V.find(*It) == V.end())
            {
                Change(It->a,It->b);
            }
        //q个询问一次更新查询即可
        for(int i=q;i>=1;i--)
        {
            if(ans[i].kind == 1)
                Change(ans[i].a,ans[i].b);
            else if(ans[i].kind == 2)
                ans[i].val = query(ans[i].a,ans[i].b);
        }
        printf("Case #%d:\n",cas++);
        for(int i=1; i<=q; i++)
            if(ans[i].kind == 2)
                printf("%d\n",ans[i].val);
    }
    return 0;
}