The more, The Better(hdu1561)

The more, The Better

Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7867    Accepted Submission(s): 4616

Problem Description

ACboy很喜欢玩一种战略游戏，在一个地图上，有N座城堡，每座城堡都有一定的宝物，在每次游戏中ACboy允许攻克M个城堡并获得里面的宝物。但由于地理位置原因，有些城堡不能直接攻克，要攻克这些城堡必须先攻克其他某一个特定的城堡。你能帮ACboy算出要获得尽量多的宝物应该攻克哪M个城堡吗？

Input

每个测试实例首先包括2个整数，N,M.(1
<= M <= N <= 200);在接下来的N行里，每行包括2个整数，a,b. 在第 i 行，a 代表要攻克第 i
个城堡必须先攻克第 a 个城堡，如果 a = 0 则代表可以直接攻克第 i 个城堡。b 代表第 i 个城堡的宝物数量, b >= 0。当N
= 0, M = 0输入结束。

Output

对于每个测试实例，输出一个整数，代表ACboy攻克M个城堡所获得的最多宝物的数量。

Sample Input

3 2
0 1
0 2
0 3
7 4
2 2
0 1
0 4
2 1
7 1
7 6
2 2
0 0

Sample Output

5

13

思路：树形dp+01背包;

首先这个题中是无环的。

• 7 4
• 2 2
• 0 1
• 0 4
• 2 1
• 7 1
• 7 6
• 2 2
• 这组数据所建的图：
• [0]
• /         \
• [2]          [3]
• /    |   \
• [1]   [4]   [7]
• /     \
• [5]  [6]

0为根节点，我们只能先取上面的根节点才能取下面的子节点，dp[i][j]表是以i为当前根节点的子树所取的点为j的最大值。先给dp[i][1]
= val[i]，表示当前节点必须选，其他dp[i][j] =
-1,所以要更新当前节点必然包含当前的根节点，这样保证了先后性，状态转移方程看代码（01背包）复杂度（n^3）。

 1 #include<iostream>
 2 #include<string.h>
 3 #include<algorithm>
 4 #include<queue>
 5 #include<math.h>
 6 #include<stdlib.h>
 7 #include<stack>
 8 #include<stdio.h>
 9 #include<ctype.h>
10 #include<map>
11 #include<vector>
12 #include<map>
13 using namespace std;
14 typedef long long LL;
15 int dp[300][300];
16 int cnt[300];
17 int val[300];
18 bool vis[300];
19 int s[300];
20 vector<int>vec[1000];
21 vector<int>topu[1000];
22 queue<int>que;
23 void Init()
24 {
25     while(!que.empty())
26         que.pop();
27     for(int i = 0; i < 300; i++)
28         vec[i].clear(),topu[i].clear();
29     memset(dp,-1,sizeof(dp));
30     memset(cnt,0,sizeof(cnt));
31     memset(val,0,sizeof(val));
32     memset(vis,0,sizeof(vis));
33     memset(s,0,sizeof(s));
34 }
35 void dfs(int n,int m);
36 int main(void)
37 {
38     int n,m;
39     while(scanf("%d %d",&n,&m),n!=0&&m!=0)
40     {
41         Init();
42         for(int i = 1; i <= n; i++)
43         {
44             int a,b;
45             scanf("%d %d",&a,&val[i]);
46             vec[a].push_back(i);
47             dp[i][1] = val[i];
48             dp[i][0] = 0;
49         }
50         dp[0][1] = 0;
51         dfs(0,m+1);
52         printf("%d\n",dp[0][m+1]);
53     }
54     return 0;
55 }
56 void dfs(int n,int m)
57 {
58     for(int i = 0; i < vec[n].size(); i++)
59     {
60         int id = vec[n][i];
61         dfs(id,m);
62         for(int j = m; j >= 2; j--)
63         {
64             for(int ss = 1; ss <= j-1; ss++)
65             {
66                 if(dp[id][j-ss]!=-1&&dp[n][ss]!=-1)
67                     dp[n][j] = max(dp[n][j],dp[id][j-ss]+dp[n][ss]);
68             }
69         }
70     }
71 }