POJ 2486 Apple Tree 树形dp+背包

题意：

给一棵苹果树 ，树上有n个结点，每个结点有 ai个苹果，（不存在父子关系），让求最多走k步之后可以吃到的最多的苹果数目，（走动必须在相邻结点之间进行发生，从一个结点到另一个相邻结点是需要消耗一个步数。），每次都先从结点1开始走。

思路：首先看到这个题就要先想起树形结构，然后这道题只存在相邻关系，即是一个无向树，

此题让求最多走k步可以吃到的苹果数目，

所以状态可以先表示成在x结点 最多走k步可以吃到的最多的苹果数目；

存在两种可能 的决策

1：从根节点x出发，走k步后会返回到根结点x 表示为dp[ x ][ k ][ 0 ];

2： 从根节点x出发，走k步后不返回到根结点x 表示为dp[ x ][ k ][ 1 ];

由两种总决策可以退出下面三种子决策；

dp[0][x][j+2]=Max(dp[0][x][j+2],dp[0][son][k]+dp[0][x][j-k]);//从x出发，要回到x，需要多走两步x-son,son-x,分配给son子树k步，其他子树j-k步，都返回
dp[1][x][j+2]=Max(dp[1][x][j+2],dp[0][son][k]+dp[1][x][j-k]);//不回到s（去s的其他子树），在t子树返回，同样有多出两步

dp[1][x][j+1]=Max(dp[1][x][j+1],dp[1][son][k]+dp[0][x][j-k]);//先遍历x的其他子树，回到x，遍历son子树，在当前子树son不返回，多走一步

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <ctime>
#include <map>
#include <queue>
#define LL long long
#define INF 0x3f3f3f3f
#define bug puts("***************")
using namespace std;
const int N =210;
vector<int>vec
;
int dp

[2];
bool vis
;
int a
;
int n,m;
void dfs(int x){
int len=vec[x].size();
dp[x][0][1]=dp[x][0][0]=a[x];
vis[x]=1;
for(int i=0;i<len;i++){
int son=vec[x][i];
if(vis[son]) continue;
dfs(son);
for(int j=m;j>=0;j--){
for(int k=0;k<=j;k++){
int &d0=dp[x][j+2][0];
int &d1=dp[x][j+2][1];
d0=max(d0,dp[x][k][0]+dp[son][j-k][0]);
dp[x][j+1][1]=max(dp[x][j+1][1],dp[x][k][0]+dp[son][j-k][1]);
d1=max(d1,dp[x][k][1]+dp[son][j-k][0]);
}
}
}
}
int main(){
while(~scanf("%d%d",&n,&m)){
memset(vec,0,sizeof(vec));
memset(dp,0,sizeof(dp));
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
int v,u;
for(int i=0;i<n-1;i++){
scanf("%d%d",&u,&v);
vec[u].push_back(v);
vec[v].push_back(u);
}
dfs(1);
int ans=0;
for(int i=0;i<=m;i++){ ///可能存在走不到m步的情况，比如 1 1 1 ，此数据就不许走动，输出为1；
ans=max(ans,max(dp[1][i][0],dp[1][i][1]));
}
printf("%d\n",ans);
}
return 0;
}