poj 1947 树形dp

思路：dp[i][j]表示，以i节点为根，删去j个节点最少要断几条边。

那么dp[u][j]=min(dp[u][j],dp[v][k]+dp[u][j-k]);//选取最优状态

dp[u][j]=min(dp[u][j],dp[u][j-son[v]]+1);//切断与子节点相连的边

对于子节点

dp[v][n-son[v]]=1;

dp[v][j]=min(dp[v][j],dp[v][j-n+son[v]]+1)//表示不需要由父节点过来的那条分支

最有从所有状态中选举最优的dp[i][n-p];

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Maxn 160
#define Maxm 200010
#define LL __int64
#define Abs(x) ((x)>0?(x):(-x))
#define lson(x) (x<<1)
#define rson(x) (x<<1|1)
#define inf 0x7fffffff
#define Mod 1000000007
using namespace std;
int head[Maxn],vi[Maxn],e,dp[160][160],n,p,son[160],root[Maxn];
struct Edge{
    int u,v,next;
}edge[Maxm];
void init()
{
    memset(head,-1,sizeof(head));
    memset(vi,0,sizeof(vi));
    memset(son,0,sizeof(son));
    for(int i=1;i<=155;i++){
        root[i]=i;
        for(int j=1;j<=155;j++){
            dp[i][j]=200;
        }
        dp[i][0]=0;
    }
    e=0;
}
void add(int u,int v)
{
    edge[e].u=u,edge[e].v=v,edge[e].next=head[u],head[u]=e++;
    edge[e].u=v,edge[e].v=u,edge[e].next=head[v],head[v]=e++;
}
void dfs(int u)
{
    int i,v,j,k;
    vi[u]=1;
    son[u]=1;
    for(i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].v;
        if(vi[v]) continue;
        dfs(v);
        son[u]+=son[v];
        for(j=n-1;j>=1;j--){
            for(k=1;k<=j;k++){
                dp[u][j]=min(dp[u][j],dp[u][j-k]+dp[v][k]);
            }
            if(j>=son[v])
            dp[u][j]=min(dp[u][j],dp[u][j-son[v]]+1);
        }
        dp[v][n-son[v]]=1;
        for(j=n-1;j>=n-son[v];j--)
        dp[v][j]=min(dp[v][j],dp[v][j-n+son[v]]+1);
    }
}
int main()
{
    int i,j,u,v;
    while(scanf("%d%d",&n,&p)!=EOF){
        init();
        for(i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            add(u,v);
        }
        if(p==n){
            printf("0\n");
            continue;
        }
        if(p==n-1)
        {
            printf("1\n");
            continue;
        }
        dfs(1);
        int ans=200;
        for(i=1;i<=n;i++){
            ans=min(ans,dp[i][n-p]);
        }
        printf("%d\n",ans);
    }
    return 0;
}