POJ - 2486 :Apple Tree 树上有依赖背包

深度学习下动态规划求解：最大遍历权值问题

最新推荐文章于 2022-11-21 16:51:26 发布

原创最新推荐文章于 2022-11-21 16:51:26 发布 · 71 阅读

0 ·

CC 4.0 BY-SA版权

本文讲解了如何使用深度优先搜索（DFS）结合状态转移方程，解决在一棵树中从根节点出发，走k步时，最大化遍历权值的问题。着重于理解重复路径和是否返回节点的影响，并提供了相应的代码实现。

传送门

题目描述

一颗树，n个点（1-n），n-1条边，每个点上有一个权值，求从1出发，走k步，最多能遍历到的权值。

分析

首先我们可以去dfs每一个为为根节点的时候，子树走 $k$ 步的时候的最大权值，但这里涉及到一位问题，因为每一条边可以重复走，所以会不会有回头的情况
我们用 $f [i] [j] [0 / 1]$ 表示在 $i$ 点的时候，走 $k$ 步，是否返回 $i$ 节点的情况下所能获得的最大权值，然去去状态转移就可以了

如果返回 $u$ 点，那么
$f [u] [j + 2] [1] = m a x (f [u] [j + 2] [1], f [u] [j - k] [1] + f [v] [k] [1]);$
如果不返回 $u$ 点，停留在子树中
$f [u] [j + 1] [0] = m a x (f [u] [j + 1] [0], f [u] [j - k] [1] + f [v] [k] [0]);$
如果不返回 $u$ 点，不停留在子树中
$f [u] [j + 2] [0] = m a x (f [u] [j + 2] [0], f [u] [j - k] [0] + f [v] [k] [1]);$

代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>

using namespace std;

const int N = 500,M = N;
int h[N],ne[M],e[M],idx;
int a[N];
int f[N][N][2];
int n,li;

void add(int x,int y){
    ne[idx] = h[x],e[idx] = y,h[x] = idx++;
}

void dfs(int u,int fa){
    for(int i = 0;i <= li;i++) f[u][i][0] = f[u][i][1] = a[u];
    for(int i = h[u];~i;i = ne[i]){
        int v = e[i];
        if(v == fa) continue;
        dfs(v,u);
        for(int j = li;j >= 0;j--)
            for(int k = 0;k <= j;k++){
                f[u][j + 2][1] = max(f[u][j + 2][1],f[u][j - k][1] + f[v][k][1]);
                f[u][j + 1][0] = max(f[u][j + 1][0],f[u][j - k][1] + f[v][k][0]);
                f[u][j + 2][0] = max(f[u][j + 2][0],f[u][j - k][0] + f[v][k][1]);
            }
    }
}

int main(){
    while(~scanf("%d%d",&n,&li)){
        memset(h,-1,sizeof h);
        idx = 0;
        for(int i = 1;i <= n;i++) scanf("%d",&a[i]);
        for(int i = 1;i < n;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            add(x,y),add(y,x);
        }
        memset(f,0,sizeof f);
        dfs(1,-1);
        printf("%d\n",max(f[1][li][1],f[1][li][0]));
    }
    return 0;
}