题意:
给出一棵树,然后从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;i<n;i++){
scanf("%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;
}