bzoj1017: [JSOI2008]魔兽地图DotR[树形DP+依赖型背包]

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

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

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

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

这题有经典做法和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
;int data=0;
int f
[P][M],g[M],need
;
int n,m,pow
,cost
,lim
;
int fa
,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,-1,sizeof(f));
for(int i=1;i<=n;i++) if(!fa[i]) dfs(i);
printf("%d\n",ans);
return 0;
}

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