Description
给出一个 n n 个点条边的无向图,无重边无自环两种操作
1 u v: 1 u v : 在 u,v u , v 之间加一条边
2 u v: 2 u v : 查询 u u 到的路径上割边数量
Input
第一行输入一整数 T T 表示用例组数,每组用例首先输入两个整数表示点数和边数,之后 m m 行每行输入两个整数表示一条无向边,之后输入一整数 q q 表示操作数,最后行每行一个操作 (1≤n,m,q≤105) ( 1 ≤ n , m , q ≤ 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 u 到的路径上割边数量即为 u u 所在连通块到所在连通块在由连通块构成的树上的距离,也即两点所在连通块在树上的深度减去二倍的其 LCA L C A 的深度,首先对原图建一棵生成树,初始边权均为 1 1 ,加边时,记 u,v u , v 的 LCA L C A 为 t t ,则加边操作对边权的影响相当于把到 t t 路径上的边的边权以及从到 t t 路径上的边的边权变为,也即对这两条路径上的所有点,让其子树上所有点的深度减一,对该树树链剖分以便求 LCA L C A ,同时得到每个点的 dfs d f s 序 l[x],r[x] l [ x ] , r [ x ] ,则 [l[x],r[x]] [ l [ x ] , r [ x ] ] 即表示以 x x 为根的子树节点序编号范围,如果 x x 点在这两条路径上,那么要对区间上点的深度均减一,用树状数组维护该变动,同时注意到一条边的边权可能被多次变成 0 0 ,第一次更新后之后的更新没有意义,故用并查集维护边的连通关系(由于是树,等价与维护点的连通关系),每次从一个连通块跳到另一个连通块更新,这样每条边至多被更新一次,查询的时候,先在树状数组中得到深度的改变值,加上其原先深度即为如今的真实值,进而得到答案
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;
}