HDU 4616 树形DP + 限制求最大贡献值的路

树形DP + 限制求最大贡献值的路

题意：

有一棵树节点为0~n，每一个节点都有一个值，但是有的节点会有陷阱，现在让从任意一个点出发能获得的最大值和是多少，限制为1. 不能进入陷阱的次数超过k次，当等于k 的是很好立刻停止，2. 每一个节点最多走一次。

思路：

题意很明显是找到一条最大的一条路，并且最多进入k次陷阱，可以看成一点从两个儿子的走路中的最大值，这样可以暴力，但是超时了。

那么就需要用数据结构进行存储了，如果能把每一个节点的儿子到这个节点的情况都记录，那么只需进行一次dfs 就能找出最大值。

因为陷阱是有限制的分为四种情况：

1. 一条最大路两端都是陷阱
2. 一条路两端只有一个是陷阱（左右两种）
3. 两端都不是陷阱的情况只适合于路上的陷阱没有k次

定义：$dp[u][j][0/1]$ 表示u的儿子节点到u，路上经过了j次陷阱能获得的最大值和，0表示儿子起点为非陷阱，1表示起点是陷阱。那么对于第一种情况适合于j <= k 的所有情况，第二种情况最多存在一个端点是陷阱

第三种j < k ，所以处理这四种情况，然后每次更新dp[u] 的所有情况。

• 注意：只要按照dp 的含义去定义去更新就不会存在bug的情况，所以说意义很重要
• 当trap[u] == 0，j = k 的时候，可以存在一端是陷阱。

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

using namespace std;

const int maxn = 50005;
const long long inf = 1LL<<60;

int n,k,pos;
long long ans,dp[maxn][5][2];
int head[maxn],val[maxn],trap[maxn];

struct Node
{
    int e,next;
}edge[maxn*2];

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

int main(int argc, char const *argv[])
{
    //freopen("in.txt","r",stdin);

    int tt;
    scanf("%d",&tt);
    while(tt--) {
        scanf("%d%d",&n,&k);
        for(int i = 0;i < n; i++) {
            for(int j = 0;j < 5; j++) {
                dp[i][j][0] = dp[i][j][1] = -inf;
            }
            head[i] = -1;
        }
        for(int i = 0;i < n; i++) {
            scanf("%d%d",&val[i],&trap[i]);
        }
        pos = 0;
        for(int i = 0;i < n-1; i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            edge[pos].e = b;
            edge[pos].next = head[a];
            head[a] = pos++;
            edge[pos].e = a;
            edge[pos].next = head[b];
            head[b] = pos++;
        }
        ans = 0;
        dfs(0,-1);
        printf("%I64d\n",ans);
    }

    return 0;
}