poj1947

这道题挺有意思的，标签是树形DP加背包。

一眼看过去其实状态挺好想的，显然根为x的子树取j个点可以形成最优子问题的解。

不过这道题的转移方程有点特殊，因为在不取某一个点的时候不是单纯的不去处理他就好了，而是也会对当前这个状态的值产生影响。

所以需要提前先取一个值表示取到这棵子树的时候不取这个点，然后再去比较取了这个点的值。

转移方程为： 首先取一个tmp=dp[x][j]+1;表示以x为根的子树取了j个点，但是当前扫到这棵子树不取点

　　然后枚举这棵子树取的点数 tmp=min(tmp,dp[v][j-k]+dp[x][k]);

最后把tmp值赋给dp即可

因为标签是加了背包的嘛，所以实际做的时候应该能察觉到，这题枚举状态的时候也就是x为根的树取j个点的时候，j的枚举需要从大到小，以避免同一棵子树一直被取。

下附代码：

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int INF=0X3f3f3f3f;
int head[155],Next[305],to[305],tot=0,n,p,flag[155],dp[155][155];
void add(int a,int b){
    Next[tot]=head[a],to[tot]=b;
    head[a]=tot++;
}
void dfs(int x,int pre){
    dp[x][1]=0;
    for (int i=head[x]; i!=-1; i=Next[i]){
        int v=to[i];
        if (v!=pre){
            dfs(v,x);
            for (int j=p; j>0; j--){
                int tmp=dp[x][j]+1;
                for (int k=1; k<j; k++){
                    if (dp[v][j-k]+dp[x][k]<tmp){
                        tmp=dp[v][j-k]+dp[x][k];
                    }
                }
                dp[x][j]=tmp;
            }
        }
    }
}
int main(){
    while (scanf("%d%d",&n,&p)!=EOF){
        tot=0;
        memset(dp,INF,sizeof(dp));
        memset(flag,0,sizeof(flag));
        for (int i=1; i<=n; i++) head[i]=-1;
        for (int i=1; i<n; i++){
            int a,b;
            scanf("%d%d",&a,&b);
            flag[b]=1;
            add(a,b);
            add(b,a);
        }
        int root;
        for (int i=1; i<=n; i++){
            if (!flag[i]) {
                root=i;
                break;
            }
        }
        dfs(root,-1);
        int res=dp[root][p];
        for (int i=1; i<=n; i++){
            if (res>dp[i][p]+1)
                res=dp[i][p]+1;
        }
        printf("%d
",res);
    }
    return 0;
}