POJ - 3417 Network 【LCA模板+树形DP】

POJ - 3417入口

 题意：先给出一棵n个点的无根树，然后下面再给出m条边，把这m条边连上，然后每次你能破坏两条边，规定一条是树边，一条是新边，问有多少种方案能使树分为两部分。

思路：我们知道，这m条边连上后这颗树必将成环，假设新边为（u，v），那么环为u---->LCA(u,v)------->v-------->u，我们给这个环上的边计数1，表示这些边被一个环覆盖了一次。添加了多条新边后，可知树上有些边是会被多次覆盖的，画图很容易发现，但一个树边被覆盖了2次或以上，它就是一条牢固的边，就是说毁掉它再毁掉任何一条新边都好，树都不会断裂，这个结论也是很容易证明的，画图更明显，所以不累述

所以这启发了我们，要统计所有的边被覆盖了几次，我们分情况来讨论

1.覆盖0次，说明这条边不在任何一个环上，这样的边最脆弱，单单是毁掉它就已经可以使树断裂了，这时候只要任意选一条新边去毁，树还是断裂的，所以这样的树边，就产生m种方案（m为新边条数）

2.覆盖1次，说明这条边在一个环上，且，仅在一个环上，那么要使树断裂，就毁掉这条树边，并且毁掉和它对应的那条新边（毁其他的新边无效），就一定能使树断裂，这种树边能产生的方案数为1，一条这样的树边只有唯一解

3.覆盖2次或以上，无论怎么样都不能使树断裂，产生的方案数为0

所以，如果我们能知道所有的树边的覆盖，那么统计一次就行了，所以问题只剩下，怎么每条边被覆盖了几次？

需要用到树DP。

首先我们定义dp[u]的意义为，u所对应的那条父边（u和它父亲连接的那条边）被覆盖的次数

对应一条新边（u，v），我们知道是要求LCA(u,v)的，这时候我们计数dp[u]++ , dp[v]++ , dp[lca]-=2

为什么这样计数？我们试着看看，点u和点v和点lca，都试着沿路径一直回到树根处（注意不是回到LCA而是树根），u的路径中每经过一个点，就将这些点上的值加上dp[u],同样v的路径上没经过一个点就将这些点上的值加上dp[v]，lca也是这样。你会发现，lca回到树根的部分，其实被抵消掉了，dp值没有变化，而u到lca，v到lca部分的值都已经分别加上了dp[u],dp[v]

这启发了我们，我们在求完所有m对顶点的LCA后，每个u和v都做一次dp[u]++,dp[v]++,dp[lca]-=2，然后我从树根开始向下遍历一次整棵树，在回溯的时候就执行累加dp[u],dp[v]的操作

ACcode

#include<cstring>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
using namespace std;
const int N=100100;
const int M=200100;
int fa[20][N],head[M],dep[N];
int nu,n,m;
bool fl[N];
struct edge
{
    int to,nex;
}e[M];
void add(int from,int to)
{
    e[nu].to=to;
    e[nu].nex=head[from];
    head[from]=nu++;
}
void init1()
{
    memset(head,-1,sizeof(head));
    nu=0;
}
void dfs(int x,int ffa,int d)
{
    fa[0][x]=ffa;
    dep[x]=d;
    for(int i=head[x];i!=-1;i=e[i].nex)
    {
        int y=e[i].to;
        if(y==ffa)continue;
        dfs(y,x,d+1);
    }
}
void init2()
{
    dfs(1,-1,1);
m=0;
while(n>=(1<<m))m++;
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(fa[i-1][j]<0)fa[i][j]=-1;
            else
            {
                fa[i][j]=fa[i-1][fa[i-1][j]];
            }
        }
    }
}
int LCA(int x,int y)
{
    if(dep[x]<dep[y])swap(x,y);
    for(int i=m;i>=0;i--)
    {
        if((dep[x]-dep[y])&(1<<i))
            x=fa[i][x];
    }
    if(x==y)return x;
    for(int i=m;i>=0;i--)
    {
        if(fa[i][x]!=fa[i][y])
        {
            x=fa[i][x];
            y=fa[i][y];
        }
    }
    return fa[0][x];
}
long long dp[N];
int n2;
void dfs1(int x,int fa)
{
    for(int i=head[x];i+1;i=e[i].nex)
    {
        int y=e[i].to;
        if(y==fa)continue;
        dfs1(y,x);
        dp[x]+=dp[y];
    }
}
int main()
{
    int x,y;
    while(scanf("%d%d",&n,&n2)!=EOF)
    {
        init1();
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }
        init2();
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n2;i++)
        {
            scanf("%d%d",&x,&y);
            dp[x]++;
            dp[y]++;
            dp[LCA(x,y)]-=2;
        }
        dfs1(1,-1);
        long long ans=0;
        for(int i=2;i<=n;i++)
        {
            if(dp[i]==0)
                ans+=n2;
            else if(dp[i]==1)
                ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}