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=;

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

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

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

 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==-&&m==-)
             break;
         init();
         for(int i=;i<=n;i++){
             int u;
             scanf("%d %d",&u,&val[i]);
             bug[i]=(u+)/;
         }
         for(int i=;i<n;i++){
             int u,v;
             scanf("%d %d",&u,&v);
             addedge(u,v);
             addedge(v,u);
         }

         printf("%d\n",solve());
     }
     return ;
 }

 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=;k<=j-bug[u];k++){
                 dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]);
             }
         }
     }
 }

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

     return dp[][m];
 }