hdu 1011 Starship Troopers（树DP）

Starship Troopers

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 7621    Accepted Submission(s): 2090

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
  
  

 

Author

XU, Chuan

 

Source

ZJCPC2004

 

Recommend

JGShining

题意：派一些士兵去攻打隧道的bugs，一个士兵打20个bugs，给出隧道的结点的关系，给出每个点有多少bugs，而士兵打攻打必须打了该点，才能攻打与该点联通的下一点，每一个点有一定的价值，从点1出发，问最大价值。

题解：（由于本人在熟悉静态邻接表，所以用的是静态邻接表结构存图）士兵都从1出发，然后留足够的人攻打一个点，然后可能分开几条路继续进行，所以就算结点都0 bugs也要至少派一个士兵去获得该点价值。（不过题意有问题，该题是叶子结点为0也需要士兵，其他为0不需要）用dfs+dp，dp【i】【j】代表结点 i 有 j 个人的最大价值，用深搜，然后由叶子逆推上去汇合处，将 dp 【i】【j】 值 j 个士兵分一部分出去给其中一条路进行dp转移，每条路都逐一尝试分出至少一个士兵，转移方程如下：dp[x][i]=MAX(dp[x][i],dp[x][i-j]+dp[v[temp].data][j]); 到达 x 结点的时候还有 i 个人，但是由于 x 结点必须攻打，所以分出去的 j个人必不能使剩下的 i-j 个人不够打下结点 x ，而剩下的 i-j个人可能有一部分攻打结点 x 一部分分出去另一条路。这个dp我是看别人代码的，我的理解就是上面那样，而其中最巧妙我觉得是如果顺推就等于完全深搜，效率必须很慢，但是逆推的深搜+dp 就一次过算出结果了

#include<stdio.h>
#include<string.h>
int wei[105],val[105],p[105];
int mark[105],dp[105][105],n,m;
struct linjiebiao{
    int data,next;
}v[205];
int MAX(int a,int b)
{
    return a>b?a:b;
}
void dfs(int x)
{
    int cost=(wei[x]+19)/20;
    int temp=p[x],i,j;

    mark[x]=1;
    for(i=cost;i<=m;i++) dp[x][i]=val[x];
    while(temp!=-1)
    {
        if(!mark[v[temp].data])
        {
            dfs(v[temp].data);
            for(i=m;i>=cost;i--)
                for(j=1;j<=i-cost;j++)
                dp[x][i]=MAX(dp[x][i],dp[x][i-j]+dp[v[temp].data][j]);
        }
        temp=v[temp].next;
    }
}
int main()
{
    int i,num,x,y;

    while(scanf("%d%d",&n,&m),n!=-1||m!=-1)
    {
        memset(p,-1,sizeof(p));
        memset(mark,0,sizeof(mark));
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++) scanf("%d%d",wei+i,val+i);
        for(num=i=0;i<n-1;i++)
        {
            scanf("%d%d",&x,&y);
            v[num].next=p[y];
            v[num].data=x;
            p[y]=num++;
            v[num].next=p[x];
            v[num].data=y;
            p[x]=num++;
        }
        if(m==0){ printf("0\n"); continue; }
        dfs(1);
        printf("%d\n",dp[1][m]);
    }

    return 0;
}