poj3417(lca + 树形dp)

题目链接: http://poj.org/problem?id=3417

题意: 先给出一棵树, 再添加 m 条新边, 然后再删除其中一条新边和一条树枝, 问有多少中删除方法可以使新树分成两部分 .

思路:  lca + 树形dp

添加新边后必然形成环, 对于添加新边 (u, v), 形成的环为 u -> v -> lca(u, v) -> u . 用一个权值记录一下边被环覆盖的次数, 即给每个环上的所有边权值加一 .

通过画图可以发现:

对于权值为 0 的树枝, 删除后即能将树分成两部分, 即其能和任意一条新边组合成一个合法方案, 对答案贡献为 m；

对于权值为 1 的树枝, 删除后, 只能再删除其对应的新边能将树分成两部分, 即对答案贡献为 1；

对于权值为 2 的树枝, 其和任意新边组合都不能将树分成两部分, 即对答案贡献为 0；

那么现在只需要求出每条树枝的权值即可, 对于这个问题可以通过树形 dp 解决, 用 dp[x] 表示节点 x 和其父亲节点组成的边的权值,

如果直接暴力求权值的话时间复杂度为O(n^2), 对于比较大的数据肯定会 tle . 事实上这些新边增加后形成的环对于彼此的权值是不会有影响的, 那么可以先将所有新边标记一下, 然后从下往上遍历一次树即可计算出所有边的权值.

具体操作为, 对于每条新边 (u, v), 先令 dp[u] += 1, dp[v] += 1, dp[lca] -= 2, 然后 dfs 回溯时将儿子节点的权值累加到父亲节点上即可. (dp[lca] - 2 是为了消除当前环对其上面的节点的影响, 这个过程和树状数组改段求点差不多) .

代码:

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

const int MAXN = 1e5 + 10;

struct node{
    int u, v, lca, next;
}edge1[MAXN << 1], edge2[MAXN << 1];

int pre[MAXN], vis[MAXN], dp[MAXN];
int head1[MAXN], head2[MAXN], id1, id2;

void init(void){
    memset(dp, 0, sizeof(dp));
    memset(vis, 0, sizeof(vis));
    memset(head1, -1, sizeof(head1));
    memset(head2, -1, sizeof(head2));
    id1 = id2 = 0;
}

void addedge1(int u, int v){
    edge1[id1].v = v;
    edge1[id1].next = head1[u];
    head1[u] = id1++;
}

void addedge2(int u, int v){
    edge2[id2].v = v;
    edge2[id2].next = head2[u];
    head2[u] = id2++;
}

int find(int x){
    return pre[x] == x ? x : pre[x] = find(pre[x]);
}

void jion(int x, int y){
    x = find(x);
    y = find(y);
    if(x != y) pre[x] = y;
}

void tarjan(int u){
    pre[u] = u;
    vis[u] = 1;
    for(int i = head1[u]; i != -1; i = edge1[i].next){
        int v = edge1[i].v;
        if(!vis[v]){
            tarjan(v);
            jion(v, u);
        }
    }
    for(int i = head2[u]; i != -1; i = edge2[i].next){
        int v = edge2[i].v;
        if(vis[v]) edge2[i].lca = edge2[i ^ 1].lca = find(v);
    }
}

void dfs(int x, int fa){
    for(int i = head1[x]; i != -1; i = edge1[i].next){
        int v = edge1[i].v;
        if(v != fa){
            dfs(v, x);
            dp[x] += dp[v];
        }
    }
}

int main(void){
    int n, m, x, y;
    while(~scanf("%d%d", &n, &m)){
        init();
        for(int i = 1; i < n; i++){
            scanf("%d%d", &x, &y);
            addedge1(x, y);
            addedge1(y, x);
        }
        for(int i = 0; i < m; i++){
            scanf("%d%d", &x, &y);
            addedge2(x, y);
            addedge2(y, x);
            dp[x] += 1;
            dp[y] += 1;
        }
        tarjan(1);
        for(int i = 0; i < m; i++){
            int cc = i << 1;
            int lca = edge2[cc].lca;
            dp[lca] -= 2;
        }
        dfs(1, 0);
        int ans = 0;
        for(int i = 2; i <= n; i++){
            if(dp[i] == 0) ans += m;
            else if(dp[i] == 1) ans += 1;
        }
        printf("%d
", ans);
    }
    return 0;
}