暗之连锁——解题报告

题目链接：http://172.18.70.217/problem/20。
题目大意：删掉两条边，一条必要边，一条附加边。必要边能构成一棵树。求有多少种方案可以使这个图不联通。必要边N条，附加边M条。
首先我们知道，暴力枚举两条边，再判断是否联通，复杂度为O（n^2 * m）.枚举一条边后求图中桥的个数，复杂度为O（n * m）。所以我们需要更快的算法。
通过分析题意我们知道，其实对于一个树中的点来说，除了树中的连边能让这个点到达上级外，如果存在一条其他的边仍能到达上级，那么就多出了一种情况。而如果存在大于一条的其他边，那么就没有这种情况。而如果根本没有其他边让它到达上级，那么就有M种情况，因为无论再删掉哪一条边，图都不会再联通。如图所示：

所以我们只要找到一种方法记录连出这棵子树的边的个数即可。为了简化代码，可以做一次树形DP，差分维护通过每个点及其子树的附加边条数。

加入边（u，v），dp[u]++,dp[v]++,dp[LCA(u,v)]-=2

这样就可以保证，对于一棵树来说，将所有子树的值相加，根的DP值一定为0.而对于本题来说，大于0代表连到了其他地方，则可以作为一种到达上级的方式。按照上面所讲的，等于0，M种方案，等于1，一种方案，大于1，没有方案。
附上AC代码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>

using namespace std;
typedef int ll;
const ll maxn=200010;
struct node
{
    ll v;
    ll next;
}e[3*maxn];
ll N,M,p[maxn],t=0,ans=0;
ll d[maxn],parent[maxn][20];
void insert(ll u,ll v)
{
    e[t].v=v;
    e[t].next=p[u];
    p[u]=t++;
}
ll LCA(ll x,ll y)
{
    ll i,j;
    if(d[x]<d[y])
        swap(x,y);
    for(i=0;(1<<i)<=d[x];i++)
        ;
    i--;
    for(j=i;j>=0;j--)
        if(d[x]-(1<<j)>=d[y])
            x=parent[x][j];
    if(x==y)
        return x;
    for(j=i;j>=0;j--)
    {
        if(parent[x][j]!=parent[y][j])
        {
            x=parent[x][j];
            y=parent[y][j];
        }
    }
    return parent[x][0];
}
void dfs1(ll u)
{
    for(ll i=p[u];i!=-1;i=e[i].next)
    {
        ll v=e[i].v;
        if(d[v]==-1)
        {
            d[v]=d[u]+1;
            parent[v][0]=u;
            dfs1(v);
        }
    }
}
ll th[maxn];
void dfs2(ll u,ll fa)
{
    for(ll i=p[u];i!=-1;i=e[i].next)
    {
        ll v=e[i].v;
        if(v!=fa)
        {
            dfs2(v,u);
            th[u]+=th[v];
        }
    }
    if(u==1)
        return;
    if(th[u]==1)
        ans++;
    else if(th[u]==0)
        ans+=M;
}
int main()
{
    memset(p,-1,sizeof(p));
    memset(d,-1,sizeof(d));
    scanf("%d%d",&N,&M);
    for(ll i=1;i<N;i++)
    {
        ll u,v;
        scanf("%d%d",&u,&v);
        insert(u,v);
        insert(v,u);
    }
    d[1]=0;
    dfs1(1);
    for(ll level=1;(1<<level)<=N;level++)
        for(ll i=1;i<=N;i++)
            parent[i][level]=parent[parent[i][level-1]][level-1];
    for(ll i=1;i<=M;i++)
    {
        ll u,v;
        scanf("%d%d",&u,&v);
        ll fa=LCA(u,v);
        th[u]++;th[v]++;th[fa]-=2;
    }
    dfs2(1,-1);
    printf("%d",ans);

    return 0;
}