POJ3345 Bribing FIPA（树形DP）

题意：有n个国家，贿赂它们都需要一定的代价，一个国家被贿赂了从属这个国家的国家也相当于被贿赂了，问贿赂至少k个国家的最少代价。

这些国家的从属关系形成一个森林，加个超级根连接，就是一棵树了，考虑用DP：

• dp[u][m]表示以u国家为根的子树贿赂m个国家的最少代价

单单这样的话转移是指数级的，其实这题就是树上背包，同HDU1516。现在觉得想明白了，其实就是所有结点为根做n次01背包，每次01背包的物品就是当前根的各个儿子。

状态加一维度表示，转移就可以不是指数级了：

• dp[u][n][m]表示以u国家为根的前n个儿子构成的子树贿赂m个国家的最少代价

然后其实循环利用内存，像01背包一样省去一维背包从大到小枚举，然后就是那样了。。

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<string>
 #include<algorithm>
 using namespace std;
 #define INF (1<<29)
 #define MAXN 222

 struct Edge{
     int u,v,next;
 }edge[MAXN];
 int NE,head[MAXN];
 void addEdge(int u,int v){
     edge[NE].u=u; edge[NE].v=v; edge[NE].next=head[u];
     head[u]=NE++;
 }

 int n,k,cost[MAXN],d[MAXN][MAXN],size[MAXN];
 void getsize(int u){
     size[u]=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         getsize(v);
         size[u]+=size[v];
     }
 }
 void dfs(int u){
     if(u) d[u][size[u]]=cost[u];
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         dfs(v);
         for(int j=size[u]; j>=; --j){
             for(int k=; k<j; ++k) d[u][j]=min(d[u][j],d[u][k]+d[v][j-k]);
         }
     }
 }

 bool read(char *&s,int &t){
     if(sscanf(s,"%d",&t)!=) return ;
     while(*s==' ') ++s;
     while(*s>='' && *s<='') ++s;
     while(*s==' ') ++s;
     return ;
 }
 bool read(char *&s,char *str){
     if(sscanf(s,"%s",str)!=) return ;
     while(*s==' ') ++s;
     while(*s && *s!=' ') ++s;
     while(*s==' ') ++s;
     return ;
 }

 char str[];
 string name[MAXN<<];
 int main(){
     int w[MAXN]; char ts[MAXN];
     while(gets(str) && str[]!='#'){
         char *s=str;
         read(s,n); read(s,k);

         int nn=;
         vector<string> vec[MAXN];
         for(int i=; i<n; ++i){
             gets(str); s=str;
             read(s,ts); name[nn++]=ts; vec[i].push_back(ts);
             read(s,w[i]);
             while(read(s,ts)){
                 name[nn++]=ts; vec[i].push_back(ts);
             }
         }
         sort(name+,name+nn);
         nn=unique(name+,name+nn)-name;

         NE=;
         memset(head,-,sizeof(head));
         int deg[MAXN]={};
         for(int i=; i<n; ++i){
             int u=lower_bound(name+,name+nn,vec[i][])-name;
             cost[u]=w[i];
             for(int j=; j<vec[i].size(); ++j){
                 int v=lower_bound(name+,name+nn,vec[i][j])-name;
                 addEdge(u,v); ++deg[v];
             }
         }
         for(int i=; i<=n; ++i){
             if(deg[i]==) addEdge(,i);
         }

         getsize();
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j) d[i][j]=INF;
         }
         dfs();
         int res=INF;
         for(int i=k; i<=n; ++i) res=min(res,d[][i]);
         printf("%d\n",res);
     }
     return ;
 }