poj 1947 Rebuilding Roads (树形dp)

给一棵树，问最少减掉几条边能得到一棵p个节点的树。

算法：

dp[i][j]表示以i为根的子树要变成有j个节点的状态需要减掉的边数。

考虑状态转移的时候不考虑i的父亲节点，就当不存在。最后统计最少减去边数的

时候+1。

 考虑一个节点时，有两种选择，要么剪掉跟子节点相连的边，则dp[i][j] = dp[i][j]+1;

 要么不剪掉，则d[i][j] = max(dp[i][j], dp[i][k]+dp[son][j-k]);

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>

using namespace std;

vector<int> v[160];
int dp[160][160],fa[160],p,n;

int minn(int a,int b)
{
    return a<b?a:b;
}

void dfs(int r,int pre)
{
    int s = v[r].size();
    dp[r][1]=0;
    for(int k=0;k<s;k++)
    {
        int to=v[r][k];
        if(to==pre) continue;
        dfs(to,r);
        for(int i=p;i>=0;i--)
        {
            int tmp=dp[r][i]+1;
            for(int j=1;j<i;j++)
                tmp=minn(tmp,dp[r][j]+dp[to][i-j]);
            dp[r][i]=tmp;
        }
    }
}

int main()
{
    int a,b,root;
    while(scanf("%d%d",&n,&p)!=EOF)
    {
        memset(dp,0x3f,sizeof(dp));
        memset(fa,0,sizeof(fa));

        for(int i=0;i<n-1;i++)
        {
            scanf("%d%d",&a,&b);
            v[a].push_back(b);
            fa[b]=a;
        }
        for(int i=1;i<=n;i++)
        {
            if(!fa[i])
            {
                root=i;
                break;
            }
        }
        dfs(root,-1);
        int ans=dp[root][p];
        for(int i=1;i<=n;i++)
            ans=minn(dp[i][p]+1,ans);
        printf("%d\n",ans);
    }
    return 0;
}