POJ 2486 Apple Tree（树形dp）

http://poj.org/problem?id=2486

题意：

有n个点，每个点有一个权值，从1出发，走k步，最多能获得多少权值。（每个点只能获得一次）

思路：

从1点开始，往下dfs，对于每个结点，把时间分配给它的子节点，然后求一个最大值。

但是要注意的是，它有可能会走了之后然后又走回到父亲结点，这样的话，状态转移方程需要多考虑一下。

d【u】【j】【0/1】表示从u结点出发走 j 时所能获得的最大权值（0/1表示是否返回u结点）。

 d[u][j][]=max(d[u][j][],d[u][j-t][] + d[v][t-][]);
 d[u][j][]=max(d[u][j][],d[u][j-t][] + d[v][t-][]);
 d[u][j][]=max(d[u][j][],d[u][j-t][] + d[v][t-][]);

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<sstream>
 #include<vector>
 #include<stack>
 #include<queue>
 #include<cmath>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long ll;
 typedef pair<int,int> pll;
 const int INF = 0x3f3f3f3f;
 const int maxn = +;

 int n, k;

 int val[maxn];
 int vis[maxn];

 vector<int> g[maxn];

 int d[maxn][maxn][];

 void dfs(int u)
 {
     vis[u]=;
     for(int i=;i<g[u].size();i++)
     {
         int v=g[u][i];
         if(vis[v]) continue;
         dfs(v);
         for(int j=k;j>=;j--)
         {
             for(int t=;t<=j;t++)
             {
                 d[u][j][]=max(d[u][j][],d[u][j-t][]+d[v][t-][]);
                 d[u][j][]=max(d[u][j][],d[u][j-t][]+d[v][t-][]);
                 d[u][j][]=max(d[u][j][],d[u][j-t][]+d[v][t-][]);
             }
         }
     }
 }

 int main()
 {
     //freopen("in.txt","r",stdin);
     while(~scanf("%d%d",&n, &k))
     {
         for(int i=;i<=;i++)  g[i].clear();
         memset(d,,sizeof(d));

         for(int i=;i<=n;i++)
         {
             scanf("%d",&val[i]);
             for(int j=;j<=k;j++)
                 d[i][j][]=d[i][j][]=val[i];
         }

         for(int i=;i<n;i++)
         {
             int u,v;
             scanf("%d%d",&u,&v);
             g[u].push_back(v);
             g[v].push_back(u);
         }

         memset(vis,,sizeof(vis));
         dfs();
         printf("%d\n",max(d[][k][],d[][k][]));
     }
     return ;
 }