POJ 2486 Apple Tree - 树形DP

本来想的是三维，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;
}