Apple Tree POJ - 2486

Apple Tree POJ - 2486

题目大意：一棵点带权有根树，根节点为1。从根节点出发，走k步，求能收集的最大权值和。

树形dp。复杂度可能是O(玄学)，不会超过$O(nk^2)$。（反正这题不卡这个，考思想）参考

ans[i][j][0]表示i点以下共走j步，不回来，可能收集到最大的权值
ans[i][j][1]表示i点以下共走j步，回来，可能收集到最大的权值

比较复杂的是，每个节点（以下称当前节点）从其子节点转移的时候，需要用一个背包：

t[i][j][0]表示当前节点的前i个子节点共走j步，不回来
t[i][j][1]表示当前节点的前i个子节点共走j步，回来

对于t[i][j][0]，要么是当前节点的前i-1个子节点共走j步（包括去和回来前面的子节点所用步数），在之前就不回来；

要么是前i-1个子节点共走j-p步（包括去和回来前面的子节点所用步数），当前节点走到第i个子节点用1步，第i个子节点向下走p-1步，不回来；

要么是花一步走到第i个子节点，在第i个子节点往下走p-2步，再花一步走回当前节点，再在前i-1个子节点中走j-p步（包括去和回来前面的子节点所用步数）并且不回来。

因此t[i][j][0]=max(t[i-1][j][0],max{t[i-1][j-p][1]+ans[nowson][p-1][0]},max{t[i-1][j-p][0]+ans[nowson][p-2][1]})

对于t[i][j][1]，要么是前i-1个子节点共走j-p步（包括去和回来前面的子节点所用步数），走到第i个子节点花1步，第i个子节点向下走用p-2步并回来，从第i个子节点回来花一步；要么是前i-1个子节点共走j步（包括去和回来前面的子节点所用步数），回来。

因此t[i][j][1]=max(t[i-1][j][1],max{t[i-1][j-p][1]+ans[nowson][p-2][1]})

当然实际求解的时候并不需要每个节点开一个t数组，只需要在ans数组上直接做就行了。就是先对t数组求解过程用滚动数组优化，那么只需要两维t[j][0/1]。这时只需要把ans[当前节点]的数组当做t去做就行了。另外，求解t数组的边界要注意一下。另外，t数组再求解前就全部初始化成当前节点权值就行了。

最终答案很显然：max(ans[1][k][0],ans[1][k][1])。

曾经错误：

naive的转移方程：

t[i][j][0]=max(t[i-1][j][0],t[i-1][j-p][0],t[i-1][j-p][1]+ans[son][p][0])
t[i][j][1]=max(t[i-1][j][1],t[i-1][j-p][1]+ans[son][p][1])

事实上，这道题转移t[i][j][0]的第3种（标红的）情况很容易遗漏。另外，很容易忽略走去与走回子节点花费的1或2步。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 struct Edge
 {
     int to,next;
 }edge[];
 int ne,ans[][][],f1[];
 int a[];
 int n,k;
 bool vis[];
 void dfs(int u)
 {
     int j,kk=f1[u],p,v;
     vis[u]=true;
     for(j=;j<=k;j++)
         ans[u][j][]=ans[u][j][]=a[u];
     while(kk!=)
     {
         v=edge[kk].to;
         if(!vis[v])
         {
             dfs(v);
             for(j=k;j>=;j--)
             {
                 for(p=;p<=j;p++)
                     ans[u][j][]=max(ans[u][j][],max(ans[u][j-p][]+ans[v][p-][],ans[u][j-p][]+ans[v][p-][]));
                 for(p=;p<=j;p++)
                     ans[u][j][]=max(ans[u][j][],ans[u][j-p][]+ans[v][p-][]);
             }
         }
         kk=edge[kk].next;
     }
 }
 int main()
 {
     int i,ta,tb;
     while(scanf("%d%d",&n,&k)==)
     {
         ne=;
         memset(ans,,sizeof(ans));
         memset(vis,,sizeof(vis));
         memset(f1,,sizeof(f1));
         for(i=;i<=n;i++)
             scanf("%d",&a[i]);
         for(i=;i<n;i++)
         {
             scanf("%d%d",&ta,&tb);
             edge[++ne].to=tb;
             edge[ne].next=f1[ta];
             f1[ta]=ne;
             edge[++ne].to=ta;
             edge[ne].next=f1[tb];
             f1[tb]=ne;
         }
         dfs();
         printf("%d\n",max(ans[][k][],ans[][k][]));
     }
     return ;
 }