loj 10131 暗的连锁

题目

题目描述

原题来自：poj3417

Dark 是一张无向图，图中有 N个节点和两类边，一类边被称为主要边，而另一类被称为附加边。Dark 有N -1条主要边，并且 Dark 的任意两个节点之间都存在一条只由主要边构成的路径。另外，Dark 还有 M 条附加边。

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

现在你想要知道，一共有多少种方案可以击败 Dark。注意，就算你第一步切断主要边之后就已经把 Dark 斩为两截，你也需要切断一条附加边才算击败了 Dark。

输入格式

第一行包含两个整数  N和 M；

之后 N-1 行，每行包括两个整数 A 和 B，表示 A 和 B 之间有一条主要边；

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

输出格式

输出一个整数表示答案。

样例

样例输入

4 1 
1 2 
2 3 
1 4 
3 4

样例输出

3

数据范围与提示

对于 20% 的数据1 <= N，M<=100；

对于 100% 的数据1<=N<=10⁵，1 <= M <= 2*10⁵。数据保证答案不超过 2³¹ - 1。

分析

一本通（提高篇）P250

每一条附加边（u，v）都相当于把树上（u，v）路径上的所有边都“覆盖”了一遍，断其中一条边不会断树

统计出每一条边“覆盖”了几次，0次的直接断掉就会断树，任意断一条附加边即可，1次的断附加边的方案唯一，2次及以上无解

统计覆盖次数用到了树上差分，把边权下放到下面的点

差分学习资料：差分数组 and 树上差分 By 顾z

代码

/**********************
User：Mandy.H.Y
Language:c++
Problem:
Algorithm:
Date: 
**********************/

//LCA,树上差分 

#include<bits/stdc++.h>
#define Max(x,y) ((x) > (y) ? (x) : (y))
#define Min(x,y) ((x) < (y) ? (x) : (y))

using namespace std;

const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;

int n,m,ans;
int size,first[maxn],score[maxn];
int top[maxn],cnt[maxn],father[maxn],dep[maxn];

struct Edge{
    int v,nt;
}edge[maxm];

char *TT,*mo,but[(1 << 15) + 2];
#define getchar() ((TT == mo && (mo = ((TT = but) + fread(but,1,1 << 15,stdin)),TT == mo)) ? -1 : *TT++)
template<class T>inline void read(T &x){
    x = 0;bool flag = 0;char ch = getchar();
    while( ! isdigit(ch)) flag |= ch == '-',ch = getchar();
    while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
    if(flag) x = -x;
}

template<class T>inline void putch(const T x){
    if(x > 9) putch(x / 10);
    putchar(x % 10 | 48);
}

template<class T>inline void put(const T x){
    if(x < 0) putchar('-'),putch(-x);
    else putch(x);
}

void file(){
    freopen("yam2.in","r",stdin);
//    freopen("network.out","w",stdout);
}

void eadd(int u,int v){
    edge[++ size].v = v;
    edge[size].nt = first[u];
    first[u] = size;
}

void readdata(){
    read(n);read(m);
    for(int i = 1;i < n; ++ i){
        int u,v;
        read(u);read(v);
        eadd(u,v);eadd(v,u);
    }
}

void dfs(int u,int f,int d){
    top[u] = u;dep[u] = d;
    int mcnt = 0,son = 0;
    father[u] = f;cnt[u] = 1;
    
    for(int i = first[u];i;i = edge[i].nt){
        int v = edge[i].v;
        if(v == f) continue;
        dfs(v,u,d + 1);
        cnt[u] += cnt[v];
        if(mcnt < cnt[v]){
            mcnt = cnt[v];
            son = v;
        }
    }
    
    if(son) top[son] = u;
}

int find(int u){
    return top[u] == u ? u : top[u] = find(top[u]);
}

int LCA(int x,int y){
    if(find(x) == find(y)) return dep[x] < dep[y] ? x : y;
    else return dep[top[x]] <dep[top[y]] ? LCA(x,father[top[y]]) : LCA(y,father[top[x]]);
    //没想到有一天模板也会打错 
}

void dfs1(int u){
    for(int i = first[u];i;i = edge[i].nt){
        int v = edge[i].v;
        
        if(v == father[u]) continue;
        
        dfs1(v);
        score[u] += score[v]; //累加 
        if(score[v] == 0){
            ans+=m;
        } else if(score[v] == 1) ans++;
    }
}

void work(){
    
    dfs(1,0,0);
    
    for(int i = 1;i <= m; ++ i){
        int u,v;
        read(u);read(v);
        int anc = LCA(u,v); 
        score[u]++,score[v]++;
        score[anc]-=2;
        //差分
        //把边下放到点 
    }
    
    dfs1(1);
//    put(score[1]);puts("");
    put(ans);
}

int main(){
//    file();
    readdata();
    work();
    return 0;
}