树形DP专辑-ZOJ3201(Tree of Tree)

ZOJ Problem Set - 3201

Tree of Tree

---

Time Limit: 1 Second      Memory Limit: 32768 KB

---

You're given a tree with weights of each node, you need to find the maximum subtree of specified size of this tree.

Tree Definition
A tree is a connected graph which contains no cycles.

Input

There are several test cases in the input.

The first line of each case are two integers N(1 <= N <= 100), K(1 <= K <= N), where N is the number of nodes of this tree, and K is the subtree's size, followed by a line with N nonnegative integers, where the k-th integer indicates the weight of k-th node. The following N - 1 lines describe the tree, each line are two integers which means there is an edge between these two nodes. All indices above are zero-base and it is guaranteed that the description of the tree is correct.

Output

One line with a single integer for each case, which is the total weights of the maximum subtree.

Sample Input

3 1
10 20 30
0 1
0 2
3 2
10 20 30
0 1
0 2

Sample Output

30
40

---

Author: LIU, Yaoting
Source: ZOJ Monthly, May 2009

/***************************************************
* problem:ZOJ 3201 Tree of Tree
* algorithm：树状DP+枚举或者说树状DP+背包
* author：sgx
* date：2013/09/12
****************************************************/
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn=110;

struct Edge
{
    int to;
    int next;
}edge[maxn<<1];

int dp[maxn][maxn];
int head[maxn],w[maxn];
int cnt;
int res,m,n;

inline int max(int a,int b)
{
    return a>b?a:b;
}

inline int min(int a,int b)
{
    return a<b?a:b;
}

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

inline void makemap(int from,int to)
{
     addedge(from,to);
     addedge(to,from);
}

inline void DFS(int u,int father)
{
     dp[u][1]=w[u];
     for(int i=head[u];~i;i=edge[i].next)
     {
        int v=edge[i].to;
        if(v==father)
            continue;
         else if(v!=father)
         {
             DFS(v,u);

             for(int j=m;j>=2;j--)
             {
                 for(int k=1;k<j;k++)
                 {
                     dp[u][j]=max(dp[u][j],dp[v][k]+dp[u][j-k]);
                 }
             }
         }
     }
     res=max(res,dp[u][m]);
}

int main()
{
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         cnt=0;
         memset(head,-1,sizeof(head));
         memset(dp,0,sizeof(dp));

         for(int i=0;i<n;i++)
         {
             scanf("%d",&w[i]);
         }
         for(int i=1;i<n;i++)
         {
            int u,v;
             scanf("%d%d",&u,&v);
             makemap(u,v);
         }

         res=0;
         DFS(0,-1);
         printf("%d\n",res);
     }
     return 0;
}