poj3417 Network 树形Dp+LCA

题意：给定一棵n个节点的树，然后在给定m条边，去掉m条边中的一条和原树中的一条边，使得树至少分为两部分，问有多少种方案。

神题，一点也想不到做法，

首先要分析出加入一条边之后会形成环，形成环的话，如果去掉该边和环上面没有被其他环覆盖的边，那么便分为两部分了。

这样只需要记录每条边被环覆盖了几次即可，

用dp[u]表示u点的父边被覆盖了几次。

每次新加进来一条边(a,b) dp[a] ++ ,dp[b] ++ , dp[lca(a,b)] -= 2;

所有边处理完之后，遍历一边此树，同时转移状态 dp[u] += dp[v];

#define maxn 100005

struct node
{
    int v,next;
};
node e[maxn *  ];
int cnt ;
int head[maxn *  ];
int num ;
int E[maxn *  + ],L[maxn *  + ],R[maxn *  +  ];
int f[maxn *  +  ][];
int dp[maxn];
void init()
{
    cnt =  ;
    memset(head,-,sizeof(head));
}
void add(int u ,int v)
{
    e[cnt].v = v ;
    e[cnt].next = head[u];
    head[u] = cnt ++ ;
    e[cnt].v = u;
    e[cnt].next = head[v] ;
    head[v] = cnt ++ ;
    return ;
}
void dfs(int u ,int fa,int dep)
{
    E[++num] = u , L[num] = dep , R[u] = num;
    for(int i = head[u] ;i != -; i = e[i].next)
    if(e[i].v != fa)
    {
        int v = e[i].v;
        dfs(v, u, dep +  );
        E[++num] = u , L[num] = dep;
    }
    return;
}
void initRMQ()
{
    for(int i =  ; i <= num ;i ++ ) f[i][] = i;
    for(int j =  ; (<<j) <= num ; j++ )
        for(int i = ; i + (<<j) - <= num; i ++ )
            if(L[f[i][j-]] < L[f[i+(<<(j-))][j-]])      //ps:注意下标
                f[i][j] = f[i][j-];
            else f[i][j] = f[i+(<<(j-))][j-];
}
int lca(int a ,int b)
{
    a = R[a] , b = R[b];
    if(a>b) swap(a,b);
    int k = (log(1.0 + b - a )/log(2.0));
    if(L[f[a][k]] < L[f[b-(<<k)+][k]] )
        return E[f[a][k]];
    else return E[f[b-(<<k)+][k]];
}
void dfs(int u,int fa)
{
    for(int i = head[u] ; i != - ; i =e[i].next)
    if(e[i].v != fa)
    {
        int v = e[i].v;
        dfs(v,u);
        dp[u] += dp[v];
    }
    return ;
}
int main()
{
    int n,m;
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i =  ; i < n - ; i ++ )
        {
            scanf("%d%d",&u,&v);
            add(u,v);
        }
        num =  ;
        memset(R,,sizeof(R));
        dfs(,,);
        initRMQ();
        memset(dp,,sizeof(dp));
        for(int i = ; i < m ; i ++ )
        {
            scanf("%d%d",&u,&v);
            dp[u] ++ ;
            dp[v] ++ ;
            dp[lca(u,v)] -= ;
        }
        dfs(,);
        int sum ;
        sum =  ;
        for(int i =  ;i <= n ; i++ ) //   ps:1为根不要选。
        {
            if(dp[i] == )
                sum ++;
            else if(dp[i] ==  )
                sum += m;
        }
        printf("%d\n",sum);
    }
    return ;
}

/*
好题：
离线LCA + 树形DP

分析：加进来一条边(a,b)，会形成一条环 a - lca(a,b) - b
如果去掉(a,b)和没有被其他环覆盖的边，那么就能把树分成两部分。
只要记录dp[u]表示u的负边被环覆盖了几次
对于新加进来的一条边(a,b) dp[a] ++ , dp[b] ++  , dp[lca(a,b)] -= 2;///
这样处理为完所有新加进来的边之后，在dfs一边，跑完状态转移：dp[u] += dp[v];
这里就可以把每条环上的边都依次加1，并且因为lca(a,b)的父边不再环上，且已经提前减去了2
这样转移正好可以把减掉的2消去。

注意：这里把lca离线处理成rmq，只需要O(n)的遍历和O(nlogn)的预处理即可。  ST表

并且这里以1为根，后面的状态转移也要以1为根，否则lca就白算了。

*/

poj3417