pku 3345 && pku 3107

两道树形DP； 

http://acm.pku.edu.cn/JudgeOnline/problem?id=3345

题意：一共有n（<=200）个国家, 你想要用收买m(<=m)个国家，其中收买国家i的代价是v[ i ]。但是有些国家有拥属关系，如果A拥属B国，就是买通了A也意味着买通了B，而且这些关系是传递的。

dp[i][j]表示：以i为根节点在其子树中收买j个国家花费的最小值；

状态转移：dp[idx][j+k]=min(dp[idx][j+k],dp[idx][j]+dp[map[idx][i]][k]，Tree[idx].dim);

map[idx][i]]为idx的第i颗子树；

Tree[idx].dim为idx的第idx个结点的贿赂金额；

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<cmath>
using namespace std;
const int N = 250;
const int inf= 1<<30;
int   n,m,dp[N][N],used[N],map[N][N],num[N];
struct Node
{
      char name[105];
      int  father;
      int  dim;
      int  cnt;
      char child[N][105];
      void Init()
      {
           father=cnt=0;     
      }
}Tree[N];
int find(char str[])
{
      for(int i=1;i<=n;i++)
              if(!strcmp(Tree[i].name,str)) return  i;                                  
}
void Bulid_Map()
{
      for(int i=1;i<=n;i++)
      {
              for(int j=0;j<Tree[i].cnt;j++)
              {
                      int idx=find(Tree[i].child[j]);
                      map[i][num[i]++]=idx;
                      Tree[idx].father=1;
              }         
      }
      for(int i=1;i<=n;i++)
              if(!Tree[i].father) map[0][num[0]++]=i;     
      Tree[0].cnt=1,Tree[0].dim=inf;       
}
void  dfs(int idx)
{
      dp[idx][0]=0;
      if(Tree[idx].cnt==0)
      {
              dp[idx][1]=Tree[idx].dim;
              return ;
      }
      used[idx]=1;
      for(int i=0;i<num[idx];i++)
      {
              if(used[map[idx][i]]) continue;
              dfs(map[idx][i]);
              for(int j=m;j>=0;j--)
              {
                 if(dp[idx][j]==-1) continue;
                 for(int k=1;k<=m;k++)
                 {
                        if(dp[map[idx][i]][k]==-1)  continue;
                        if(dp[idx][j+k]==-1)
                                dp[idx][j+k]=dp[idx][j]+dp[map[idx][i]][k];
                        else    dp[idx][j+k]=min(dp[idx][j+k],dp[idx][j]+dp[map[idx][i]][k]);         
                        if(dp[idx][j+k]>Tree[idx].dim) dp[idx][j+k]=Tree[idx].dim;
                 }   
              }
      }
      for(int i=n;i>=0;i--)
      {
              if(dp[idx][i]!=-1)
              {
                        dp[idx][i+1]=Tree[idx].dim;
                        break;
              }    
      }
}
int   main()
{
      char s[1000];
      while(gets(s))
      {
            if(s[0]=='#')  break;
            int h=0,l=strlen(s);
            while(s[h]!=' ') h++;
            n=m=0;
            for(int k=h-1;k>=0;k--)
            {
                    int t=(int)pow(10.0,h-1-k);
                    n+=(s[k]-'0')*t; 
            }
            for(int k=strlen(s)-1;k>h;k--)
            {
                    int t=(int)pow(10.0,l-1-k);
                    m+=(s[k]-'0')*t; 
            }
            for(int i=1;i<=n;i++) Tree[i].Init();
            for(int i=1;i<=n;i++)
            {
                    scanf("%s",&Tree[i].name);
                    scanf("%d",&Tree[i].dim);
                    while(getchar()==' ')
                    {
                            scanf("%s",&Tree[i].child[Tree[i].cnt]);
                            Tree[i].cnt++;        
                    }              
            } 
            memset(dp,-1,sizeof(dp));
            memset(used,0,sizeof(used));
            memset(num,0,sizeof(num));
            Bulid_Map();
            dfs(0);
            printf("%d/n",dp[0][m]);
      }
      return 0;
}
http://acm.pku.edu.cn/JudgeOnline/problem?id=3107

题意：给你一棵无向树T，要求依次去除树中的某个结点，求去掉该结点后变成的森林T'中的最大分支。并要求该分支为去除的结点中为最小的。（注意：答案可能有多个）。

即求：树结点最大分支量的最小值所对应的结点。

dp[i]表示以i为根节点的子树的结点数；

然后枚举删掉每个结点idx后得到的最大分支，其最大分支为max（dp[u],n-dp[idx]-1）；

^^...就是时间太长了。。1400++ms才A掉。。。。

代码：

#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;
const int N = 50005;
const int inf = 1<<30;
struct Node
{
       int vdx;
       Node *next;
}*Tree[N],nome[N*100]; 
int n,k,dp[N],used[N],sign[N],best;
void addedge(int from,int to)
{
       Node*ptr=&nome[k++];
       ptr->vdx=to;
       ptr->next=Tree[from];
       Tree[from]=ptr; 
}
void dfs(int idx,int prev)
{
       int Min_Max=-1;
       for(Node *ptr=Tree[idx];ptr;ptr=ptr->next)
       {
                 int u=ptr->vdx;
                 if(u==prev) continue;
                 dfs(u,idx);
                 dp[idx]+=dp[u]+1;
                 if(dp[u]+1>Min_Max)  Min_Max=dp[u]+1;                  
       }
       if(n-dp[idx]-1>Min_Max)  Min_Max=n-dp[idx]-1;
       if(Min_Max<best)
       {
                memset(sign,0,sizeof(sign));   
                sign[idx]=1;
                best=Min_Max;
       }
       else if(Min_Max==best)sign[idx]=1;
}
int main()
{
          while(scanf("%d",&n)!=EOF)
          {
                  k=0,best=inf;
                  for(int i=1;i<=n;i++)
                              Tree[i]=NULL;                   
                  int u,v;
                  for(int i=1;i<n;i++)
                  {
                              scanf("%d%d",&u,&v);
                              addedge(u,v);
                              addedge(v,u);
                  }
                  memset(dp,0,sizeof(dp));
                  dfs(1,0);
                  int j=0;
                  for(;j<=n;j++) if(sign[j]){printf("%d",j);break;}
                  for(j++;j<=n;j++) if(sign[j]){printf(" %d",j);}
                  printf("/n");
         
          }
          return 0;
}