本来想的是三维,0表示不返回,1表示返回,2表示返回+不返回
后来转念一想2状态不是完全浪费了吗,和0完全等同
想成一个自动机,大概就是0是结束态,1是接受态(对应上面两种不返回/返回状态),1+1->1,1+0->0
有两种情况
- 1+1>1
- 1+0->0
这里还需要注意一下由于两个子树并无顺序的先后,因此还需继续讨论先后次序问题(三个讨论的具体内容见代码)
其次就是子树通过根节点联系,所以不如将根节点和左儿子合并看成一棵子树,和右儿子不断合并。
还有一个边界的问题。此题意为在子树合并完后,由于每一种情况必然都有根节点,于是给所有情况都加上根节点的代价。这里等价于一开始便给所有的dp[x]赋上x的代价较为简洁。
大概。。就是这样,噫,树形dp真恶心。。。
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
//dp x cost 0 返回x根节点
//dp x cost 1 不返回x根节点
const int maxn=1005;
struct edge
{
int to,next;
}e[maxn<<1];
int n,m,cnt;
int size[maxn],head[maxn],s[maxn];
int dp[maxn][maxn][2];
void insert(int a,int b)
{
e[++cnt].to=b;e[cnt].next=head[a];head[a]=cnt;
}
void dfs(int x,int fa)
{
size[x]=1;
for(int i=head[x];i;i=e[i].next)if(e[i].to!=fa)
{
int to=e[i].to;
dfs(to,x);
for(int j=m;j>=1;j--)//以根节点+左儿子为基础,枚举消耗的cost
{
//不以size[]作为边界,原因是不知此节点最多可以消耗多少cost(因为其可以返回)
for(int k=j;k>=1;k--)//合并右儿子
{
//j-k==0表示只有根节点,j-k<0则无任何意义,所以j<=k
if(k>=2)
dp[x][j][0]=max(dp[x][j][0],dp[x][j-k][0]+dp[to][k-2][0]);
//先遍历根节点+左儿子,返回到根节点,需要再跨越根节点到右儿子,代价+1
//返回时还需从右儿子跨越回根节点,代价再+1,共多加2代价
if(k>=2)
dp[x][j][1]=max(dp[x][j][1],dp[x][j-k][1]+dp[to][k-2][0]);
//先遍历右儿子,从根节点到右儿子+1,返回再+1,遍历根节点+左儿子,不返回
//共多加2点代价
if(k>=1)
dp[x][j][1]=max(dp[x][j][1],dp[x][j-k][0]+dp[to][k-1][1]);
//先遍历左儿子,返回根节点后再跨越+1,继续遍历右儿子不返回,共多加1点代价
}
}
}
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
cnt=0;
memset(head+1,0,sizeof(int)*n);
for(int i=1;i<=n;i++)
scanf("%d",s+i);
for(int i=1;i<n;i++)
{
int a,b;
scanf("%d%d",&a,&b);
insert(a,b);
insert(b,a);
}
for(int i=1;i<=n;i++)
{
for(int j=0;j<=m;j++)
dp[i][j][0]=dp[i][j][1]=dp[i][j][2]=s[i];
}
dfs(1,-1);
printf("%d\n",dp[1][m][1]);
}
return 0;
}