题目描述

传说中的暗之连锁被人们称为 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

解题报告

题意理解

这道题目题意比较绕,我们来一步步剖解这道题目.题目解剖学,人体解剖学

1. 一颗$n-1$条主要边的树,然后增加了$m$条附加边.
2. 我们只能删除一条主要边,一条附加边,一种边叫做主要边,一种边叫做附加边.
3. 要求删除两条边后,这棵树不再是连通的.
4. 我们需要统计,有多少种方案可以使得不连通,输出方案数.

算法解析

附加边到底有什么用处?
$$ 对于每一条连接x,y节点的(x,y),其实我们都可以认为这条边,连接了(x,y)这条路径上的所有点. $$
当没有了主要边的时候,其实附加边就是我们的主要边.
$$ 所以说,附加边(x,y),就是将树上x,y之间的路径上的每条主要边,都覆盖了一次. $$
因为当$(x,y)$路径上的任意一条主要边消失后,他都可以成为主要边,去维护连通性.

因此现在我们的问题模型转化了.

给定一个$n-1$条边的树,求每一条树边,被非树边覆盖了多少次

1. 树边也就是主要边
2. 非树边也就是附加边

那么这就是一个树上差分统计覆盖次数问题了.
$$ 每一条附加边,使得(x,y)节点的路径上,每一个节点的权值+1. $$

此时我们的问题,变成了如何统计方案数.

我们来好好地分类讨论一下主要边,身上的附加边.
$$ 1.主要边被覆盖了0次,即上面只有0条附加边. $$
我们发现删除完这条主要边后,随意删除一条附加边,我们都可以让树不连通.也就是$m$种方案.

只要删除$(2,4)$这条红边,那么随意一条附加边,都可以满足条件.
$$ 2.主要边覆盖1次,即上面只有一条附加边 $$
我们发现删除完这条主要边后,我们只能删除这条主要边的附加边.也就是$1$种方案.

也就是删除咱们图上面的$(3,7)$红边,然后我们只能删除那条上面的紫色边.
$$ 3.主要边覆盖大于1次,即上面有多条附加边 $$
我们发现,怎么删除,总能连通.于是$0$种方案.

代码解析

#include <bits/stdc++.h>
using namespace std;
const int N=100000+200;
int n,m,ans;
struct LCA
{
    int head[N<<1],Next[N<<1],edge[N<<1],ver[N<<1],tot;
    int deep[N],fa[N][22],lg[N],date[N];
    inline void init()
    {
        memset(head,0,sizeof(head));
        memset(deep,0,sizeof(deep));
        tot=0;
    }
    inline void add_edge(int a,int b,int c)
    {
        edge[++tot]=b;
        ver[tot]=a;
        Next[tot]=head[a];
        head[a]=tot;
    }
    inline void dfs(int x,int y)
    {
        deep[x]=deep[y]+1;//深度是父亲节点+1
        fa[x][0]=y;//2^0=1,也就是父亲节点
        for(int i=1; (1<<i)<=deep[x]; i++) //2^i<=deep[x]也就是别跳出根节点了
            fa[x][i]=fa[fa[x][i-1]][i-1];
        for(int i=head[x]; i; i=Next[i]) //遍历所有的出边
            if (edge[i]!=y)//避免回到父亲节点
                dfs(edge[i],x);//自己的儿子节点, 自己是父亲节点
        return ;
    }
    inline int Lca(int x,int y)//Lca过程
    {
        if (deep[x]<deep[y])//x节点默认深度深一些,在下面
            swap(x,y);//交换
        while(deep[x]>deep[y])//还没有同一高度
            x=fa[x][lg[deep[x]-deep[y]]-1];//往上面跳跃,deep[x]-deep[y]是高度差.-1是为了防止deep[x]<deep[y]
        if(x==y)//意外发现,y就是(x,y)的Lca
            return x;
        for(int i=lg[deep[x]]; i>=0; i--)
            if (fa[x][i]!=fa[y][i])//没有跳到Lca
            {
                x=fa[x][i];//旋转跳跃
                y=fa[y][i];//我闭着眼
            }
        return fa[x][0];//父亲节点就是Lca,因为本身是离着Lca节点最近的节点,也就是Lca的儿子节点.
    }
    inline int query(int x,int f)//f是x节点的父亲节点
    {
        for(int i=head[x]; i; i=Next[i]) //所有出边
        {
            int j=edge[i];//出边
            if (j!=f)//不是父亲节点
            {
                query(j,x);//访问儿子节点
                date[x]+=date[j];//累加子树节点的值
                if(date[j]==0)
                    ans+=m;
                else if(date[j]==1)
                    ans++;
            }
        }
    }
    inline int update(int x,int y)//修改操作,x,y节点构成的路径统一+1
    {
        date[x]++;
        date[y]++;
        date[Lca(x,y)]-=2;
    }
} g1;
int main()
{
    scanf("%d%d",&n,&m);
    g1.init();
    for(int i=1; i<n; i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        g1.add_edge(a,b,0);//加边
        g1.add_edge(b,a,0);//无向图
    }
    for(int i=1; i<=n; i++)
        g1.lg[i]=g1.lg[i-1]+(1<<g1.lg[i-1]==i);//处理log数组的关系
    g1.dfs(1,0);
    for(int i=1; i<=m; i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        g1.update(a,b);//附加边
    }
    g1.query(1,0);
    printf("%d\n",ans);
    return 0;
}