<hdu5834 Magic boy Bi Luo with his excited tree> (树形DP)

题意:一棵树有点权和边权 从每个点出发 走过一条边要花费边权同时可以获得点权 边走几次就算几次花费 点权最多算一次

   问每个点能获得的最大价值

题解:好吧 这才叫树形DP入门题

   dp[i][0]表示从i节点的儿子中走又回到i的最大值 dp[i][1]表示不回到i的最大值 dp[i][2]表示不回到i的次大值

   同时需要记录不回到i最大值的方向id[x]

   很显然 第一遍dfs可以预处理每个节点往下的值 然后关键的就是每个节点从父亲这个方向的值怎么处理

   有个很显然的结论就是 不回来是肯定比回来更优的 所以重点就是在处理不回来的这个支路在哪

   如果对于x节点其父亲的id[fa] = x 那么显然x,fa不回来的最大值是同一个支路 这个时候就可以更新两种答案

   在x下面的儿子中不回来 dp[x][1] = dp[x][1] += max(0, dp[fa][0] - cost[x][fa] * 2)

   在fa中的其他儿子中不回来就用到了次大 dp[x][1] = dp[x][0] + dp[fa][2] - cost[x][fa]

   如果id[fa] != x  dp[x][1] = dp[x][0] + dp[fa][1] - cost[x][fa]

   最后再更新dp[x][0] = dp[x][0] + max(0, dp[fa][0] - cost[x][fa] * 2) 同时转移的时候次大 以及最大的方向都要更新

   不过这里的dp值显然都是要减去重复计算的部分 具体代码见

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
using namespace std;

int n, cnt;
int q[100005];
int dp[100005][3];
int du[100005];
int head[100005];
int id[100005];

struct node
{
    int no, to, nex, val;
}E[200005];

void dfs1(int x, int fa)
{
    dp[x][0] = q[x];
    dp[x][1] = q[x];
    dp[x][2] = q[x];
    int c = head[x];
    for(int i = c; i; i = E[i].nex)
    {
        int v = E[i].to;
        if(v == fa) continue;

        dfs1(v, x);
        if(E[i].val * 2 < dp[v][0]) dp[x][0] += dp[v][0] - E[i].val * 2;
    }

    for(int i = c; i; i = E[i].nex)
    {
        int v = E[i].to;
        if(v == fa) continue;

        int tmp = dp[x][0];
        if(E[i].val * 2 < dp[v][0]) tmp += E[i].val * 2 - dp[v][0];

        if(tmp + dp[v][1] - E[i].val >= dp[x][1])
        {
            dp[x][2] = dp[x][1];
            dp[x][1] = tmp + dp[v][1] - E[i].val;
            id[x] = v;
        }
        else if(tmp + dp[v][1] - E[i].val > dp[x][2]) dp[x][2] = tmp + dp[v][1] - E[i].val;

        dp[x][2] = max(dp[x][2], dp[x][0]);
    }
}

void dfs2(int x, int fa)
{
    int c = head[x];
    for(int i = c; i; i = E[i].nex)
    {
        int v = E[i].to;
        if(v != fa) continue;

        int tmp0 = dp[fa][0];
        int tmp1 = dp[fa][1];
        int tmp2 = dp[fa][2];
        if(E[i].val * 2 < dp[x][0])
        {
            tmp0 += E[i].val * 2 - dp[x][0];
            if(id[fa] != x) tmp1 += E[i].val * 2 - dp[x][0];
            else tmp2 += E[i].val * 2 - dp[x][0];
        }
        tmp0 = max(tmp0, 0); tmp1 = max(tmp1, 0); tmp2 = max(tmp2, 0);

        //dp[x][0] = max(dp[x][0], dp[x][0] - E[i].val * 2 + tmp0); 因为下面的转移用到了dp[x][0] 写在这里就不对
        if(tmp0 - E[i].val * 2 > 0)
        {
            dp[x][2] += tmp0 - E[i].val * 2;
            dp[x][1] += tmp0 - E[i].val * 2;
        }

        if(id[fa] == x)
        {
            if(dp[x][0] - E[i].val + tmp2 >= dp[x][1])
            {
                dp[x][2] = dp[x][1];
                dp[x][1] = dp[x][0] - E[i].val + tmp2;
                id[x] = fa;
            }
            else if(dp[x][0] - E[i].val + tmp2 > dp[x][2]) dp[x][2] = dp[x][0] - E[i].val + tmp2;
        }
        else
        {
            if(dp[x][0] - E[i].val + tmp1 >= dp[x][1])
            {
                dp[x][2] = dp[x][1];
                dp[x][1] = dp[x][0] - E[i].val + tmp1;
                id[x] = fa;
            }
            else if(dp[x][0] - E[i].val + tmp1 > dp[x][2]) dp[x][2] = dp[x][0] - E[i].val + tmp1;
        }
        dp[x][0] = max(dp[x][0], dp[x][0] - E[i].val * 2 + tmp0);
    }

    for(int i = c; i; i = E[i].nex)
    {
        int v = E[i].to;
        if(v == fa) continue;
        dfs2(v, x);
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    int t = 0;

    while(T--)
    {
        t++;
        cnt = 0;
        scanf("%d", &n);
        memset(id, 0, sizeof(id));
        memset(head, 0, sizeof(head));
        memset(dp, 0, sizeof(dp));
        memset(du, 0, sizeof(du));
        for(int i = 1; i <= n; i++) scanf("%d", &q[i]);

        for(int i = 1; i < n; i++)
        {
            int u, v, w; scanf("%d%d%d", &u, &v, &w); du[u]++; du[v]++;
            E[++cnt].no = u, E[cnt].to = v, E[cnt].nex = head[u], head[u] = cnt, E[cnt].val = w;
            E[++cnt].no = v, E[cnt].to = u, E[cnt].nex = head[v], head[v] = cnt, E[cnt].val = w;
        }

        int rt;
        for(int i = 1; i <= n; i++)
            if(du[i] == 1)
            {
                rt = i;
                break;
            }

        dfs1(rt, -1);
        dfs2(rt, -1);
        printf("Case #%d:\n", t);
        for(int i = 1; i <= n; i++) printf("%d\n", max(dp[i][0], dp[i][1]));
    }
    return 0;
}

  

原文地址:https://www.cnblogs.com/lwqq3/p/9021086.html

时间: 2024-10-09 23:44:06

<hdu5834 Magic boy Bi Luo with his excited tree> (树形DP)的相关文章

HDU-2196 Computer (树形DP)

最近在看树形DP,这题应该是树形DP的经典题了,写完以后还是有点感觉的.之后看了discuss可以用树分治来做,以后再试一试. 题目大意 找到带权树上离每个点的最远点.︿( ̄︶ ̄)︿ 题解: 对于每一个点的最远点,就是以这个点为根到所有叶子节点的最长距离.但是如果确定根的话,除了根节点外,只能找到每个节点(度数-1)个子树的最大值,剩下一个子树是该节点当前的父亲节点. 所以当前节点的最远点在当前节点子树的所有叶子节点以及父亲节点的最远点上(当父亲节点的最远点不在当前节点的子树上时), 如果父亲节

UVA-01220 Party at Hali-Bula (树形DP+map)

题目链接:https://vjudge.net/problem/UVA-1220 思路: 树形DP模板题,求最大人数很简单,难点在于如何判断最大人数的名单是否有不同的情况: 解决方法是用一个数组f[manx][2]记录该节点是否出场的情况,为真时代表有多种情况; 具体讨论: 当父节点的值加上某个子节点的值时,他的f的情况也和该子节点一样: 当某个节点dp(i, 0) == dp(i, 1), 则该节点以及它的父节点也一定有多种情况(父节点必定取其中之一). Code: 1 #include<bi

HDU 1520 树形dp裸题

1.HDU 1520  Anniversary party 2.总结:第一道树形dp,有点纠结 题意:公司聚会,员工与直接上司不能同时来,求最大权值和 #include<iostream> #include<cstring> #include<cmath> #include<queue> #include<algorithm> #include<cstdio> #define max(a,b) a>b?a:b using nam

HDU2196 Computer(树形DP)

和LightOJ1257一样,之前我用了树分治写了.其实原来这题是道经典的树形DP,感觉这个DP不简单.. dp[0][u]表示以u为根的子树中的结点与u的最远距离 dp[1][u]表示以u为根的子树中的结点与u的次远距离 这两个可以一遍dfs通过儿子结点转移得到.显然dp[0][u]就是u的一个可能的答案,即u往下走的最远距离,还缺一部分就是u往上走的最远距离: dp[2][u]表示u往上走的最远距离 对于这个的转移,分两种情况,是这样的: dp[2][v] = max( dp[0][u]+w

hdu5593--ZYB&#39;s Tree(树形dp)

问题描述 ZYB有一颗N个节点的树,现在他希望你对于每一个点,求出离每个点距离不超过KK的点的个数. 两个点(x,y)在树上的距离定义为两个点树上最短路径经过的边数, 为了节约读入和输出的时间,我们采用如下方式进行读入输出: 读入:读入两个数A,B,令fai??为节点i的父亲,fa?1??=0;fa?i??=(A∗i+B)%(i−1)+1,i∈[2,N] . 输出:输出时只需输出N个点的答案的xor和即可. 输入描述 第一行一个整数TT表示数据组数. 接下来每组数据: 一行四个正整数N,K,A,

CF 219D Choosing Capital for Treeland 树形DP 好题

一个国家,有n座城市,编号为1~n,有n-1条有向边 如果不考虑边的有向性,这n个城市刚好构成一棵树 现在国王要在这n个城市中选择一个作为首都 要求:从首都可以到达这个国家的任何一个城市(边是有向的) 所以一个城市作为首都,可能会有若干边需要改变方向 现在问,选择哪些城市作为首都,需要改变方向的边最少. 输出最少需要改变方向的边数 输出可以作为首都的编号 树形DP 先假定城市1作为首都 令tree(i)表示以i为根的子树 dp[i]表示在tree(i)中,若以i为首都的话,需要改变的边数 第一次

HDU 1011 Starship Troopers(树形dp+背包)

Starship Troopers Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 13109    Accepted Submission(s): 3562 Problem Description You, the leader of Starship Troopers, are sent to destroy a base of

Codeforces 462D Appleman and Tree 树形dp

题目链接:点击打开链接 题意: 给定n个点的树, 0为根,下面n-1行表示每个点的父节点 最后一行n个数 表示每个点的颜色,0为白色,1为黑色. 把树分成若干个联通块使得每个联通块有且仅有一个黑点,问有多少种分法(结果mod1e9+7) 思路: 树形dp,每个点有2个状态,已经归属于某个黑点和未归属于某个黑点. #include <cstdio> #include <vector> #include <iostream> using namespace std; #de

poj 3342(树形dp)

题意:在一个公司中要举办一个聚会,每一个员工有一个奉献值.为了和谐规定直接上下级不能一起出席.让你找出奉献值之和最大为多少. 思路:dp[v][1]表示当前结点选,能获得的最大奉献值,dp[v][0]表示当前节点不选能获得的最大奉献值.状态转移: dp[v][0] = max(dp[v][0], ∑max(dp[x][1], dp[x][0]))x为直接儿子 dp[v][1] = max(dp[v][1], ∑dp[x][0] + vex[v]) 最后答案是max(dp[root][0], dp

CodeForces 219D.Choosing Capital for Treeland (树形dp)

题目链接: http://codeforces.com/contest/219/problem/D 题意: 给一个n节点的有向无环图,要找一个这样的点:该点到其它n-1要逆转的道路最少,(边<u,v>,如果v要到u去,则要逆转该边方向)如果有多个这样的点,则升序输出所有 思路: 看了三篇博客,挺好的 http://blog.csdn.net/chl_3205/article/details/9284747 http://m.blog.csdn.net/qq_32570675/article/d