POJ2486【树形DP】

题意：

给出一棵树，然后从1开始走，问你走k步所能遍历到的最大权值和.

思路：

我们要求从1这个节点走K步所获得的最大值，所以dp就很容易想到>>>>>dp[node][k]: 代表从这个节点走k步的最大值。
但是在状态转移的时候，好像不能很清楚的从子节点通过某种关系到父节点。
所以套路：考虑从某个节点他最终回不回到本身。
那么转移就很容易了。
dp[i][j][0]代表从节点i走j步回到i的最大值/dp[i][j][1]代表从节点i走j步不回到i的最大值
[son] [k - 2] [0] + dp[father] [j - k] [0] => [father] [ j ] [0]
[son] [k - 2] [0] + dp[father] [j - k] [1] => [father] [ j ] [1]
[son] [k - 1] [1] + dp[father] [j - k] [0] => [father] [ j ] [1]
现在转移有了，初始化呢？
每个节点走0步回到本身: val[node];
意味着所有节点不管走多少步，最小就是本身的价值。
PS：
转移中有一个小地方，自己一开始还疑惑

  for(int j=k;j>=1;j--){
      for(p=1;p<=j;p++){

       }
  }

凭什么我里面要调用步数少的节点，却不先更新步数小的而先更新大的？
类似0/1背包，因为我每次对于这个子节点我只能用一次，
如果先枚举小的，又取小的，这个子节点不是只取了一次。
那么我对于步数小的那些dp值就是初始值？
肯定不是啊，那些步数小的dp值在其他son节点中更新了呀。

Code:

const int N=1e2+10;
struct Edge{
    int v;
    int Next;
}edge[N<<1];
int head[N],tol;
int n,k,val[N];
int dp[N][N<<1][2];
void init(){
    tol=0;
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp));
}
void add(int u,int v){
    edge[tol].v=v;
    edge[tol].Next=head[u];
    head[u]=tol++;
}
bool vis[N];
void DFS(int u){
    int j,p;
    for(int i=head[u];~i;i=edge[i].Next){
        int v=edge[i].v;
        if(vis[v]) continue;
        vis[v]=true;
        DFS(v);
        for(int j=k;j>=1;j--){
                for(p=1;p<=j;p++){
                    if(p>=2){
                        dp[u][j][0]=max(dp[u][j][0],dp[v][p-2][0]+dp[u][j-p][0]);
                        dp[u][j][1]=max(dp[u][j][1],dp[v][p-2][0]+dp[u][j-p][1]);
                    }
                    dp[u][j][1]=max(dp[u][j][1],dp[v][p-1][1]+dp[u][j-p][0]);
                }
        }
    }
}

int main(){
    int u,v;
    while(~scanf("%d%d",&n,&k)){
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&val[i]);
            for(int j=0;j<=k;j++)
                dp[i][j][0]=dp[i][j][1]=val[i];
        }
        for(int i=1;iscanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        memset(vis,false,sizeof(vis));
        vis[1]=true;
        DFS(1);
        printf("%d\n",max(dp[1][k][0],dp[1][k][1]));
    }
    return 0;
}