HDU 6200 mustedge mustedge mustedge（树链剖分LCA+并查集+BIT）

Description

给出一个$n$个点$m$条边的无向图，无重边无自环两种操作

$1\ u\ v:$在$u,v$之间加一条边

$2\ u\ v:$查询$u$到$v$的路径上割边数量

Input

第一行输入一整数$T$表示用例组数，每组用例首先输入两个整数$n,m$表示点数和边数，之后$m$行每行输入两个整数$u,v$表示一条无向边，之后输入一整数$q$表示操作数，最后$q$行每行一个操作 $(1\le n,m,q\le 10^5)$

Output

对于每个查询，输出结果

Sample Input

2
4 3
1 2
2 3
3 4
5
2 1 4
1 2 3
2 1 4
2 2 3
2 2 4
8 9
1 2
2 3
1 3
3 4
4 5
4 6
5 7
5 8
7 8
5
2 7 8
2 1 6
2 4 7
1 6 8
2 5 6

Sample Output

Case #1:
3
2
0
1
Case #2:
0
2
1
0

Solution

$u$到$v$的路径上割边数量即为$u$所在连通块到$v$所在连通块在由连通块构成的树上的距离，也即两点所在连通块在树上的深度减去二倍的其$LCA$的深度，首先对原图建一棵生成树，初始边权均为$1$，加边$u\leftrightarrow v$时，记$u,v$的$LCA$为$t$，则加边操作对边权的影响相当于把$u$到$t$路径上的边的边权以及从$v$到$t$路径上的边的边权变为$0$，也即对这两条路径上的所有点，让其子树上所有点的深度减一，对该树树链剖分以便求$LCA$，同时得到每个点的$dfs$序$l[x],r[x]$，则$[l[x],r[x]]$即表示以$x$为根的子树节点$dfs$序编号范围，如果$x$点在这两条路径上，那么要对区间$[l[x],r[x]]$上点的深度均减一，用树状数组维护该变动，同时注意到一条边的边权可能被多次变成$0$，第一次更新后之后的更新没有意义，故用并查集维护边的连通关系（由于是树，等价与维护点的连通关系），每次从一个连通块跳到另一个连通块更新，这样每条边至多被更新一次，查询的时候，先在树状数组中得到$u,v,t$深度的改变值，加上其原先深度即为如今的真实值，进而得到答案

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
namespace fastIO 
{
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror=0;
    inline char nc() 
    {
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if(p1==pend) 
        {
            p1=buf;
            pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if(pend==p1) 
            {
                IOerror=1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) 
    {
        return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';
    }
    inline void read(int &x) 
    {
        char ch;
        while(blank(ch=nc()));
        if(IOerror)return;
        for(x=ch-'0';(ch=nc())>='0'&&ch<='9';x=x*10+ch-'0');
    }
    #undef BUF_SIZE
};
using namespace fastIO;
#define maxn 100005
struct BIT 
{
    #define lowbit(x) (x&(-x))
    int b[maxn],n;
    void init(int _n)
    {
        n=_n;
        for(int i=1;i<=n;i++)b[i]=0;
    }
    void update(int x,int v)
    {
        while(x<=n)
        {
            b[x]+=v;
            x+=lowbit(x);
        }
    }
    int query(int x)
    {
        int ans=0;
        while(x)
        {
            ans+=b[x];
            x-=lowbit(x);
        }
        return ans;
    }
}bit;
struct Edge
{
    int to,next;
}edge[2*maxn];
int head[maxn],tot;
int idx,size[maxn],fa[maxn],son[maxn],dep[maxn],top[maxn],l[maxn],r[maxn];
void add(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void dfs1(int u)
{
    size[u]=1;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v!=fa[u]) 
        {
            fa[v]=u;
            dep[v]=dep[u]+1;
            dfs1(v);
            size[u]+=size[v];
            if(size[son[u]]<size[v])son[u]=v;
        }
    }
}
void dfs2(int u,int topu)
{
    top[u]=topu;
    l[u]=++idx;
    if(son[u]) dfs2(son[u],top[u]); 
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v!=fa[u]&&v!=son[u]) dfs2(v,v);
    }
    r[u]=idx;
}
int lca(int u,int v)
{
    int top1=top[u],top2=top[v];
    while(top1!=top2)
    {
        if(dep[top1]<dep[top2])
        {
            swap(top1,top2);
            swap(u,v);
        }
        u=fa[top1];
        top1=top[u];
    }
    return dep[u]<dep[v]?u:v;
}
int ff[maxn];
int find(int x)
{
    if(ff[x]==x)return x;
    return ff[x]=find(ff[x]);
}
void Deal(int u,int t)
{
    u=find(u);
    int v=fa[u];
    while(dep[v]>=dep[t])
    {
        bit.update(l[u],-1),bit.update(r[u]+1,1);
        ff[u]=v;
        u=find(v);
        v=fa[u];
    }
}
int T,n,m,q,e[maxn][2],vis[maxn],Case=1;
int main()
{
    read(T);//scanf("%d",&T);
    while(T--)
    {
        read(n);read(m);//scanf("%d%d",&n,&m);
        bit.init(n);
        idx=tot=0;
        dep[1]=1,fa[1]=0;
        for(int i=1;i<=n;i++)son[i]=0,head[i]=-1,ff[i]=i;
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=m;i++)read(e[i][0]),read(e[i][1]);//scanf("%d%d",&e[i][0],&e[i][1]);
        int cnt=0;
        for(int i=1;i<=m;i++)
        {
            int u=find(e[i][0]),v=find(e[i][1]);
            if(u!=v)
            {
                add(e[i][0],e[i][1]),add(e[i][1],e[i][0]);
                ff[u]=v,vis[i]=1,cnt++;
                if(cnt==n-1)break;
            }
        }
        dfs1(1);
        dfs2(1,1);
        for(int i=1;i<=n;i++)ff[i]=i;
        for(int i=1;i<=m;i++)
            if(!vis[i])
            {
                int t=lca(e[i][0],e[i][1]);
                Deal(e[i][0],t),Deal(e[i][1],t);
            }
        read(q);//scanf("%d",&q);
        printf("Case #%d:\n",Case++);
        while(q--)
        {
            int op,u,v;
            read(op),read(u),read(v);//scanf("%d%d%d",&op,&u,&v);
            if(op==1)
            {
                int t=lca(u,v);
                Deal(u,t),Deal(v,t);
            }
            else
            {
                int t=lca(u,v);
                int d1=dep[u]+bit.query(l[u]),d2=dep[v]+bit.query(l[v]),d3=dep[t]+bit.query(l[t]);
                printf("%d\n",d1+d2-2*d3);
            }
        }
    }
    return 0;
}