HDU 5834 Magic boy Bi Luo with his excited tree 树形DP

最新推荐文章于 2024-05-22 17:32:19 发布

转载最新推荐文章于 2024-05-22 17:32:19 发布 · 258 阅读

树形dp 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一种使用树形动态规划解决特定问题的方法：给定一棵带边权的树，求从每个节点出发能获得的最大宝藏价值。文章通过定义w1和w2两个辅助数组来记录不同情况下的最大值，并通过两次深度优先搜索实现解决方案。

参考http://www.cnblogs.com/qscqesze/p/5771193.html
挺经典的

题意

给你一棵树，边有边权，每经过边一次，就得支付过路费c[i]，点上面有宝藏，每个点只能拿一次。

问从每个点出发，能够拿到的最大值是多少？

有空自己做一下

#include <bits/stdc++.h>
#define INF 1000000007
#define FI first
#define SE second
#define PB emplace_back
#define VI vector<int>
using namespace std;
typedef long long LL;
typedef pair <int, int> P;
const int NUM = 100010;
struct edge {int next, to, cost;} e[NUM * 2];
int head[NUM], tot;
void gInit() {memset(head, -1, sizeof(head)); tot = 0;}
void add_edge(int u, int v, int c)
{
    e[tot] = (edge) {head[u], v, c};
    head[u] = tot++;
}
int n, V[NUM], w1[NUM], w2[NUM], id[NUM], ans[NUM];
//w1是从该点出发最后回到该点的最大值
//w2是从该点出发有一次不回来的最大值
//id是不回来的路的子树根节点
void dfs1(int u, int fa)
{
    w1[u] = V[u];
    w2[u] = V[u];
    id[u] = -1;
    for(int i = head[u]; ~i; i = e[i].next) {
        int v = e[i].to;
        if(v == fa) continue;
        dfs1(v, u);
        int tmp = max(0, w1[v] - e[i].cost - e[i].cost);
        int tmmp = w1[u] + max(0, w2[v] - e[i].cost);
        w2[u] += tmp;
        if(w2[u] < tmmp) {
            w2[u] = tmmp;
            id[u] = v;
        }
        w1[u] += tmp;
    }
}
//sum1同w1,sum2同w2
void dfs2(int u, int fa, int sum1, int sum2)
{
    ans[u] = max(w1[u] + sum2, w2[u] + sum1);
    int W1 = w1[u];
    int W2 = w2[u];
    int Id = id[u];
    W2 += sum1;
    if(W2 <= W1 + sum2) {
        W2 = W1 + sum2;
        Id = fa;
    }
    W1 += sum1;
    for(int i = head[u]; ~i; i = e[i].next) {
        int v = e[i].to;
        if(v == fa) continue;
        if(v == Id) {
            int tmp1 = sum1 + V[u], tmp2 = sum2 + V[u];
            for(int j = head[u]; ~j; j = e[j].next) {
                int vv = e[j].to;
                if(vv == fa || v == vv) continue;
                int tmp = max(0, w1[vv] - e[j].cost - e[j].cost);
                tmp2 = max(tmp1 + max(0, w2[vv] - e[j].cost), tmp2 + tmp);
                tmp1 += tmp;
            }
            tmp1 = max(0, tmp1 - e[i].cost - e[i].cost);
            tmp2 = max(0, tmp2 - e[i].cost);
            dfs2(v, u, tmp1, tmp2);
        }
        else {
            int tmp = max(0, w1[v] - e[i].cost - e[i].cost);
            int tmp1 = max(0, W1 - tmp - e[i].cost - e[i].cost);
            int tmp2 = max(0, W2 - tmp - e[i].cost);
            dfs2(v, u, tmp1, tmp2);
        }
    }
}
int main()
{
    int T; scanf("%d", &T);
    for(int cas = 1; cas <= T; ++cas) {
        gInit();
        scanf("%d", &n);
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &V[i]);
        }
        for(int i = 1; i < n; ++i) {
            int u, v, c;
            scanf("%d%d%d", &u, &v, &c);
            add_edge(u, v, c);
            add_edge(v, u, c);
        }
        dfs1(1, -1);
        dfs2(1, -1, 0, 0);
        printf("Case #%d:\n", cas);
        for(int i = 1; i <= n; ++i)
            printf("%d\n", ans[i]);
    }
    return 0;
}