poj 1947 经典树形dp

经典树形dp：问在一棵树上最少删除多少条边可以分离出一个节点数为p的子树。

定义状态：

　　dp[i][j]表示从i为根的子树上分离出一个节点数为j的子树的代价（最少需要删除的边数）。

　　考虑i节点的每个儿子ii，ii可以选或者不选（切断），然后就转化成了背包问题。

　　dp[u][j] = min( dp[u][j], dp[u][j - k] + dp[v][k] );

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int INF = 9999999;
const int N = 151;
int dp[N][N];
int head[N];
int f[N];
int n, p, e;

void init()
{
    e = 0;
    memset( f, -1, sizeof(f) );
    memset( head, -1, sizeof(head) );
}

struct Edge
{
    int v, next;
} edge[N];

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

void dfs( int u )
{
    dp[u][1] = 0;
    for ( int i = 2; i <= p; i++ )
    {
        dp[u][i] = INF;
    }
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        dfs(v);
        for ( int j = p; j >= 1; j-- )
        {
            dp[u][j]++;
            for ( int k = 1; k <= j - 1; k++ )
            {
                dp[u][j] = min( dp[u][j], dp[u][j - k] + dp[v][k] );
            }
        }
    }
}

int main ()
{
    while ( scanf("%d%d", &n, &p) != EOF )
    {
        init();
        for ( int i = 1; i < n; i++ )
        {
            int u, v;
            scanf("%d%d", &u, &v);
            addEdge( u, v );
            f[v] = u;
        }
        int root;
        for ( root = 1; f[root] != -1; root = f[root] ) ;
        dfs(root);
        int ans = dp[root][p];
        for ( int i = 1; i <= n; i++ )
        {
            if ( i == root ) continue;
            ans = min( ans, dp[i][p] + 1 );
        }
        printf("%d
", ans);
    }
    return 0;
}