HDU 1011 Starship Troopers 树形DP 有坑点

本来是一道很水的树形DP题

设dp[i][j]表示，带着j个人去攻打以节点i为根的子树的最大收益

结果wa了一整晚

原因：

坑点1：

即使这个节点里面没有守卫，你如果想获得这个节点的收益，你还是必须派一个人去这个节点，不然谁帮你去拿收益？

坑点2：

题目说是从节点1开始攻打，然后我就以为给出的数据都是以1为根节点的，就没有加双向边

不过，

最后我加了双向边，然后还是wa了

又找了很久，最后发现是前向星的数组开小了

注意：数组开小了可能会返回wa，tle，re等等等等

 

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=110;

int dp[maxn][maxn];
int bug[maxn];
int val[maxn];

struct Edge
{
    int to,next;
};
Edge edge[maxn<<1];
int head[maxn];
int tot,n,m;

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

void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

int solve();

int main()
{
    while(scanf("%d %d",&n,&m)){
        if(n==-1&&m==-1)
            break;
        init();
        for(int i=1;i<=n;i++){
            int u;
            scanf("%d %d",&u,&val[i]);
            bug[i]=(u+19)/20;
        }
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d %d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }

        printf("%d
",solve());
    }
    return 0;
}

void dfs(int u,int pre)
{
    if(bug[u]>m)
        return ;
    for(int i=bug[u];i<=m;i++)
        dp[u][i]=val[u];
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].to;
        if(v==pre)
            continue;
        dfs(v,u);
        for(int j=m;j>=bug[u];j--){
            for(int k=1;k<=j-bug[u];k++){
                dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]);
            }
        }
    }
}

int solve()
{
    if(m==0)
        return 0;
    memset(dp,0,sizeof dp);
    dfs(1,-1);

    return dp[1][m];
}