Starship Troopers

Problem Description

You, the leader of Starship Troopers, are sent to
destroy a base of the bugs. The base is built underground. It is actually a huge
cavern, which consists of many rooms connected with tunnels. Each room is
occupied by some bugs, and their brains hide in some of the rooms. Scientists
have just developed a new weapon and want to experiment it on some brains. Your
task is to destroy the whole base, and capture as many brains as
possible.

To kill all the bugs is always easier than to capture their
brains. A map is drawn for you, with all the rooms marked by the amount of bugs
inside, and the possibility of containing a brain. The cavern‘s structure is
like a tree in such a way that there is one unique path leading to each room
from the entrance. To finish the battle as soon as possible, you do not want to
wait for the troopers to clear a room before advancing to the next one, instead
you have to leave some troopers at each room passed to fight all the bugs
inside. The troopers never re-enter a room where they have visited
before.

A starship trooper can fight against 20 bugs. Since you do not
have enough troopers, you can only take some of the rooms and let the nerve gas
do the rest of the job. At the mean time, you should maximize the possibility
of capturing a brain. To simplify the problem, just maximize the sum of all the
possibilities of containing brains for the taken rooms. Making such a plan is a
difficult job. You need the help of a computer.

Input

The input contains several test cases. The first line
of each test case contains two integers N (0 < N <= 100) and M (0 <= M
< = 100), which are the number of rooms in the cavern and the number of
starship troopers you have, respectively. The following N lines give the
description of the rooms. Each line contains two non-negative integers -- the
amount of bugs inside and the possibility of containing a brain, respectively.
The next N - 1 lines give the description of tunnels. Each tunnel is described
by two integers, which are the indices of the two rooms it connects. Rooms are
numbered from 1 and room 1 is the entrance to the cavern.

The last test
case is followed by two -1‘s.

Output

For each test case, print on a single line the
maximum sum of all the possibilities of containing brains for the taken
rooms.

Sample Input

5 10

50 10

40 10

40 20

65 30

70 30

1 2

1 3

2 4

2 5

1 1

20 7

-1 -1

Sample Output

50

7

 1 #include"iostream"
2 #include"vector"
3 #include"cstring"
4 using namespace std;
5 const int size=105;
6 int r,t;
7 int cost[size],brain[size];
8 int dp[size][size];
9 vector<int> adj[size];
10 void dfs(int p,int pre);
11 int main()
12 {
13 while(cin>>r>>t)
14 {
15 if(r==-1&&t==-1)
16 break;
17 int bug,a,b,i;
18 for(i=0;i<r;i++)
19 {
20 cin>>bug>>brain[i];
21 cost[i]=(bug+19)/20;
22 }
23 for(i=0;i<r;i++)
24 {
25 adj[i].clear();
26 }
27 for(i=0;i<r-1;i++)
28 {
29 cin>>a>>b;
30 adj[a-1].push_back(b-1);
31 adj[b-1].push_back(a-1);
32 }
33 if(t==0)
34 {
35 cout<<‘0‘<<endl;
36 continue;
37 }
38 memset(dp,0,sizeof(dp));
39 dfs(0,-1);
40 cout<<dp[0][t]<<endl;
41 }
42 return 0;
43 }
44 void dfs(int p,int pre)
45 {
46 for(int i=cost[p];i<=t;i++)
47 {
48 dp[p][i]=brain[p];
49 }
50 int num=adj[p].size();
51 for(int i=0;i<num;i++)
52 {
53 int v=adj[p][i];
54 if(v==pre)
55 continue;
56 dfs(v,p);
57 for(int j=t;j>=cost[p];j--)
58 for(int k=1;k<=j-cost[p];k++)
59 {
60 if(dp[p][j]<dp[p][j-k]+dp[v][k])
61 {
62 dp[p][j]=dp[p][j-k]+dp[v][k];
63 }
64 }
65 }
66 }

Starship Troopers,布布扣,bubuko.com

时间: 2024-11-03 22:25:03

Starship Troopers的相关文章

HDU 1011 Starship Troopers(树形dp+背包)

Starship Troopers Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 13109    Accepted Submission(s): 3562 Problem Description You, the leader of Starship Troopers, are sent to destroy a base of

HDU 1011 Starship Troopers(树形DP)

Starship Troopers Time Limit : 10000/5000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total Submission(s) : 62   Accepted Submission(s) : 12 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description You, the leader of

hdu 1011 Starship Troopers(树形DP入门)

Starship Troopers Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 17498    Accepted Submission(s): 4644 Problem Description You, the leader of Starship Troopers, are sent to destroy a base of t

hdu 1011 Starship Troopers (依赖背包 树形dp)

题目: 链接:点击打开链接 题意: n个房间组成一棵树,你有m个战队,从1号房间开始依次clear每个房间,在每个房间需要花费的战队个数是bugs/20,得到的价值是the possibility of capturing a brain,求最大的价值. 算法: 树形dp,有依赖的背包问题.(依次clear每个房间) 思路: 状态转移dp[i][j]表示根结点为i时(房间i)花费j个战队能够得到的最大价值(捕捉到一个brain最大的可能值).递归求出每个根结点处的最大值,最后dp[1][m]就是

hdu 1011 Starship Troopers DP

Starship Troopers Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 11929    Accepted Submission(s): 3295 Problem Description You, the leader of Starship Troopers, are sent to destroy a base of

BNUOJ 5235 Starship Troopers

Starship Troopers Time Limit: 5000ms Memory Limit: 32768KB This problem will be judged on HDU. Original ID: 101164-bit integer IO format: %I64d      Java class name: Main You, the leader of Starship Troopers, are sent to destroy a base of the bugs. T

HDU-1011 Starship Troopers (树形DP+分组背包)

题目大意:给一棵有根带点权树,并且给出容量.求在不超过容量下的最大权值.前提是选完父节点才能选子节点. 题目分析:树上的分组背包. ps:特判m为0时的情况. 代码如下: # include<iostream> # include<cstdio> # include<vector> # include<cstring> # include<algorithm> using namespace std; const int N=105; const

Starship Troopers(HDU 1011 树形DP)

题意: 给定n个定点和m个士兵,n个定点最终构成一棵树,每个定点有一定x个bugs和y个value,每20个bug需要消耗一个士兵,不足20也消耗一个,然后最终收获y个value,只有父节点被占领后子节点才有被占领的可能. DP状态转移方程: dp[p][j]=max(dp[p][j],dp[p][j-k]+dp[t][k]); 看的王大神的代码,DFS写的,先从叶子节点开始向上遍历进行动态规划,自己看了dp方程也没写出来.. 1 #include <iostream> 2 #include

hdu_1011(Starship Troopers) 树形dp

题目连接:http://acm.hdu.edu.cn/showproblem.php?pid=1011 题意:打洞洞收集脑子,你带领一个军队,洞洞互联成一棵树,每个洞中有一些bug,要全部杀死这些虫子才可以取得这个洞中的脑子,只有杀死当前节点的bug才可以继续走下去,且如果有0个bug你仍要派遣一个士兵在这里,只不过可以士兵不停留. 题解:很清晰明了的树形dp了,但是某些人说过写题解就要写细致...所以我们还是来详细讲解一下树形dp吧... 树形dp: 这是一个很裸的树形dp,和一般的dp不同的