树形dp入门[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]

最新推荐文章于 2022-07-04 16:17:38 发布
最新推荐文章于 2022-07-04 16:17:38 发布
阅读量545 收藏
点赞数
分类专栏： ACM_DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24833289/article/details/47681751
版权

树形dp中，我们可以很容易利用题目给出的数据构建出一棵树，然后我们会用dp[i]记录，选择以 i 为根的子树中的点能得到的最优答案。而dp[i]的值可以根据，i节点的子节点u1,u2...un对应的dp[u1],dp[u2]...dp[un]，递推得到。树形dp通常用搜索的形式实现，由于是树的结构，所以不包含重复的搜索，复杂度为O（n）。

我建树是建边用的是邻接表，做图论题的时候也是这样，感觉挺方便的。看了网上一些题解是用一个数组 a[i] 记录与 i 有同一个父节点的下一个节点。



下面是一些树形dp入门题


题目：POJ 1655 http://poj.org/problem?id=1655

题意：定义树上每个节点的有一个平衡值，平衡值为删除这个点后得到的树的大小的最大值。给出一棵树，求出平衡值最小的节点和它对应的平衡值。

思路：dp[ i ] 记录以 i 为根节点的树的大小。求每个节点的平衡值，要求以它的子节点为跟的子树的大小，和总节点数-以它为根节点的树的大小。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
vector<int> G[20005];
int d[20005], vis[20005];

void dp(int u)
{
    d[u] = 1;
    vis[u] = 1;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(vis[v])
        { //v是u的父节点而不是子节点
            G[u][i] = -1;
            continue;
        }
        dp(v);
        d[u] += d[v];
    }
    //printf("d[%d]=%d\n", u, d[u]);
    return;
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t, n, a, b;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 0; i <= n; i++)
        {
            G[i].clear();
        }
        for(int i = 0; i < n - 1; i++)
        {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        memset(d, 0, sizeof(d));
        memset(vis, 0, sizeof(vis));
        dp(1);
        int ans = INF, p;
        for(int i = 1; i <= n; i++)
        {
            int cur = d[1] - d[i];
            for(int j = 0; j < G[i].size(); j++)
            {
                int k = G[i][j];
                if(k == -1) continue;
                cur = max(cur, d[k]);
            }
            if(cur < ans)
            {
                ans = cur; p = i;
            }
        }
        printf("%d %d\n", p, ans);
    }
    return 0;
}


题目：HDU 1520 http://acm.hdu.edu.cn/showproblem.php?pid=1520

题意：办一个派对，邀请员工的时候，如果邀请了一个上司，那他的直接下属不能邀请了，每个人都有一个参与派对的欢乐值，要求出可以得到的派对欢乐值最大是多少。

思路：每个人选和不选都会决定他的直接下属是否可选，所以对于每个人要分两种情况讨论然后求最大值，要使用二维数组，dp[u][0] 记录不选 u 能得到的最大值，那么他的直接下属也有选和不选两种情况，dp[u][1] 记录选 u 能得到的最大值，那么他的直接下属只有不选的情况。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
int con[6005], in[6005];
vector<int> G[6005];
int d[6005][5];//0²»È¡£¬1È¡

void dp(int u)
{
    //if(d[u][0] || d[u][1]) return;
    d[u][0] = 0; d[u][1] = con[u];
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        dp(v);
        d[u][0] += max(d[v][0], d[v][1]);
        d[u][1] += d[v][0];
    }
    //printf("d[%d][0]=%d,d[%d][1]=%d\n", u, d[u][0], u, d[u][1]);
    return;
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, l, k;
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &con[i]);
            G[i].clear();
        }
        memset(in, 0, sizeof(in));
        while(scanf("%d%d", &l, &k))
        //for(int i = 0; i < n - 1; i++)
        {
            //scanf("%d%d", &l, &k);
            if(l == 0 && k == 0) break;
            G[k].push_back(l);
            in[l]++;
        }
        int v;
        for(int i = 1; i <= n; i++)
        {
            if(in[i] == 0)
            {
                v = i; break;
            }
        }
        memset(d, 0, sizeof(d));
        dp(v);
        printf("%d\n", max(d[v][0], d[v][1]));
    }



    return 0;
}


题目：HDU 1561 http://acm.hdu.edu.cn/showproblem.php?pid=1561

题意：在一个地图上，有N座城堡，每座城堡都有一定的宝物，在每次游戏中ACboy允许攻克M个城堡并获得里面的宝物。求ACboy能得到的最大宝物数。

思路：地图就是一棵树，根节点为ACboy的起点0。dp[u][m]记录以u为起点，最多到达m个点，能得到的最大宝物数。类似背包问题中到达的点数为重量，宝物数为价值，容量为总重量。

代码：发现这个代码有记录价值的数组v[ ]（全局），也有表示子节点的v（for循环里面），懒得改了，不影响运行结果。后面几个代码也是有这个问题。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
int n, m, v[205], sum[205], dp[205][205];
vector<int> G[205];

void dfs(int u)
{
    sum[u] = 1;
    dp[u][1] = v[u];
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        dfs(v);
        sum[u] += sum[v]; //当前以u为根节点可到达的节点数
        for(int j = sum[u]; j >= 2; j--)
        {
            for(int k = 1; k <= sum[v]; k++)
            { //确定攻克了u,v为u子节点，枚举在以v为根节点的树上攻克的节点数
                if(j - k < 1) continue;
                dp[u][j] = max(dp[u][j], dp[u][j - k] + dp[v][k]);
                //printf("(v%d) dp[%d][%d]=%d\n", v, u, j, dp[u][j]);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int f;
    while(scanf("%d%d", &n, &m) != EOF && (n && m))
    {
        for(int i = 0; i <= n; i++)
        {
            G[i].clear();
        }
        v[0] = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d%d", &f, &v[i]);
            G[f].push_back(i);
        }
        memset(dp, 0, sizeof(dp));
        dfs(0);
        printf("%d\n", dp[0][m + 1]); //起点为一个到达的点但不需要攻克
    }

    return 0;
}


题目：HDU 1011 http://acm.hdu.edu.cn/showproblem.php?pid=1011

题意：一群士兵在地洞里打虫子，他们想抓住虫子头目，他们每到了一个洞要走到更深的洞的时候之前都要留下一些士兵在当前的洞打虫子。士兵的数量有限，他们知道每个洞能找到虫子头目的概率，问他们抓住虫子头目的最大概率。

思路：也是在一个树形的地图里，起点为根节点。和上面一题差不多，不同的是每个点的权值不同（上面一题每个点权值都为1）。dp[u][w] 表示以 u 为起点用 w 个士兵找到虫子头目的最大概率。类似背包问题中需要士兵数为重量，概率为价值，容量为总士兵数。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
vector<int> G[205];
int n, m;
int w[105], v[105], vis[105], dp[105][105];

void dfs(int u)
{
    vis[u] = 1;
    for(int i = w[u]; i <= m; i++)
        dp[u][i] = v[u];
    //printf("d[%d][%d]=%d\n", u, m - w[u], dp[u][m - w[u]]);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(vis[v]) continue;
        dfs(v);
        for(int j = m; j >= w[u]; j--)
        {
            for(int k = 1; j - k >= w[u]; k++)
            {
                dp[u][j] = max(dp[u][j], dp[u][j - k] + dp[v][k]);
                //printf("(v%d) d[%d][%d]=%d %d\n", v, u, j, dp[u][j], k);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int a, b;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        if(n == -1 && m == -1) break;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d%d", &w[i], &v[i]);
            w[i] = (w[i] + 20 - 1) / 20;
            G[i].clear();
        }
        for(int i = 0; i < n - 1; i++)
        {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        memset(vis, 0, sizeof(vis));
        memset(dp, 0, sizeof(dp));
        if(m == 0)
        {
            printf("0\n");
            continue;
        }
        dfs(1);
        printf("%d\n", dp[1][m]);
    }

    return 0;
}


题目：POJ 1155 http://poj.org/problem?id=1155

题意：电视台要见一个电视网，电视网友发射站和用户接收端组成，终端为一个发射站，一个发射站可以连接其他发射站或用户，用户只能连发射站。连接每条线都有一定的费用，每个用户付的费用为一定值，求电视台在不亏本的情况下最多能连接多少个用户。

思路：前面两题的费用都为点的权值，这题的费用为边权，价值只在“用户”这些点上。dp[ u ] [ j ] 记录以u为起点连接 j 个用户的最大收益（初始化为负值），类似0-1背包中用价值作为容量的情况。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
int n, m, vis[3005], sum[3005], dp[3005][3005];
struct Edge
{
    int to, cost;
}cur;
vector<Edge> G[3005];

void dfs(int u)
{
    vis[u] = 1;
    if(u <= n - m) sum[u] = 0;
    else sum[u] = 1;
    for(int i = 0; i < G[u].size(); i++)
    {
        Edge &e = G[u][i];
        if(vis[e.to]) continue;
        dfs(e.to);
        //printf("v=%d\n", e.to);
        sum[u] += sum[e.to];
        dp[u][0] = 0;
        for(int j = sum[u]; j >= 1; j--)
        {
            for(int k = 1; k <= sum[e.to]; k++)
            {
                if(j - k < 0) break;
                dp[u][j] = (int)max((ll)dp[u][j], (ll)dp[u][j - k] + dp[e.to][k] - e.cost);
                //printf("dp[%d][%d]=%d\n", u, j, dp[u][j]);
            }
        }
    }
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int k, a, c;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        for(int i = 0; i <= n; i++)
        {
            G[i].clear();
        }
        for(int i = 1; i <= n - m; i++)
        {
            scanf("%d", &k);
            for(int j = 0; j < k; j++)
            {
                scanf("%d%d", &a, &c);
                cur.to = a; cur.cost = c;
                G[i].push_back(cur);
            }
        }
        memset(sum, 0, sizeof(sum));
        memset(vis, 0, sizeof(vis));
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= m; j++)
            {
                dp[i][j] = -INF;
            }
        }
        for(int i = n - m + 1; i <= n; i++)
        {
            scanf("%d", &dp[i][1]);
        }

        dfs(1);
        for(int i = m; i >= 0; i--)
        {
            if(dp[1][i] >= 0)
            {
                printf("%d\n", i);
                break;
            }
        }
    }

    return 0;
}


题目：ZOJ 3626 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3626

题意：有一个危险的村庄，这里有时会有怪兽出现，已知怪兽多久会出现一次，怪兽出现之后发现谁不在家，就会把谁杀掉。一个勇士要得到了一张藏宝图并要去找宝藏，他知道村庄之间的距离和每个村庄里有多少宝藏，问他不被怪兽杀掉的话，最多能拿到多少宝藏。给出的n个村庄和n-1条路，村庄两两之间可以到达。

思路：地图是树形的，勇士所在的村庄为根节点，边权为重量，价值在点上，怪兽出现的时间的为容量。dp[u][j] 记录从 u 出发回到 u 用 j 天最多能收集到的宝藏数。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define MOD 1000000007
#include <vector>
using namespace std;
typedef long long ll;
int n, k, m, v[105], vis[105], dp[105][205];
struct Edge
{
    int to, cost;
}cur;
vector<Edge> G[105];

void dfs(int u)
{
    vis[u] = 1;
    for(int i = 0; i <= m; i++)
        dp[u][i] = v[u];
    //dp[u][0] = v[u];
    for(int i = 0; i < G[u].size(); i++)
    {
        Edge &e = G[u][i];
        if(vis[e.to]) continue;
        dfs(e.to);
        //printf("v=%d\n", e.to);
        for(int j = m; j >= 1; j--)
        {
            for(int k = 0; j - k - 2 * e.cost >= 0; k++)
            {
                dp[u][j] = max(dp[u][j], dp[u][j - k - 2 * e.cost] + dp[e.to][k]);
                //printf("dp[%d][%d]=%d\n", u, j, dp[u][j]);
            }
        }
    }
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int a, b, c;
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &v[i]);
            G[i].clear();
        }
        for(int i = 0; i < n - 1; i++)
        {
            scanf("%d%d%d", &a, &b, &c);
            cur.cost = c; cur.to = a;
            G[b].push_back(cur);
            cur.to = b;
            G[a].push_back(cur);
        }
        scanf("%d%d", &k, &m);
        //m /= 2;
        memset(vis, 0, sizeof(vis));
        memset(dp, 0, sizeof(dp));
        dfs(k);
        printf("%d\n", dp[k][m]);
    }

    return 0;
}





cookiesMonster
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj1655(Balancing Act + 树形dfs)
鸟 的 天 空
08-22 723
题目链接：http://poj.org/problem?id=1655      题意：有一颗N个节点的树，每个节点的Balancing是删除该节点后所有子树中节点数目最大的子树节点数目。问Balancing的最小值与该节点的编号。如果Balancing相同，输出节点编号较小的。 代码： #include #include #define MAXN 20005 struct Edge{
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
Poj 1655 【树的重心】
t51645的博客
03-30 316
题目链接：http://poj.org/problem?id=1655 题解： 一开始建树时是取小的点指向大的点，然后一直WA后来发现这样建树是有问题的，可能会有（1,3）（2,3）这种出现1->3,2->3导致1、2不联通的情况出现。 #include #include #include #include #include #include #include #inc
poj - 1655 Balancing Act
weixin_34061482的博客
11-08 89
给出一个树，若去掉其中一个结点，剩下的子树中规模最大的树的规模（估且称为D值），就是该点的D值。求所有结点中D值最小的点，输出点及其D值。 这题用两次DFS，第一次求出所有结点的子结点数，第二次求出所有结点的D值。 1 #include <stdio.h> 2 #include <string.h> 3 #include <vector> ...
POJ-1655-树的重心
lifeforge的博客
09-15 139
树的重心模板题 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #include <cmath> #include <map> #include <queue> #include <functional> #include <vector> #include <stack> #inc
POJ_1655_Balancing Act
fengyu0556的专栏
07-15 701
//树形DP,TREE DP。这里使用邻接表存储树，可以改进的一点就是使用动态分配数组。 #include #include #include int f[20001]; int n; //树的节点的表示 typedef struct node { int num; struct node *next; }; //建立头结点数组 node ft[20001]; //深度优先搜索，last用于指示上一层节点编号，主要是防止死循环 int dfs(int last,i
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
POJ、HDU、ZOJ、SOJ水题过滤器
11-08
标题中的“POJ、HDU、ZOJ、SOJ水题过滤器”指的是一个工具，它主要用于帮助在ACM（国际大学生程序设计竞赛）训练中筛选出这些在线判题系统中的简单题目，即所谓的“水题”。这些在线判题平台是编程爱好者和参赛者们...
HDU ZOJ POJ 杭电浙大北大 3大OJAC代码4000份大合集
08-16
利用vjudge源码改造爬虫抓取vjudge全局共享答案资源。 ACMer，请用于参考思路，对拍代码，不要直接提交。
hdu oj 分类（杭州电子科技）
08-07
杭州电子科技大学OJ分类，很适合刚入门的新手哦，分类很详细，是不可多得的资料
POJ-1655 Balancing Act
weixin_30478757的博客
04-16 53
题目大意：一棵n个节点的树，找出最大子树最小的节点。 题目分析：过程类似求重心。 代码如下： # include<iostream> # include<cstdio> # include<cstring> # include<vector> # include<queue> # include<...
树的重心模板 / poj1655
m0_54646258的博客
07-04 257
树的重心
Poj 1655(树的重心、树形DP、经典)
Feynman1999的博客
08-21 725
problemConsider a tree T with N (1 <= N <= 20,000) nodes numbered 1…N. Deleting any node from the tree yields a forest: a collection of one or more trees. Define the balance of a node to be the size of
POJ 1655 求树的重心
flyzer的博客
05-09 185
POJ 1655 题意：求出树的重心 x 以及 max_part(x) 的值。 设max_part(i) 表示在删除节点x后产生的子树中，最大的一颗的大小。使max_part函数取到最小值的节点p就称为征颗树的重心。 树的重心的几条性质： 1、找到一个点，其所有的子树中最大的子树节点数最少，那么这个点就是这棵树的重心。 2、以这个点为根，那么所有的子树（不算整个树自身）的大小都不超过整个树...
POJ1655 树重心模板题
weixin_43843730的博客
11-08 387
传送门 树重心：树的重心也叫树的质心。对于一棵树n个节点的无根树，找到一个点，使得把树变成以该点为根的有根树时，最大子树的结点数最小。换句话说，删除这个点后最大连通块（一定是树）的结点数最小。 题意：给你一颗树，找出这棵树的重心和对应的最大子树的节点数。 题解：d[i]表示以i为节点的子树的节点数，然后d[i] = sum(d[j])+1,j的范围为i的子节点，一次dfs就可以了。 code #i...
poj1655 树的重心
夷则九的博客
03-22 129
一.性质 树中所有点到某个点的距离和中，到重心的距离和是最小的，如果有两个距离和，他们的距离和一样。 把两棵树通过一条边相连，新的树的重心在原来两棵树重心的连线上。 一棵树添加或者删除一个节点，树的重心最多只移动一条边的位置。 一棵树最多有两个重心，且相邻。 去掉重心后最大子树大小不超过n/2 二.模板 版本一： #include<iostream> #incl...
POJ - 1655 （点分治-树的重心）
weixin_30649641的博客
08-13 108
题目：https://vjudge.net/contest/307753#problem/D 题意：给你一棵树，让你求出一个点，让他的最大子树的节点数尽量小 思路：最大子树节点数尽量小，一看就是树的重心， 然后随便套个原来的点分治模板即可 #include<cstdio> #include<cstring> #include<cmath&...
poj1655
weixin_30446613的博客
07-25 74
/***************************************************************\ *Author:Hu Wenbiao *Created Time: Tue 17 Aug 2010 04:54:15 PM CST *File Name: main.cpp *Description:树状dp。邻接表 \*************...
POJ1655
qq_39479426的博客
08-10 332
  Consider a tree T with N (1 &lt;= N &lt;= 20,000) nodes numbered 1...N. Deleting any node from the tree yields a forest: a collection of one or more trees. Define the balance of a node to be the si...
"ACM与网络流：图论和DP模板，解析POJ和HDU例题
这些例题通常是从POJ和HDU等在线评测平台上选取的经典题目，涵盖了各种不同类型的问题，如图论问题、动态规划问题、网络流问题等。通过练习这些例题，读者可以更加熟练地运用模板中的算法和数据结构，提高解题能力和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值