树形DP入门

HDU1011：

一棵树，有n个结点，每个结点有v个bug，有w的brain。我从1号结点开始走，带着m个战士。

1个战士可以消灭20个bugs，如果我把某个结点的所有bug都消灭了我就能得到那个结点的brain。

如果想攻击当前结点，那么必须先攻击了它的父结点（1号点除外）。

其中当你攻占了当前结点，你可以分派人手，走向几个不同的子结点，去攻占更多。也就是说，不是单一的路径。

# include<stdio.h>
# include<string.h>
# define N 105
struct node{
    int from,to,next;
}edge[2*N];
int head[N],tol,visit[N],ans[N],bug[N],n,m,dp[N][N],f[N][N];
void add(int a,int b)
{
    edge[tol].from=a;edge[tol].to=b;edge[tol].next=head[a];head[a]=tol++;
}
int max(int a,int b)
{
    return a>b?a:b;
}
void dfs(int u)
{
    int i,j,r,tt,k;
    visit[u]=1;
    for(i=head[u];i!=-1;i=edge[i].next)
    {
        r=edge[i].to;
        if(!visit[r])
        {
            dfs(r);
            for(k=m;k>=1;k--)
            {
                for(j=1;j<=k;j++)
                {
                    f[u][k]=max(f[u][k],f[u][k-j]+dp[r][j]);
                }
            }
                /*for(j=0;j<=m;j++)
                {
                if(j*20>=ans[u])
                    dp[u][j]=max(dp[u][j],dp[r][(j*20-ans[u])/20]+bug[u]);
                }*/
        }
    }
    tt=(ans[u]+19)/20;
    for(j=tt;j<=m;j++)
        dp[u][j]=f[u][j-tt]+bug[u];
}
int main()
{
    int i,a,b;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==-1 && m==-1) break;
        for(i=1;i<=n;i++)
            scanf("%d%d",&ans[i],&bug[i]);
        tol=0;
        memset(head,-1,sizeof(head));
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        memset(visit,0,sizeof(visit));
        memset(dp,0,sizeof(dp));
            memset(f,0,sizeof(f));
                    if(m==0)
        {
            printf("0\n");
            continue;
        }

        dfs(1);
        printf("%d\n",dp[1][m]);
    }
    return 0;
}