树形 DP

已于 2022-03-04 14:13:03 修改
阅读量241 收藏
点赞数
分类专栏： 数据结构 树 # 树形DP 文章标签： 深度优先 算法 动态规划
于 2022-02-08 00:09:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51070956/article/details/122811136
版权
数据结构 同时被 3 个专栏收录
28 篇文章 0 订阅
订阅专栏
树
15 篇文章 0 订阅
订阅专栏
树形DP
6 篇文章 0 订阅
订阅专栏

树状DP

简单入门题

P1352 没有上司的舞会

一、dfs方法

普通dp一般用两个for循环，但是树形dp的基本操作就是将一个结点所有子树的信息合到这个节点上，我们的for循环显然就不能满足这个要求。我们采取dfs的方法。

很容易发现树形dp它为什么一般会是dfs形式？因为树形dp的状态大多是一颗颗子树，它传递状态过程一般都是先求出最下层再往上更新。所以对于每一个点，我们在求解它的值的过程中，需要求出它每一个子节点的解。

#include <iostream>
#include <vector>
using namespace std;
const int MAX=6005;
int h[MAX]; 
int vis[MAX];
int dp[MAX][2];
vector<int> son[MAX];//son[x][i],值为x的节点的儿子们 
void dfs(int x){
	dp[x][0]=0;
	dp[x][1]=h[x];//x号职员去或不去的初始快乐值
	for(int i=0;i<son[x].size();i++){
		int s=son[x][i];
		dfs(s);
		dp[x][0]+=max(dp[s][0],dp[s][1]);//x不去，下属去或不去的最大值
		dp[x][1]+=dp[s][0]; 
	} 
	
}
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>h[i];
	} 
	int x,y;//下属，上司 
	for(int i=1;i<=n-1;i++){//只有n-1个职员有公司 
		cin>>x>>y;
		son[y].push_back(x);
		vis[x]=1;//没有上司的是根节点 
	}
	int root;
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			root=i;
			break;
		}
	} 
	//判断根节点方法可多种了，但都是判断是否做别人儿子的演化
	//是否做别人儿子vis数组、是否有父亲fa【x]!=x、入度是否为0
	dfs(root);
	cout<<max(dp[root][0],dp[root][1]);
    return 0;
}

链式前向星（head数组初始化为0好了，不用特意memset成-1，遍历时终止条件直接i省的~i

#include <iostream>
//#include <vector>
#include<string.h>
using namespace std;
const int MAX=6005;
int h[MAX]; 
int vis[MAX];
int dp[MAX][2];
//vector<int> son[MAX];//son[x][i],值为x的节点的儿子们 
struct edge{
	int to;
	int next;
//	int w;这里无所谓边的权重了 
}e[MAX];
int cnt;
int head[MAX];
void add(int u,int v){
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int x){
	dp[x][0]=0;
	dp[x][1]=h[x];//x号职员去或不去的初始快乐值
//	for(int i=0;i<son[x].size();i++){
//		int s=son[x][i];
	for(int i=head[x];~i;i=e[i].next){
		int s=e[i].to;
		dfs(s);
		dp[x][0]+=max(dp[s][0],dp[s][1]);//x不去，下属去或不去的最大值
		dp[x][1]+=dp[s][0]; 
	} 
	
}
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>h[i];
	} 
	memset(head,-1,sizeof(head));
	int x,y;//下属，上司 
	for(int i=1;i<=n-1;i++){//只有n-1个职员有公司 
		cin>>x>>y;
//		son[y].push_back(x);
		add(y,x);
		vis[x]=1;//没有上司的是根节点 
	}
	int root;
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			root=i;
			break;
		}
	} 
	dfs(root);
	cout<<max(dp[root][0],dp[root][1]);
    return 0;
}

更周到的解法

洛谷题解页面大佬提供的思路👇
如果我们的人数相当多且是一条链的时候就容易造成爆栈，那这我们有如何解决呢?
方法有三
1、开一个数组手动实现栈。
2、bfs后用for循环
3、拓扑排序

第一个想必大家都会写，而且其与dfs相似，所以不再赘述。
那为啥会讲后两种呢？
因为有时候dfs并不好写，所以我们会把它转化为bfs+for或者拓扑，大家可以看一下，dfs和这两种写法的推导有的是不一样的。特别是和这题的拓扑写法，可以仔细看一下。

二、bfs+for循环（终于有点理解为什么说dfs能做到的bfs都可以做到了）从底部节点开始，节点由孩子信息推出（叶子节点孩子信息为0哪）

我们很容易发现树形dp它为什么一般会是dfs形式？因为树形dp的状态大多是一颗颗子树，它传递状态过程一般都是先求出最下层再往上更新。所以对于每一个点，我们在求解它的值的过程中，需要求出它每一个子节点的解。
那有什么方法我们可以用数组和for循环实现这样的求解呢？没错，就是bfs过程中的队列。由于队列中的点都是先入的父亲节点后入的子节点，所以我们求解的时候只要把循环顺序反过来就可以了。

从根节点自顶而下就需要dfs掌握所有子树信息
那么试想自底而上，先掌握底部节点的信息，可用bfs将节点依据深度依次放入队列，当然了，先进先出，先放的应该是底部节点

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MAX=6005;
int h[MAX];
vector<int> son[MAX];
int fa[MAX];//以此判断根节点，感觉比vis是否有父亲难一点 
int dp[MAX][2];//dp[x][0]以x为根节点的子树上 在x上不妨士兵 共需士兵数
int vis[MAX];//节点是否入队的判断 
queue<int> Q;
int que[MAX];//到时候可逆序输出存储在队列中的节点
int cnt;//给que计数，到时候好逆序 
void bfs(int r){
	Q.push(r);
	que[cnt++]=r;
	vis[r]=1;
	while(!Q.empty()){
		int x=Q.front();Q.pop();
		for(int i=0;i<son[x].size();i++){
			int s=son[x][i];
			if(!vis[s]){
			Q.push(s);
			que[cnt++]=s;
			vis[s]=1;
			}
		}
	}
} 
int main(){
	int n;
	cin>>n;
for(int i=1;i<=n;i++){
		cin>>h[i];
		fa[i]=i;
	} 
	int x,y;//下属，上司 
	for(int i=1;i<=n-1;i++){//只有n-1个职员有公司 
		cin>>x>>y;
		son[y].push_back(x);
		fa[x]=y; 
	}
	int r=n;//随便找了个节点r，寻找她的终极祖先 我们的根节点 
	while(r!=fa[r]){
		r=fa[r];//r现在是当初r的父亲 父亲的父亲的父亲直到根节点 
	}
	bfs(r);
	for(int i=cnt-1;i>=0;i--){
		int x=que[i];
		for(int j=0;j<son[x].size();j++){
			int s=son[x][j];
			dp[x][0]+=max(dp[s][0],dp[s][1]);
			dp[x][1]+=dp[s][0];
		}
		dp[x][1]+=h[x];
	}
	cout<<max(dp[r][0],dp[r][1]);
    return 0;
}

三、拓扑排序(节点fa[x]由节点x信息推出）

先回忆一下拓扑排序
在这里插入图片描述

拓扑排序，先将所有入度为0的点入队，列举队列中元素，逐一出队，出队时改变邻接结点的入度，如果邻接结点入读减为0就将其入队
现在从后往前，就看出度是否为0
这次就是真真切切的先存底部叶子节点再依次往上了

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MAX=6005;
int h[MAX];
vector<int> son[MAX];
int fa[MAX];//以此判断根节点，感觉比vis是否有父亲难一点 
int dp[MAX][2];//dp[x][0]以x为根节点的子树上 在x上不妨士兵 共需士兵数
int vis[MAX];//节点是否入队的判断 
queue<int> Q;
int degree[MAX];
int main(){
	int n;
	cin>>n;
for(int i=1;i<=n;i++){
		cin>>h[i];
	} 
	int x,y;//下属，上司 
	for(int i=1;i<=n-1;i++){//只有n-1个职员有公司 
		cin>>x>>y;
		son[y].push_back(x);
		fa[x]=y; 
		degree[y]++;//出度为0的点（没有孩子的点） 
	}
	for(int i=1;i<=n;i++){
		if(degree[i]==0)Q.push(i);
	} 
	int maxx=0;
	while(!Q.empty()){
		int x=Q.front();Q.pop();
		dp[x][1]+=h[x];
		maxx=max(maxx,dp[x][1]);
		maxx=max(maxx,dp[x][0]);
		degree[fa[x]]--;
		if(degree[fa[x]]==0)Q.push(fa[x]);
		dp[fa[x]][1]+=dp[x][0];
		dp[fa[x]][0]+=max(dp[x][0],dp[x][1]);
	}
	cout<<maxx;
    return 0;
}

P2016 战略游戏

#include <iostream>
#include <vector>
using namespace std;
const int MAX=1500;
vector<int> son[MAX];
int vis[MAX];
int dp[MAX][2];//dp[x][0]以x为根节点的子树上 在x上不妨士兵 共需士兵数
void dfs(int x){
	dp[x][1]=1;
	dp[x][0]=0;//不放就只花0个士兵
//	if(son[x].size()==0)return;
	for(int i=0;i<son[x].size();i++){
		int s=son[x][i];
		dfs(s);
		dp[x][1]+=min(dp[s][1],dp[s][0]);
		dp[x][0]+=dp[s][1];
	} 
}
int main(){
	int n;
	cin>>n;
	int x,y,k;//x节点有k个节点与他相连（k个孩子 
	for(int i=0;i<n;i++){
		cin>>x>>k;
		for(int i=0;i<k;i++){
			cin>>y;
			son[x].push_back(y);
			vis[y]=1;
		} 
	}
	int root;
	for(int i=0;i<n;i++){
		if(!vis[i]){
			root=i;
			break;
		}
	}
	dfs(root);
	cout<<min(dp[root][1],dp[root][0]);
    return 0;
}

链式前向星存储无向边 一要开两倍空间，二要

全都是有向边还好，有无向边就要判断即将dfs的节点x的终点是否是x的起点， 少了这个判断就死循环了，由于层层递归，x取决于to的情况，而以to为起点发出去的一条边终点又是x，像拓扑排序里形成了个圈，互为前提

#include <iostream>
//#include <vector>
using namespace std;
const int MAX=1500;
//vector<int> son[MAX];
int vis[MAX];
int dp[MAX<<1][2];//dp[x][0]以x为根节点的子树上 在x上不妨士兵 共需士兵数
struct edge{
	int to;
	int next;
}e[MAX<<1];
int head[MAX<<1];
int cnt;
void add(int u,int v){
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int x,int from){//全都是有向边还好，有无向边就要判断即将dfs的节点x的终点是否是x的起点， 少了这个判断就死循环了，由于层层递归，x取决于to的情况，而以to为起点发出去的一条边终点又是x，像拓扑排序里形成了个圈，互为前提
	dp[x][1]=1;
	dp[x][0]=0;//不放就只花0个士兵
//	if(son[x].size()==0)return;
//	for(int i=0;i<son[x].size();i++){
//		int s=son[x][i];
	for(int i=head[x];i;i=e[i].next){
		int s=e[i].to;
		if(s!=from){//由于视作了无向边a->b,b->a 
		dfs(s,x);
		dp[x][1]+=min(dp[s][1],dp[s][0]);
		dp[x][0]+=dp[s][1];
		}
	} 
}
int main(){
	int n;
	cin>>n;
	int x,y,k;//x节点有k个节点与他相连（k个孩子 
	for(int i=0;i<n;i++){
		cin>>x>>k;
		for(int i=0;i<k;i++){
			cin>>y;
//			son[x].push_back(y);
			add(x,y);
			add(y,x);
			vis[y]=1;
		} 
	}
	int root;
	for(int i=0;i<n;i++){
		if(!vis[i]){
			root=i;
			break;
		}
	}
	dfs(root,0);
	cout<<min(dp[root][1],dp[root][0]);
    return 0;
}
Selvaggia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树形dp
qq_41009449的博客
08-09 137
本文转自：http://blog.csdn.net/angon823/article/details/52334548 转载博主的树形dp分了入门 一般 难 三部分题目 不定时更新 1、什么是树型动态规划  顾名思义，树型动态规划就是在“树”的数据结构上的动态规划，平时作的动态规划都是线性的或者是建立在图上的，线性的动态规划有二种方向既向前和向后，相应的线性的动态规划有二种方法既顺推与逆推，...
树形DP
不平凡的博客
01-28 184
题目： Another Crisis  Time Limit: 3000MS 64bit IO Format: %lld & %llu A couple of years ago, a new world wide crisis started, leaving many people with economical problems. Some workers of a par
【AGC008F】Black Radius【树形dp】
2016gdgzoi471
08-16 447
题目链接 这道题。。。神题，花了半天的时间终于搞懂了。 我们设二元组(u,d)(u,d)(u,d)表示以uuu为染色中心，ddd为染色半径染黑的点的集合。为了方便，我们先钦定这些二元组染出的点的集合不为全集，这样答案最后加一就好了。 我们先钦定一个点uuu为染色中心。 1.1.1.这个点可以作为染色中心。则这个点使染色不会发生重复的染色半径ddd的范围为d≥0d≥0d≥0，且 {d&lt...
树形dp（超详细）
盛楠的博客
08-11 8866
通常，我们从根节点出发，向子节点做深度优先搜索，并由其子节点的最优解合并得到该节点的最优解。有些问题，我们还需再次从根节点出发，向子节点做深度优先搜索，对于树上的每个节点（除根节点外），由父节点的信息（父节点合并后的信息，除去该孩子的信息，就是其与孩子的信息）更新该节点的信息 例题1 给出一个n个节点的树，找出一个节点为根，使得树上所有节点的深度之和最大 我们先假设1号节点就是根节点，这时候，我们对树做一次dfs就可以求出每个点的子树的大小，并且同时也可以求出所有节点的深度之和 这时候，如果我们把根
树形DP-我的学习笔记
最新发布
05-17
就是赚个积分啊
树形DP的讲解
03-27
树形动态规划（树形DP）是一种特殊的动态规划方法，它将动态规划应用在树这种非线性结构上。在ACM竞赛中，树形DP是常见的算法技巧之一，尤其在区域赛中，掌握树形DP可以帮助解决许多复杂问题。 首先，树形DP的实现...
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
树形DP浅略总结
05-13
### 树形DP浅略总结 #### 一、树形DP概述 树形DP，即在树状结构上的动态规划，是一种重要的算法技术。与线性DP不同的是，树形DP考虑的问题通常涉及树结构中的节点及其之间的关系。在解决这类问题时，有两种基本的...
NOIP 提高2_树形DP
10-30
1到n。为了庆祝大学成立周年纪念，学校决定...通过以上例题的分析，可以看出树形DP不仅能够有效地解决实际问题，还能够帮助加深对动态规划的理解和掌握。此外，理解树的基本性质和遍历方式对于解决这类问题至关重要。
【动态规划】树形dp
鹭天
01-28 684
概念理解： 我们学过的一般DP方程一般都是一维或者二维的，而数组是一种线性结构，具有很强的位置关系限制(一个挨着一个)，所以一般在线性结构上的dp都很容易计算 然而除了线性的数据结构之外，还有很多非线性的数据结构，最典型的就是树。 由于树本身的特殊性质，树的局部性体现在其递归结构上：即以一个节点为根的子树是由它儿子的子树组成的，所以我们在解决树形DP问题的时候一般是选择按照层数从底向上...
【算法笔记】树形DP算法总结&详解
天生我材必有用，千金散尽还复来。
08-12 9851
树形DP，又称树状DP，即在树上进行的DP，是DP（动态规划）算法中较为复杂的一种。本文将以例题+算法的形式，详细讲解这种算法。
树状dp
shi_zi_183的博客
08-18 1962
树状dp 在树结构上做dp，常见的题型是：给出一棵树，让你实现最小代价或找到最大收益。 树这种结构本身具有“子结构”具有递归性，所以非常适合进行dp。 基于树的解题步骤一般是：先把树转为有根树（如果是几个互不连通的树，就加一个虚拟根，它连接所有孤立的树），然后在树上做DFS，递归到最底层的叶子节点，再一层层返回信息更新至根结点。显然，树上的DP所操作的就是这一层层返回的信息。不同的题目需要灵活设计不同的DP状态和转移方程。 树形dp的基本操作 先看一个简单的入门题。通过这一题，了解树的存储，以及如何在树上设
动态规划之树形DP
小L的博客
08-01 1947
本文主要讨论动态规划中的一种常见应用——树形DP。树形DP通常应用于树状结构的问题中，通过从叶子节点到根节点的动态规划过程，计算出每个节点的状态值，并最终得出问题的解。文章将介绍树形DP的基本思想、常用解法和优化技巧，并给出实例说明。通过本文的学习，读者将对树形DP有一个更深入的理解，能够更好地应用于实际问题解决中。
树状DP（算法竞赛进阶指南）
zyc_____的博客
05-08 367
树状模板：上司的舞会 选课 学校实行学分制。 每门的必修课都有固定的学分，同时还必须获得相应的选修课程学分。 学校开设了 N 门的选修课程，每个学生可选课程的数量 M 是给定的。 学生选修了这 M 门课并考核通过就能获得相应的学分。 在选修课程中，有些课程可以直接选修，有些课程需要一定的基础知识，必须在选了其他的一些课程的基础上才能选修。 例如《Windows程序设计》必须在选修了《Windows操作基础》之后才能选修。 我们称《Windows操作基础》是《Windows程序设计》的先修..
树状DP 笔记
狂想曲
08-22 117
在一棵树中，找结点值的最大和最小 可以对树进行一次遍历，在树中找到最大最小值。 我们也可以用树状DP来完成。当前结点的最值 由当前结点的值，和左孩子的最值 和 右孩子的最值决定。 struct Node{ int value; Node *left = NULL; Node *right = NULL; Node(int data){ value = data; } }; struct ReturnData { int max, min; ReturnData(int Min, i
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
树状dp(含链式前向星）
nowting的博客
04-09 313
算法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值