本来今天刷题春风得意，直到被这道题卡住才意识到自己有多么蠢。

以前的树形背包都是子节点依赖父节点，而这一题却要求父节点依赖其所有子节点。

我喊了一句：这特么在逗我？然后我就傻了。

想了一个小时，想不出来，然后去看题解。

这题有经典做法和VFK的新做法两种，我这种人自然优先选了前者。

这题算是把我对树形DP的闭塞理解给打通了一点。

我本认为树形DP只有用子节点的状态去更新父节点的状态，真是太天真了。

实际上这道题里是用子节点的状态合并得到父节点的状态。

首先，设出状态f[i][j][k]表示节点i对父亲的贡献为j付出的代价为k时i节点及其子树可以得到的最多能量。

dp当然要从初始状态推起咯。

那么对于那些叶子节点，也就是所谓的基本装备:

f[i][j][j*cost[i]]=(j-i)*power[i]

然而对于那些非叶子节点:

f[i][j][k]=max{g[k-r]+f[son][j*need[son]][r]};

这个方程具体点的解释可以理解为预算为k，拨给这个项目经费为r。

注意在这里我们并没有对f[i][j][k]中这一层中“私吞”部分进行统计，所以是j*need[son]，也就是假设全部先上交。

此处g数组是对上一次f[i][j]的复制，防止出现值的误调用。

此处循环考虑的因素比较多，所以总不能一边调用f[i][j]一边更新f[i][j]吧。memcpy多方便。

然后我们开始统计私吞部分:

f[i][j][k]=max{f[i][j'][k]+(j'-j)*power[i]}

事实上,(j'-j)*power[i]就是没有用于合成(即上交)的i装备产生的能量。

非常巧妙，可惜这状态我想不到，还是经验问题。

Tips:注意挖掉一些非法状态和缩小lim范围。

------------------------------------------------------------------------------------------------------------------------------------------------

Code:

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
 
const int N=70;
const int P=110;
const int M=2010;
const int INF=~0u>>1;
 
struct list{
    int p;
    list *next;
    list(){}
    list* Set(int _p,list* _next){
        p=_p; next=_next;
        return this; 
    }
}T[M],*head[N];int data=0;
int f[N][P][M],g[M],need[N];
int n,m,pow[N],cost[N],lim[N];
int fa[N],ans=-INF;
//F[i][j][k]表示i物品贡献给父节点j个花费k的最大力量
 
void dfs(int p){
    if(!head[p]){
        lim[p]=min(lim[p],m/cost[p]);
        for(int i=0;i<=lim[p];i++)
            for(int j=i;j<=lim[p];j++)
                f[p][i][j*cost[p]]=(j-i)*pow[p];
            //底层信息 
        return;
    }
    lim[p]=INF;
    for(list *t=head[p];t;t=t->next){
        dfs(t->p);
        lim[p]=min(lim[p],lim[t->p]/need[t->p]);
    }
    for(int i=0;i<=lim[p];i++) f[p][i][0]=0;
     //装备合成本身不需要代价，所以合并之前初始化为０
    for(list *t=head[p];t;t=t->next){
        for(int j=0;j<=lim[p];j++){
            memcpy(g,f[p][j],sizeof(f[p][j]));
            memset(f[p][j],-1,sizeof(f[p][j]));
            for(int k=m;k>=0;k--)
                for(int r=k;r>=0;r--)
                    if(g[k-r]!=-1&&f[t->p][j*need[t->p]][r]!=-1){
                        f[p][j][k]=max(f[p][j][k],g[k-r]+f[t->p][j*need[t->p]][r]);
                        //假设全部上交 
                        ans=max(ans,f[p][j][k]); 
                    }
        }
    ｝／／对子树信息进行合并
    for(int i=0;i<=lim[p];i++) 
        for(int j=i;j<=lim[p];j++) 
            for(int k=0;k<=m;k++) 
                if(f[p][j][k]!=-1) 
                    f[p][i][k]=max(f[p][i][k],f[p][j][k]+(j-i)*pow[p]),ans=max(ans,f[p][i][k]);
                    //将节点自身信息并入 
}
 
int main(){
    char opt;int t,u,v;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d \n%c\n",&pow[i],&opt);
        if(opt=='B') scanf("%d%d",&cost[i],&lim[i]);
        if(opt=='A'){
            for(scanf("%d",&t);t;t--){
                scanf("%d%d",&u,&v);
                head[i]=(T+(data++))->Set(u,head[i]);
                need[u]=v; fa[u]=i;
            }
        }
    }memset(f,sizeof(f));
    for(int i=1;i<=n;i++) if(!fa[i]) dfs(i);
    printf("%d\n",ans);
    return 0;
}