AcWing 352. 闇の連鎖 题解（最近公共祖先、树上差分）

AcWing 352. 闇の連鎖
遍历每条附加边，利用树上查分标记树上值，之后遍历树上的每条边，如果这条边的边上值大于1，因为减去主要边之后只能再减去一条边，所以这条边不能用，ans不变，如果这条边树上值为0，代表减去这条主要边之后减去任一附加边都行，就让ans += m，如果这条边树上值为1，代表减去这条边之后再减去一条附加边即可，就让ans++，遍历完所有边之后ans的值就是答案

#include<bits/stdc++.h>

using namespace std;

//define 边上值：把这条边斩断还需要斩断几条变才能将图分为两部分 

const int N = 100010, M = N * 2;  //无向图，double边

int n, m;
int h[N], e[M], ne[M], idx;
int d[N];  //记录每条边的数值
int depth[N];
int fa[N][17];  //记录祖先节点 
int ans;
int q[N];

void add(int a, int b){
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx ++ ;
}

void bfs(){  //给所有树上节点确定深度和父节点、祖先节点 
	memset(depth, 0x3f, sizeof depth);
	depth[0] = 0, depth[1] = 1;
	int hh = 0, tt = 0;
	q[0] = 1;
	
	while(hh <= tt){
		int t = q[hh ++];
		for(int i = h[t]; ~i; i = ne[i]){
			int j = e[i];
			if(depth[j] > depth[t] + 1){
				depth[j] = depth[t] + 1;
				q[ ++ tt] = j;
				fa[j][0] = t;
				for(int k = 1; k <= 16; k ++ ){
					fa[j][k] = fa[fa[j][k - 1]][k - 1];  //确定祖先节点 
				}
			}
		}
	}
}

int lca(int a, int b){  //返回a、b点的最近公共祖先 
	if(depth[a] < depth[b]) swap(a, b);  //将a置于更深层次的点 
	for(int k = 16; k >= 0; k -- ){
		if(depth[fa[a][k]] >= depth[b]){
			a = fa[a][k];
		}
	}
	if(a == b) return a;
	for(int k = 16; k >= 0; k -- ){
		if(fa[a][k] != fa[b][k]){
			a = fa[a][k];
			b = fa[b][k];
		}
	}
	return fa[a][0];  //返回公共祖先节点 
}

int dfs(int u, int fa){  //确定边上值 
	int res = d[u];  //记录边上值 
	for(int i = h[u]; ~i; i = ne[i]){
		int j = e[i];
		if(j != fa){
			int s = dfs(j, u);  //s返回的是砍完这条边，还需要再砍几条变的数值 
			//遍历的数是主要边构成的树，如果这个子树的数值之和为0，代表对于这个子树上的边来说，切断任何一个附加边都可以
			//附加边的数量为m，所以方案数要加上m
			if(s == 0) ans += m;
			else if(s == 1) ans ++ ;
			res += s;
		}
	}
	return res;
}

int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	for(int i = 0; i < n - 1; i ++ ){
		int a, b;
		scanf("%d%d", &a, &b);
		add(a, b);
		add(b, a);
	}	
	
	bfs();
	
	for(int i = 0; i < m; i ++ ){
		int a, b;
		scanf("%d%d", &a, &b);
		int op = lca(a, b);
		d[a] ++ , d[b] ++ ;
		d[op] -= 2;
	}
	
	dfs(1, -1);
	
	cout<<ans<<endl;
	
	return 0;
}