洛谷P7735 [NOI2021] 轻重边

题目描述

小 W 有一棵 𝑛n 个结点的树，树上的每一条边可能是轻边或者重边。接下来你需要对树进行 𝑚m 次操作，在所有操作开始前，树上所有边都是轻边。操作有以下两种：

1. 给定两个点 𝑎a 和 𝑏b，首先对于 𝑎a 到 𝑏b 路径上的所有点 𝑥x（包含 𝑎a 和 𝑏b），你要将与 𝑥x 相连的所有边变为轻边。然后再将 𝑎a 到 𝑏b 路径上包含的所有边变为重边。
2. 给定两个点 𝑎a 和 𝑏b，你需要计算当前 𝑎a 到 𝑏b 的路径上一共包含多少条重边。

输入格式

本题有多组数据，输入数据第一行一个正整数 𝑇T，表示数据组数。对于每组数据：

第一行包含两个整数 𝑛n 和 𝑚m，其中 𝑛n 表示结点数量，𝑚m 表示操作数量。

接下来 𝑛−1n−1 行，每行包含两个整数 𝑢 𝑣u v，表示树上的一条边。

接下来 𝑚m 行，每行包含三个整数 𝑜𝑝𝑖 𝑎𝑖 𝑏𝑖opi​ ai​ bi​，描述一个操作，其中 𝑜𝑝𝑖=1opi​=1 表示第 11 类操作，𝑜𝑝𝑖=2opi​=2 表示第 22 类操作。

数据保证 𝑎𝑖≠𝑏𝑖ai​=bi​。

输出格式

对于每一次第 22 类操作，输出一行一个整数表示答案。

输入输出样例

输入 #1

1
7 7
1 2
1 3
3 4
3 5
3 6
6 7
1 1 7
2 1 4
2 2 7
1 1 5
2 2 7
1 2 1
2 1 7

输出 #1

1
3
2
1

说明/提示

【样例解释 #1】

第 11 次操作后，重边有：(1,3)(1,3)，(3,6)(3,6)，(6,7)(6,7)。

第 22 次操作，包含的重边有：(1,3)(1,3)。

第 33 次操作，包含的重边有：(1,3)(1,3)，(3,6)(3,6)，(6,7)(6,7)。

第 44 次操作，首先 (1,3)(1,3)，(3,6)(3,6) 变为轻边，之后 (1,3)(1,3)，(3,5)(3,5) 变为重边。

第 55 次操作，包含的重边有：(1,3)(1,3)，(6,7)(6,7)。

第 66 次操作，首先 (1,3)(1,3) 变为轻边，之后 (1,2)(1,2) 变为重边。

第 77 次操作，包含的重边有：(6,7)(6,7)。

【样例 #2】

见附件 edge/edge2.in 与 edge/edge2.ans。

该样例约束与测试点 3∼63∼6 一致。

【样例 #3】

见附件 edge/edge3.in 与 edge/edge3.ans。

该样例约束与测试点 9∼109∼10 一致。

【样例 #4】

见附件 edge/edge4.in 与 edge/edge4.ans。

该样例约束与测试点 11∼1411∼14 一致。

【样例 #5】

见附件 edge/edge5.in 与 edge/edge5.ans。

该样例约束与测试点 17∼2017∼20 一致。

【数据范围】

对于所有测试数据：𝑇≤3T≤3，1≤𝑛,𝑚≤1051≤n,m≤105。

测试点编号	𝑛,𝑚≤n,m≤	特殊性质
1∼21∼2	1010	无
3∼63∼6	50005000	无
7∼87∼8	105105	A，B
9∼109∼10	105105	A
11∼1411∼14	105105	B
15∼1615∼16	2×1042×104	无
17∼2017∼20	105105	无

特殊性质 A：树的形态是一条链。

特殊性质 B：第 22 类操作给出的 𝑎𝑖ai​ 和 𝑏𝑖bi​ 之间有边直接相连。

Code:

#include<bits/stdc++.h>
char buf[100000],*buff = buf + 100000;
#define gc ((buff == buf + 100000 ? (fread(buf,1,100000,stdin),buff = buf) : 0),*(buff++))
char bfu[10000000],*bfuu = bfu;
#define pc(x) (*(bfuu++) = x)
using namespace std;
inline int read(){
	int x = 0,c = gc;
	while(c < '0' || c > '9') c = gc;
	while(c >= '0' && c <= '9') x = x * 10 + c - '0',c = gc;
	return x;
}
inline void print(int x){
	if(x >= 10) print(x / 10);
	pc(x % 10 + '0');
}
int T,n,m;
struct edge{
	int to,nxt;
}e[200010];
int cnt,fir[100010];
inline void ins(int u,int v){
	e[++cnt].to = v;e[cnt].nxt = fir[u];fir[u] = cnt;
	e[++cnt].to = u;e[cnt].nxt = fir[v];fir[v] = cnt;
}
int t[100010],f[100010],l[100010],r[100010],s[100010];
bool g[100010];
int lgo[100010],st[17][100010],dpt[100010],wz[100010],ed[100010],tot;
int bj[100010][2];
inline void dfs(int q){
	wz[q] = ++tot;s[q] = q;
	for(int i = fir[q];i;i = e[i].nxt) if(e[i].to != f[q]){
		f[e[i].to] = st[0][e[i].to] = q;
		dpt[e[i].to] = dpt[q] + 1;
		dfs(e[i].to);
	}
	ed[q] = tot;
}
inline void buildst(){
	int i,j;
	for(i = 1;i < 17;++i){
		for(j = 1;j <= n;++j) st[i][j] = st[i - 1][st[i - 1][j]];
	}
}
inline int lca(int x,int y){
	if(dpt[x] < dpt[y]) swap(x,y);
	int i = dpt[x] - dpt[y],j = 0;
	while(i){
		if(i & 1) x = st[j][x];
		i >>= 1;++j;
	}
	if(x == y) return x;
	for(i = lgo[dpt[x]];i >= 0;--i) if(st[i][x] != st[i][y]) x = st[i][x],y = st[i][y];
	return st[0][x];
}
inline void xg(int x,int y){
	for(int i = x;i <= n;i += i & -i) t[i] += y;
}
inline int cx(int x){
	int as = 0;
	for(int i = x;i;i -= i & -i) as += t[i];
	return as;
}
inline void xx(int x,int y){
	xg(wz[x],y);xg(ed[x] + 1,-y);
}
inline bool is(int q){
	return l[f[q]] != q && r[f[q]] != q;
}
#define ud(x) (s[x] = (l[x] ? s[l[x]] : x))
inline void ro(int q){
	int p = f[q];
	if(l[f[p]] == p) l[f[p]] = q;
	else if(r[f[p]] == p) r[f[p]] = q;
	f[q] = f[p];f[p] = q;
	if(l[p] == q){
		l[p] = r[q];r[q] = p;
		if(l[p]) f[l[p]] = p;
		ud(p);
	} 
	else{
		r[p] = l[q];l[q] = p;
		if(r[p]) f[r[p]] = p;
		s[q] = s[p];
	}
}
inline void sp(int q){
	while(!is(q)){
		int p = f[q];
		if(!is(p)){
			if((l[f[p]] == p) ^ (l[p] == q)) ro(q);
			else ro(p);
		}
		ro(q);
	}
}
inline int ac(int q,int w,int tp = 0){
	if(g[w]){
		int z = st[0][w];
		xx(w,-1);g[w] = 0;
		if(bj[z][0] == w) bj[z][0] = 0;
		else bj[z][1] = 0;
		sp(z);
		r[z] = 0;
	} 
	int p = 0;
	while(q){
		sp(q);
		if(bj[q][0] && bj[q][0] != tp){
			xx(bj[q][0],-1);
			g[bj[q][0]] = 0;
			bj[q][0] = 0;
		} 
		if(bj[q][1] && bj[q][1] != tp){
			xx(bj[q][1],-1);
			g[bj[q][1]] = 0;
			bj[q][1] = 0;
		} 
		r[q] = p;
		if(p){
			if(!bj[q][0]) bj[q][0] = s[p];
			else bj[q][1] = s[p];
			xx(s[p],1);
			g[s[p]] = 1;
		}
		if(s[q] == w) break;
		p = q;
		q = f[q];
	}
	sp(w);
	return s[r[w]];
}
int main(){
	int i,op,u,v,w;
	for(i = 2;i <= 100000;++i) lgo[i] = lgo[i >> 1] + 1;
	T = read();
	while(T--){
		memset(fir,0,sizeof(fir));
		memset(t,0,sizeof(t));
		memset(s,0,sizeof(s));
		memset(f,0,sizeof(f));
		memset(l,0,sizeof(l));
		memset(r,0,sizeof(r));
		memset(g,0,sizeof(g));
		memset(st,0,sizeof(st));
		memset(wz,0,sizeof(wz));
		memset(bj,0,sizeof(bj));
		tot = cnt = 0;
		n = read();m = read();
		for(i = 1;i < n;++i) ins(read(),read());
		dfs(1);
		buildst();
		for(i = 1;i <= m;++i){
			op = read();u = read();v = read();w = lca(u,v);
			if(dpt[u] < dpt[v]) swap(u,v);
			if(op == 1){
				int tmp = ac(u,w);
				if(v != w){
					ac(v,w,tmp);
					sp(w);r[w] = 0;
				} 
			}
			else{
				int ans = cx(wz[u]) + cx(wz[v]) - 2 * cx(wz[w]);
				print(ans);pc('\n');
			} 
		} 
	}
	fwrite(bfu,1,bfuu - bfu,stdout);
	return 0;
}