每周一算法：树上差分

题目链接

闇の連鎖

题目描述

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

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

经过研究，你发现Dark呈现无向图的结构，图中有$N$个节点和两类边，一类边被称为主要边，而另一类被称为附加边。

Dark 有 $N–1$ 条主要边，并且 Dark 的任意两个节点之间都存在一条只由主要边构成的路径。
另外，Dark 还有 $M$ 条附加边。

你的任务是把Dark斩为不连通的两部分。一开始 Dark 的附加边都处于无敌状态，你只能选择一条主要边切断。一旦你切断了一条主要边，Dark 就会进入防御模式，主要边会变为无敌的而附加边可以被切断。

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

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

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

输入格式

第一行包含两个整数$N$和$M$。
之后 $N–1$ 行，每行包括两个整数 $A$ 和 $B$，表示 $A$ 和 $B$ 之间有一条主要边。
之后 $M$ 行以同样的格式给出附加边。

输出格式

输出一个整数表示答案。

数据范围

【数据范围】
$N\le 100000,M\le 200000$，数据保证答案不超过 $2^{31}-1$

输入样例

4 1
1 2
2 3
1 4
3 4

输出样例

3

算法思想

根据题目描述，有$n$个节点和$n-1$条主要边，并且任意两个节点之间都存在一条只由主要边构成的路径，构成一棵树。此时无论切断哪条主要边，都可以将树斩为不连通的两个部分。

如果引入一条附加边，就会构成一个环，如下图所示：

此时，切断环中任意一条主要边，再切断该附加边就可以斩为不连通的两个部分。

如果再引入一条附加边，如下图所示：

可以发现：

• 图中黄色的主要边存在于两个环中，如果切断一条黄色边，那么还要切断两条附加边，才能将图斩为不连通的两个部分，因此不满足题目中要求的：只能切断一条主要边、再切断一条附加边将图斩为不连通的两个部分。
• 图中绿色或者红色的主要边只存在于一个环中，如果将其切断，那么只需要切断对应的附加边，就可以将图斩为不连通的两个部分
• 图中蓝色的主要边不在环中，如果将其切断，那么再切断任意一条附件边，都可以将图斩为不连通的两个部分。

基于上述分析，可以对每一条通过附加边连接的主要边进行计数，如下图所示：

最后，计算出每条主要边的经过总次数$s$：

• 如果s == 0，可以切断$m$条附加边中任意一条满足要求，方案数ans += m
• 如果s == 1，可以切断$1$条附加边满足要求，方案数ans += 1
• 如果s > 1，无法满足要求，方案数不变

树上差分

通过上面分析，需要将一条路径上的每一条主要边的经过次数都增加$1$，一共要进行$m$次操作，最终计算出经过每条边的总次数，朴素做法的时间复杂度为$O(n\times m)$，这里可以采用树上差分进行优化。

不妨设$d[]$为树中每个节点向上连接的边经过次数的差分数组，如果要将从$u$到$v$的路径中每条边的经过次数$+1$，如下图所示：

可以让d[u] += 1，d[v] += 1，d[p] -= 2，其中$p$为$u、v$的最近公共祖先。

经过若干次操作之后，再自底向上累加每棵子树的和，就可以求出每条边经过的总次数。这就是树上差分。

除此之外，在进行树上差分之前，需要预处理出两个节点的最近公共祖先，可以使用倍增求解，具体参考博主的另一篇文章——每周一算法：倍增法求最近公共祖先（LCA）

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, K = 17;
int n, m, depth[N], q[N], fa[N][K], d[N], ans = 0;
vector<int> g[N];
//预处理每个节点的深度和倍增数组
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 u = q[hh ++];
        for(int v : g[u])
        {
            if(depth[v] > depth[u] + 1)
            {
                depth[v] = depth[u] + 1;
                q[++ tt] = v;
                fa[v][0] = u; //v的父结点是u
                for(int i = 1; i < K; i ++) //计算v向上跳2^i的节点
                    fa[v][i] = fa[fa[v][i - 1]][i - 1];
            }
        }
    }
}
int lca(int u, int v)
{
    if(depth[u] < depth[v]) swap(u, v);
    for(int i = K - 1; i >= 0; i --)//将u跳到和v同层
    {
        if(depth[fa[u][i]] >= depth[v]) u = fa[u][i];
    }
    if(u == v) return u; //刚好相同
    for(int i = K - 1; i >= 0; i --) //将u和v同时向上跳
    {
        if(fa[u][i] != fa[v][i])
        {
            u = fa[u][i], v = fa[v][i];
        }
    }
    return fa[u][0];
}
int dfs(int u, int father)
{
    int res = d[u]; 
    for(int v : g[u])
    {
        if(v != father)
        {
            int s = dfs(v, u); //子树的经过总次数
            if(s == 0) ans += m; //如果v对应的边经过0次，方案数增加m
            else if(s == 1) ans += 1; 
            res += s; //累加子树的经过次数
        }
    }
    return res;
}
int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i < n; i ++) //n-1条边
    {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v), g[v].push_back(u); //无向图，双向建边
    }
    bfs(); //预处理每个节点的深度和倍增数组
    for(int i = 0; i < m; i ++) //输入附加边
    {
        int u, v;
        scanf("%d%d", &u, &v);
        int p = lca(u, v); //计算u和v的最近公共祖先
        d[u] ++, d[v] ++, d[p] -= 2; //树上差分
    }
    dfs(1, -1); //自底向上求树中每条边经过的总次数
    printf("%d\n", ans);
    return 0;
}