树状网络攻击（LCA和树上差分的应用）

树状网络攻击：
题目描述
SX 公司很发愁，因为 DX 公司想要攻击 SX 公司的网络，SX 公司的网络可以看作一个树，
有 n 个节点和 n-1 条连接这些节点的边使得节点两两连通，节点标号 1-n。树状网络很脆弱，
为了抵御攻击，SX 公司又修建了 m 条边。所有边都是双向的。
你作为 DX 的攻击者，可以恰好毁坏两条边：一条在原树状网络上，一条在新修建的边中。
请计算你有多少种方式可以将 SX 的网络分成至少两个不连通的部分。
输入说明
第一行，两个整数 n,m。
接下来 n-1 行，每行两个整数 u,v，表示 u,v 是原树状网络的一条边。
接下来 m 行，每行两个整数 u,v，表示 u,v 是新建的一条边。
保证所有边涉及节点在 1-n 内，新建边中可能存在自环或平行边，两个数之间用一个空格隔
开。
输出说明
第一行，有多少种攻击方式可以断开 SX 的网络。
输入样例
4 1
1 2
2 3
1 4
3 4
输出样例
3
数据规模：
N<=100000，M<=100000
思路：
这个题的思路大概是建好树之后，对于每一条新边的两个端点，求出其LCA，然后将它的change[LCA]-=2,change[u]++,change[v]++，这其实是运用了树上差分的思想。然后根据change数组求前缀和，前缀和数组变量的含义是该数字表示的节点向浅层的边构成了几个环，然后这个前缀和为0时，说明无论切哪一个新编，这条旧边切开后都会符合题意，变为两个不连通的部分，ANS+=M。前缀和为1时，就是只有一个环，也就是只有说切开环内的新边之后，再切开这条旧边才会分为两个不连通的部分，ANS+=SUM[i]。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
using namespace std;
int i,j,m,n,k,temp;
int hd[100001],fa[100001][25],deep[100001];
int b[100001],sum[100001],ANS;

struct data
{
    int y,nxt;
}a[200001];

int r()
{
    int ans=0,f=1;
    char ch;
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
        f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
    {
        ans*=10;
        ans+=ch-'0';
        ch=getchar();
    }
    return ans*f;
}

void add(int x,int y)
{
    a[++temp].nxt=hd[x];
    a[temp].y=y;
    hd[x]=temp;
}

void dfs(int x)
{
    b[x]=1;
    int son,po,ii;
    for(int p=hd[x];p;p=a[p].nxt)
    {
        son=a[p].y;
        if(!b[son])
        {
            deep[son]=deep[x]+1;
            po=x,ii=1;
            fa[son][0]=x;
            while(po>=1)
            {
                fa[son][ii]=fa[po][ii-1];
                po=fa[po][ii-1];
                ii++;
            }
            dfs(son);
        }
    }
}

int lca(int xx,int yy)
{
    int i,j;
    if(deep[xx]<deep[yy]) swap(xx,yy);
    for(i=0; (1<<i)<=deep[xx]; i++);
    i--;
    for(j=i; j>=0; j--)
        if(deep[xx]-(1<<j)>=deep[yy])
            xx=fa[xx][j];
    if(xx==yy)return xx;
    for(j=i; j>=0; j--)
    {
        if(fa[xx][j]!=fa[yy][j])
        {
            xx=fa[xx][j];
            yy=fa[yy][j];
        }
    }
    return fa[xx][0];

}

void dfs2(int x)
{
    b[x]=1;

    int son,po,ii;
    for(int p=hd[x];p;p=a[p].nxt)
    {
        son=a[p].y;
        if(!b[son])
        {
            dfs2(son);
            sum[x]+=sum[son];
        }
    }
}

int main()
{
    freopen("network.in","r",stdin);
    freopen("network.out","w",stdout);
    n=r(),m=r();
    int x,y;
    for(i=1;i<n;i++)
    {
        x=r(),y=r();
        add(x,y);
        add(y,x);
    }
    deep[1]=1;
    dfs(1);
    int l;
    for(j=1;j<=m;j++)
    {
        x=r(),y=r();
        l=lca(x,y);
        sum[l]-=2;
        sum[x]++,sum[y]++;
    }
    memset(b,0,sizeof(b));
    dfs2(1);
    for(i=2;i<=n;i++)
    {
        if(!sum[i])
        ANS+=m;
        else if(sum[i]==1)
        ANS++;
    }
    cout<<ANS;
}
/*
6 3
1 3
1 2
2 5
2 4
5 6
4 6
2 3
3 5
*/