树形dp hdu1561

有的堡垒攻克需要攻克另一个堡垒,形成一个森林,最多攻克m个堡垒,求获得宝物的最大价值。

1,以0做根将森林形成树;

2,用背包计算当前节点下需要攻克k个堡垒能获得的宝物最大价值,但是注意同一个根节点的情况不能够先后放入背包,否则会有比如1节点选2个和选三个形成了选5个,也就是某些节点重复计算了。所以要在back第j格时将所有种k依次放入,j--;

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<vector>
using namespace std;
const int maxa =  205;
int dp[maxa][maxa];
int back[maxa][maxa];
int vis[maxa][maxa];
int v[maxa];
vector<int> edge[maxa];
int numb[maxa];
int dfs(int x, int num ){//printf("%d %d\n", x, num);
    if(vis[x][num] || num == 0)
        return dp[x][num];
    memset(back[x], 0, sizeof(back[x]));
    for(int i = 0; i < edge[x].size(); i ++){
        int k = edge[x][i];//printf("%d ", k);
        int last = -1;
        for(int h = num-1; h >= 1; h--){
            for(int j = 1; j <= h && j <= numb[k]; j++){
                int a = dfs(k, j);
                back[x][h] = max(back[x][h], back[x][h-j] + a);//printf("%d ", back[h]);
            }//puts("");
        }
    }
    vis[x][num] = 1;
    return dp[x][num] = back[x][num-1]+v[x];
}
int dfs1(int x){
    int sum =  0;
    for(int i = 0; i < edge[x].size(); i++){
        int k = edge[x][i];
        sum += dfs1(k);
    }
    return numb[x] = sum +1;
}
int main(){
int n, m;
   //freopen("in.cpp", "r", stdin);
    while(scanf("%d%d", &n, &m), n+m){
        memset(vis, 0, sizeof(vis));
        for(int i =0; i <= n; i++)
            edge[i].clear();
        for(int i =1; i <= n; i++){
            int a, b;
            scanf("%d%d", &a, &b);
            v[i] = b;
            edge[a].push_back(i);
        }
        dfs1(0);
            memset(dp, 0, sizeof(dp));
            printf("%d\n", dfs(0, m+1));
           /* for(int i = 0; i <= n; i++){
                printf("*%d ", numb[i]);
            }*/
    }
}

时间: 2024-11-09 01:37:43

树形dp hdu1561的相关文章

hdu-1561 The more, The Better (树形dp入门,有依赖的背包问题

The more, The Better Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4954    Accepted Submission(s): 2922 Problem Description ACboy很喜欢玩一种战略游戏,在一个地图上,有N座城堡,每座城堡都有一定的宝物,在每次游戏中ACboy允许攻克M个城堡并获得里面的宝

【树形dp小练】HDU1520 HDU2196 HDU1561 HDU3534

[树形dp]就是在树上做的一些dp之类的递推,因为一般需要递归处理,因此平凡情况的处理可能需要理清思路.昨晚开始切了4题,作为入门训练.题目都非常简单,但是似乎做起来都还口以- hdu1520 Anniversary party 给一颗关系树,各点有权值,选一些点出来.任一对直接相连的边连接的点不能同时选择,问选择出的权值和最大为多少. 考虑以u为根的子树可以选择的方法,dp[u]表示选择u时能获得最大收益,dp2[u]表示不选u时能获得的最大收益.则u不选时,为dp2[u]=max{dp[v]

hdu1561 树形dp+背包

题目链接:http://acm.split.hdu.edu.cn/showproblem.php?pid=1561 思路:树形dp+01背包 //看注释可以懂 用vector建树更简单. 代码: #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<vector> using namespace std; #define ll long

树形 DP 总结

本文转自:http://blog.csdn.net/angon823/article/details/52334548 介绍 1.什么是树型动态规划 顾名思义,树型动态规划就是在"树"的数据结构上的动态规划,平时作的动态规划都是线性的或者是建立在图上的,线性的动态规划有二种方向既向前和向后,相应的线性的动态规划有二种方法既顺推与逆推,而树型动态规划是建立在树上的,所以也相应的有二个方向: 1.叶->根:在回溯的时候从叶子节点往上更新信息 2.根 - >叶:往往是在从叶往根d

树形依赖的背包 树形dp

树形DP有一个独特的优化,就是通过递归,枚举目前有效的元素个数,求dp[ i ][ j ] (表示 选取以i为根的子树中有选取j个元素的最大取值) (搭配 siz 数组表示当前该节点的总共子孙数) 1.hdu1561(树形依赖背包裸题) 注意 siz 数组的运用,以及 u 点选择的节点数时要逆向枚举,就像01背包 复杂度看似O(n^3),实际是 O( n^2 ) 左右. #include <iostream> #include <cstdio> #include <cstri

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