poj1947 Rebuilding Roads

本题是给定一棵树(n, n - 1)，试问最少去掉多少条边能够得到一个节点数恰为m(1≤ m ≤ n)的子树（连通块）。

这是一道动态规划题，也就是说最终的最优解(答案）需要靠子问题的状态转移来合成。

考虑一颗根节点为u的树(T)，u的子节点集合为 V = { v1, ...，vk }。

我们试着推导通过对T进行删边操作得到一颗节点数为i的子树T1所删的边的最小数目dp[u][i]，其中u ∈ T1。

则有：

①若T1 ∩ T（v1) ≠ ∅，则dp[u][i] = min{ dp[v1][j] + dp[u][i - j] }, 0 ≤ j ≤ i。

②若 T1 ∩ T（v1) = ∅， 则 dp[u][i] = 1 + dp[u][i]。

实际上在递归过程中相当于把各个子树当成物品求价值后用背包的方式更新父节点的最优值。

http://poj.org/problem?id=1947

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 150 + 10;
const int inf = 0x3f3f3f3f;
int dp[maxn][maxn];
int n, m, N;
int cnt[maxn];
struct Edge{
    int to, next;
}edge[maxn];
int root;
int head[maxn];

void addEdge(int u, int v){
    edge[N].next = head[u];
    edge[N].to = v;
    head[u] = N++;
}

void dfs(int u){
    //assume that T(u) is an isolated tree
    dp[u][1] = 0;
    for(int i = head[u]; i + 1; i = edge[i].next){
        int v = edge[i].to;
        dfs(v);
        for(int j = m; j >= 1; j--){
            int tem = dp[u][j] + 1;
            for(int k = 1; k < j; k++){//spilt j
                tem = min(tem, dp[u][k] + dp[v][j - k]);
            }
            dp[u][j] = tem;
        }
    }
}

int main(){
    while(~scanf("%d%d", &n, &m)){
        N = 0;
        memset(head, -1, sizeof head);
        memset(cnt, 0, sizeof cnt);
        for(int i = 1, x, y; i < n; i++){
            scanf("%d%d", &x, &y);
            ++cnt[y];
            addEdge(x, y);
        }
        for(int i = 1; i <= n; i++){
            if(!cnt[i]){
                root = i;
                break;
            }
        }
        memset(dp, inf, sizeof dp);
        dfs(root);
        int ans = dp[root][m];
        for(int i = 1; i <= n; i++) ans = min(ans, dp[i][m] + 1);
        printf("%d
", ans);
    }
    return 0;
}