hdu 4616 Game 树形dp

最新推荐文章于 2021-05-25 11:51:06 发布

原创最新推荐文章于 2021-05-25 11:51:06 发布 · 780 阅读

1 ·

CC 4.0 BY-SA版权

ACM刷题记录同时被 3 个专栏收录

106 篇文章

订阅专栏

HDU

30 篇文章

订阅专栏

DP- 树形dp

3 篇文章

订阅专栏

本文介绍了一种利用树形动态规划解决迷宫逃脱问题的方法，迷宫由n个房间构成，每个房间内可能有物品和陷阱，玩家需要在不落入C次陷阱的情况下，从任意点出发获取最大价值的物品。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：　http://acm.hdu.edu.cn/showproblem.php?pid=4616

题意

有ｎ个房间构成的一棵树，每个房间都有一定价值的礼物，价值可能不相同，有礼物的同时还可能有陷阱，而且每个房间不能重复经过，如果掉入陷阱Ｃ次或者没有路可以走了那么游戏结束，求从任意点出发能获得礼物的最大价值。

解题思路

树形ｄｐ。

dp[i][j][0] 表示从ｉ的子树上某点出发经过ｊ次陷阱获得的最大价值，且出发点不是陷阱
dp[i][j][１] 表示从ｉ的子树上某点出发经过ｊ次陷阱获得的最大价值，且出发点是陷阱

状态转移为当ｊ< C 时，
若ｉ是陷阱
dp[i][j+1][flag] = max{dp[son[i]][j][flag] + val[i]};
若ｉ不是陷阱
dp[i][j][flag] = max{dp[son[i]][j][flag] + val[i]};

当ｊ == C时，i肯定不是陷阱,起点肯定是陷阱，否则肯定可以从起点往下继续走，也就是当前ｄｐ不是最优的
dp[i][C][1] = max(dp[i][C][1],dp[son[i]][C][1] + val[i]);

最后更新ans的时候，可以看成两条链合并，枚举每条链上陷阱个数，取最优值。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <algorithm>
#include <functional>
#include <cmath>
#include <bitset>
using namespace std;

typedef long long LL;
const int inf = 1<<28;
const int maxn = 50010;
struct Edge{
    int to,next,w;
}e[maxn*2];

bool trap[maxn];
LL val[maxn];
int head[maxn],cnt;
int N,C;
LL dp[maxn][5][2];
LL ans;

void init(){
    cnt = 0;
    memset(head,-1,sizeof(head));
}

void add(int u,int v){
    e[cnt].to = v;
    e[cnt].next = head[u];
    head[u] = cnt++;
}

void dfs(int u,int fa){
    for(int i=0;i<=C;i++){
        dp[u][i][0] = dp[u][i][1] = -inf;
    }
    dp[u][trap[u]][trap[u]] = val[u];
    for(int i=head[u]; i!=-1; i=e[i].next){
        int v = e[i].to;
        if(v == fa) continue;
        dfs(v,u);
        for(int j=0;j<=C;j++){
            for(int k=0;k+j<=C;k++){
                if(j<C) ans = max(ans,dp[u][j][0] + dp[v][k][1]);
                if(k<C) ans = max(ans,dp[u][j][1] + dp[v][k][0]);
                if(j+k < C) ans = max(ans,dp[u][j][0] + dp[v][k][0]);
            }
        }
        for(int j=0;j<C;j++){
            dp[u][j+trap[u]][0] = max(dp[u][j+trap[u]][0], dp[v][j][0] + val[u]);
            dp[u][j+trap[u]][1] = max(dp[u][j+trap[u]][1], dp[v][j][1] + val[u]);
        }
        if(!trap[u]) dp[u][C][1] = max(dp[u][C][1], dp[v][C][1]+val[u]);
    }
}

int main(){
    int T;
    cin >> T;
    while(T--){
        cin >> N >> C;
        init();
        for(int i=0;i<N;i++) cin >> val[i] >> trap[i];
        int u,v;
        for(int i=0;i<N-1;i++){
            cin >> u >> v;
            add(u,v);
            add(v,u);
        }
        ans = 0;
        dfs(0,-1);
        cout << ans << endl;
    }
    return 0;
}