HDU 4169 Wealthy Family（树形DP）

Problem Description

While studying the history of royal families, you want to know how wealthy each family is. While you have various 'net worth' figures for each individual throughout history, this is complicated by double counting caused by inheritance. One way to estimate the wealth of a family is to sum up the net worth of a set of k people such that no one in the set is an ancestor of another in the set. The wealth of the family is the maximum sum achievable over all such sets of k people. Since historical records contain only the net worth of male family members, the family tree is a simple tree in which every male has exactly one father and a non-negative number of sons. You may assume that there is one person who is an ancestor of all other family members.

 

Input

The input consists of a number of cases. Each case starts with a line containing two integers separated by a space: N (1 <= N <= 150,000), the number of people in the family, and k (1 <= k <= 300), the size of the set. The next N lines contain two non-negative integers separated by a space: the parent number and the net worth of person i (1 <= i <= N). Each person is identified by a number between 1 and N, inclusive. There is exactly one person who has no parent in the historical records, and this will be indicated with a parent number of 0. The net worths are given in millions and each family member has a net worth of at least 1 million and at most 1 billion.

 

Output

For each case, print the maximum sum (in millions) achievable over all sets of k people satisfying the constraints given above. If it is impossible to choose a set of k people without violating the constraints, print 'impossible' instead.

 

题目大意：给n个点，每个点有一个权值，要求选k个点，这k个点任意一个点不能为其他点的父节点，求最大总权值。

思路：树形DP。ex[i]代表从开始遍历到某点x及其子节点（包括x）选i个点可以得到的最大总权值，now[i]代表从开始遍历到某点x及其子节点（不包括x）选i个点可以得到的最大总权值，函数一开始的时候ex是代表遍历到x之前的选i个点可以得到的最大总权值，那么在dfs算出now之后，ex[i] = max(now[i], ex[i-1] + a)就可以保证没有选的两个点是不符合要求的。

 

 #include <cstdio>
 #include <cstring>

 const int MAXN = ;

 int head[MAXN], next[MAXN], to[MAXN];
 int a[MAXN];
 int ecnt, n, k;
 int ans[];

 inline void addEdge(int u, int v) {
     to[ecnt] = v;
     next[ecnt] = head[u]; head[u] = ecnt++;
     //printf("%d->%d\n",u,v);
 }

 inline void init() {
     memset(head, , sizeof(head));
     memset(ans, , sizeof(ans));
     ecnt = ;
     int f;
     for(int i = ; i <= n; ++i) {
         scanf("%d%d", &f, &a[i]);
         addEdge(f, i);
     }
 }

 inline void _max(int &a, const int &b) {
     if(a < b) a = b;
 }

 void dfs(int u, int *ex) {
     int *now = new int[];
     for(int i = ; i <= k; ++i) now[i] = ex[i];
     for(int p = head[u]; p; p = next[p]) {
         dfs(to[p], now);
     }
     ex[] = ;
     for(int i = k; i > ; --i) {
         ex[i] = now[i];
         if(ex[i-] != -) {
             _max(ex[i], ex[i-] + a[u]);
         }
     }
     delete [] now;
 }

 int main() {
     while(scanf("%d%d", &n, &k) != EOF) {
         init();
         dfs(,ans);
         if(ans[k] == -) puts("impossible");
         else printf("%d\n", ans[k]);
     }
     return ;
 }