[HDU1011]-Starship Troopers

Starship Troopers

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Problem Description

You, the leader of 星级队员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
  
  
  
  

   
   题目描述：你是星际队长分配给你M个队员，你需要走访N个房间(不允许再次走相同的房间)，每个房间中有一定比例
  
  
  
  

   
   的
   
   brain(能量)
   
   但是如果想要得到brain，你需要留下一些队员来消灭bug，每个队员能消灭20个bug，有N个房间的
  
  
  
  

   
   描述：每个房间有n个bug和m
   
   比率的brain，然后会提供给你N-1行来描述房间之间的相邻情况。
  
  
  
  

   
   解题思路：首先就是建立模型，第一眼能想到的是，无向图问题，要利用树形结构来解答，然后进一步看，每个房间
  
  
  
  

   
   有选择权，选
   
   或不选，那么我们就清楚了，DP思维，最终我们定位其为树形DP，由于一个房间多个相邻的房间，
  
  
  
  

   
   那么就需要用到dfs来进行搜索其
   
   所有相邻的房间，总的来说是树形DP入门题所以看看代码也就差不多了。
  
  
  
  

   
   
<span style="color:#cc6600;">#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <list>
#include <utility>
typedef __int64 LL;
using namespace std;
const int MAXM = 0x3f3f3f3f;
const int MAXN = 20000+10;
const double PI  = acos(-1);
const double eps = 1e-8l;
const int MOD = 1000000007;
#define CLR(a,b) memset((a),(b),sizeof(a))
inline int maxx(int a,int b,int c)
{
	return (a=(a>b?a:b)>c?a:c);
}
inline int minn(int a,int b,int c)
{
	return (a=(a>b?b:a)>c?c:a);
}
const int maxn = 110;
int roomNmber,trooperNumber;
vector<int> graph[maxn];//图
bool vis[maxn];//标记走过的点
int cost[maxn];//需要多少个士兵
int brain[maxn];//有多少个brain
int dp[maxn][maxn];//dp[u][v]表示用v个士兵占领以u为节点的子树所能获得的概率最大值
void dfs(int num)
{
	int tmp = cost[num];
	for(int i = tmp;i <= trooperNumber;++ i)//初始化,，消耗tmp个士兵，最少能得到的能量数
		dp[num][i] = brain[num];
	vis[num]=1;//标记
	for(int i = 0;i < graph[num].size();++ i)//寻找所有与之相邻的room号，体现了dfs思想
	{
		int nextRoom = graph[num][i];//下一个相邻的room
		if(vis[nextRoom])					//标记是否遍历过
			continue;
		dfs(nextRoom);//对下一个进行搜寻
		for(int j = trooperNumber;j >= tmp;-- j)//nextRoom节点要么选，要么不选
		{
			for(int k = 1;k <= j-tmp;++ k)
				dp[num][j] = max(dp[num][j],dp[num][j-k]+dp[nextRoom][k]);
		}
	}
}
int main()
{
		ios::sync_with_stdio(false);
		// freopen("data1011.in","r",stdin);
		while(cin>>roomNmber>>trooperNumber&&(roomNmber+trooperNumber!=-2))
		{
			memset(graph,0,sizeof(graph));
			memset(vis,0,sizeof(vis));
			memset(dp,0,sizeof(dp));
			for(int i = 1;i <= roomNmber;++ i)
			{
				int bug;
				cin>>bug>>brain[i];
				cost[i] = (bug+19)/20;//要派多少个士兵
			}
			for(int i = 1;i < roomNmber;++ i)
			{
				int x,y;
				cin >> x >> y;
				graph[x].push_back(y);
				graph[y].push_back(x);
			}
			if(trooperNumber==0) //如果发现trooperNumber的值为0当然不会得到brain
			{
				cout << 0 << endl;
				continue;
			}
			dfs(1);//出发点是1号位置
			cout << dp[1][trooperNumber] << endl;
	}
	return 0;
}
</span>