HDU 1011 Starship Troopers

题目大意：给出一张树形的地图，然后每个节点就是一个洞，每个洞里面有bugs和brain,现在给出我方有m个骑兵,每个骑兵可以消灭20个bugs,经过的洞穴不能再回头,要收服每个洞穴里面的brain就必须消灭每个洞穴里面的全部bugs,求最大的brain

 

思路:树形DP.

第一次做很纠结,dp的路很漫长..一开始各种纠结,所幸跟羽哥讨论了一便之后思路清晰蛮多了,感谢羽哥...嘿嘿

对于x个节点来说.dp[x][i]表示在x洞穴用i个骑兵可以收服的brain的数目.其实就是01背包的稍加变形.

for(i=1;i<=n;i++)

  for(int j=m;j>=r;j--)

      for(int k=1;k<=j-r;j++)                                    //k<=j-r 即是:k+r<=j,即等会用于:对于当前节点使用剩下的骑兵k在子节点能够收服的brain值.

              dp[x][j]=max(dp[x][j],dp[x][j-k]+dp[i][k]);// i是x的子节点.这就是说:x节点收服brain的最大值等于:  max(本身初始化的值 ,本身+剩下骑兵的情况下子节点收服的brain值)

整个过程DFS下去再回朔,不用标记,因为这是树,只需要标记下前缀就可以了.因为数据有可能是:反树的方向给出,我一开始就只是考虑单方向所以WA了两次.囧..

所以就迫不得已给双方向,再协助pre这个前缀辅助变量就可以保证肯定是按树来遍历了.

 

 

AC Program(无注释版)

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<algorithm> 
#include<string.h>
using namespace std;
int map[110][110];
int bug[110];
int bra[110];
int vis[110];
int dp[110][110];
int n,m;
void  dfs(int x,int pre)
{
    int tr=(bug[x]+19)/20;
    for(int i=m;i>=tr;i--)
        dp[x][i]=bra[x];
    for(int i=1;i<=n;i++)
    {
       if(map[x][i]&&pre!=i)
       {
          dfs(i,x);
          for(int j=m;j>=tr;j--)
            {
               for(int k=1;k<=j-tr;k++)
                  {
                     dp[x][j]=max(dp[x][j],dp[x][j-k]+dp[i][k]);     
                  }      
            }                      
       }      
    }     
} 
int main()
{
while(cin>>n>>m && (n!=-1||m!=-1))
{
   for(int i=1;i<=n;i++)
       cin>>bug[i]>>bra[i];
   int a,b;
   memset(map,0,sizeof(map));
   memset(dp,0,sizeof(dp));
   for(int i=1;i<n;i++)
       {
          cin>>a>>b;
          map[a][b]=1;
          map[b][a]=1;     
       }                
   if(m==0)
   {
     cout<<0<<endl;
     continue;      
   }
   dfs(1,-1);
   cout<<dp[1][m]<<endl;
}
return 0;} 

 

 

AC program(注释版):

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<algorithm> 
#include<string.h>
//#include<map>
using namespace std;
int map[110][110];
int bug[110];
int bra[110];
int vis[110];
int dp[110][110];
int n,m;
//dp[x][j]表示在i洞派出j个骑兵获取的brain值
//dp[x][j]=max{dp[x][j],dp[x][j-k]+dp[i][k]};
void  dfs(int x,int pre)//巧妙设立一个前驱.便于判断是否是以树的状态遍历下去 
{
    int tr=(bug[x]+19)/20;
    for(int i=m;i>=tr;i--)//初始化很重要,因为是边界条件 
        dp[x][i]=bra[x];//进入这个洞,只要派出的人数不小于这个洞的bug的
                       //都可以至少获得这个洞brain值这么大的brain 
    for(int i=1;i<=n;i++)
    {
       if(map[x][i]&&pre!=i)
       {
          dfs(i,x);
          for(int j=m;j>=tr;j--)
            {
               for(int k=1;k<=j-tr;k++)
                  {
                     dp[x][j]=max(dp[x][j],dp[x][j-k]+dp[i][k]);     
                  }      
            }                      
       }      
    }     
} 
int main()
{
while(cin>>n>>m && (n!=-1||m!=-1))
{
   for(int i=1;i<=n;i++)
       cin>>bug[i]>>bra[i];
   int a,b;
   memset(map,0,sizeof(map));
   memset(dp,0,sizeof(dp));
/*   for(int i=1;i<=n;i++)
     cout<<dp[i]<<" ";
   cout<<endl;*/
   for(int i=1;i<n;i++)
       {
          cin>>a>>b;
          map[a][b]=1;//有向树  虽然说是树的状态,但是给出的有可能是反过来的数据,所以最好,双向  
          map[b][a]=1;     
       }                
   if(m==0)
   {
     cout<<0<<endl;
     continue;      
   }
   dfs(1,-1);
   cout<<dp[1][m]<<endl;
}
//system("pause");
return 0;}