闇の連鎖（树上边差分+LCA）

Description

传说中的暗之连锁被人们称为 Dark。

Dark 是人类内心的黑暗的产物，古今中外的勇者们都试图打倒它。

经过研究，你发现 Dark 呈现无向图的结构，图中有 n 个节点和两类边，一类边被称为主要边，而另一类被称为附加边。 Dark 有 n - 1 条主要边，并且 Dark 的任意两个节点之间都存在一条只由主要边构成的路径。

另外，Dark 还有 m 条附加边。

你的任务是把 Dark 斩为不连通的两部分。

一开始 Dark 的附加边都处于无敌状态，你只能选择一条主要边切断。

一旦你切断了一条主要边，Dark 就会进入防御模式，主要边会变为无敌的而附加边可以被切断。

但是你的能力只能再切断 Dark 的一条附加边。

现在你想要知道，一共有多少种方案可以击败 Dark。

注意，就算你第一步切断主要边之后就已经把 Dark 斩为两截，你也需要切断一条附加边才算击败了 Dark。

Input

第一行两个整数 n, m  ( n ≤ 100000 ,  m ≤ 200000 ) 。

之后 n - 1 行，每行是两个整数 a 和 b，表示 a 和 b 之间有一条主要边。

之后 m 行以同样的格式给出附加边。

Output

一个整数表示答案。数据保证答案不超过 231−1

Sample Input

4 1
1 2
2 3
1 4
3 4

Sample Output

3

---

题意分析：题目给出n个节点拥有n-1条主要边，且任意两个节点之间都存在一条只由主要边构成的路径。可以得出结论：由主要边构成的图为树，因此可以把主要边看成树边，把附加边看成非树边。问：一共有多少种不同方案使得去除一条树边与一条非树边后，图不连通。

---

解题思路：
假设存在一条非树边a,b，记lca为a,b的最近公共祖先。若删去a或b到lca路径上的任意一条树边，必须同时删去非树边a,b，才能使得图不连通。
因此令每条树边的边权表示：为使图不连通，删去该树边后至少还需要对应删除的非树边数量
因此对每一条非树边a,b，需要令a与b到lca的路径上所有边的边权+1；这一步可以通过树上边差分实现。
若一条边的边权=0：说明删去该树边后图不连通，因此可以再随意删去任意一条非树边，所以答案+=m；
若一条边的边权=1：说明删去该树边后还得对应删除一条非树边，才能使图不连通，所以答案+=1；
若一条边的边权>=2:说明删去该树边后还得对应删除两条非树边，才能使图不连通，不符合题意。

树上边差分：
每条边的边权为其子树的总点权
例：令a,b之间路径上的所有边权增加x，c = LCA(a,b)，对应的操作为：
d[a] += x; d[b] += x; d[c] -= 2*x;
因此对每条非树边a,b需要做：d[a]++, d[b]++, d[lca(a,b)] -= 2;

---

 

全部代码如下：

#include<bits/stdc++.h>
using namespace std;

#define N 100020
#define INF 0x3f3f3f3f

int n, m;
int d[N], ans;
int fa[N][17], depth[N];
int h[N], e[2 * N], ne[2 * N], idx;
void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
	e[idx] = a, ne[idx] = h[b], h[b] = idx++;
}

void bfs() {
	memset(depth, 0x3f, sizeof depth);
	depth[0] = 0, depth[1] = 1;
	int q[N], hh = 0, tt = -1;
	q[++tt] = 1;
	while (hh <= tt) {
		int t = q[hh++];
		for (int i = h[t]; i != -1; i = ne[i]) {
			int j = e[i];
			if (depth[j] > depth[t]) {
				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) {
	if (depth[a] < depth[b])swap(a, b);
	
	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 x, int father) {
	int res = d[x];
	for (int i = h[x]; i != -1; i = ne[i]) {
		int j = e[i];
		if (j != father) {
			int s = dfs(j, x); //计算j子树的总点权，代表x与j连边的边权
			if (s == 0)ans += m;
			if (s == 1)ans ++;
			res += s;
		}
	}
	return res;
}

int a, b, c;
int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d", &n, &m);
	for (int i = 1; i < n; i++) {
		scanf("%d%d", &a, &b);
		add(a, b);
	}

	memset(depth, 0x3f, sizeof depth);
	bfs();
	for (int i = 0; i < m; i++) {
		scanf("%d%d", &a, &b);
		d[a]++, d[b]++, d[lca(a, b)] -= 2;
	}
	dfs(1, -1);

	printf("%d\n", ans);

	return 0;
}