树形dp(+换根dp+dp结合)

已于 2022-03-03 19:40:56 修改
阅读量149 收藏 1
点赞数 3
分类专栏： dp 文章标签： 动态规划 算法 c++
于 2022-02-28 20:42:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalala625/article/details/123191283
版权

求树的重心

（重心：指树中的一个结点，如果将此结点删除后剩余各个连通块中点数的最大值最小。那么此结点被称为树的重心）
LINK
题目：
在这里插入图片描述

在这里插入图片描述

思路：

遍历每一结点，在此结点中判断是此结点的最大子树比较大还是非此结点子树的节点数比较大
下面用图来稍作解释：
在这里插入图片描述

代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
vector<int>g[N];
int f[N];//以u为根的子树的结点总数（不包括根） 
int n,a,b,mans=0x3f3f3f3f,manode;
void add(int x,int y){
	g[x].push_back(y);
}
void dfs(int son,int fa){
	f[son]=1;int maxx=0;
	for(int i=0;i<g[son].size();i++){
		int j=g[son][i];
		if(j==fa)continue;//防止往回走 
		dfs(j,son);
		f[son]+=f[j];//加上各子树的点
		maxx=max(maxx,f[j]);//寻找以fa为根的最大子树 
	}
	maxx=max(maxx,n-f[son]);//比较是fa的最大子树比较大还是非fa子树的节点数比较大 
	if(maxx<mans){//寻找最大值尽可能小 
		mans=maxx;manode=son;
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<n;i++){
		cin>>a>>b;
		add(a,b);add(b,a);
	}
	dfs(1,0);
	for(int i=1;i<=n;i++)cout<<f[i]<<" ";cout<<endl;
	cout<<manode<<" "<<mans<<endl;
	return 0; 
}

换根dp:

通常来说需要两次dfs，第一次从叶子到根；第二次从根到叶子。

求树的深度之和最大

（换根dp）

LINK
在这里插入图片描述

思路：
以1为根结点时，用dfs寻找树的深度之和，同时记录下各结点此时孩子的数量，然后dfs每点为根时运用公式（换根dp)求解；
下面用图中例子简单模拟：
在这里插入图片描述

代码：

1：数组
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
typedef long long ll;
struct node{
	int to,next;
}e[N<<1];
int n,cnt,id;
int head[N];
ll f[N],dep[N],size[N],ans;
//size[i]:i的孩子的个数
//dep[i]:i的深度
//f[i]:以i为根的树的深度和 
inline void add(int u,int v){//邻接表 
	e[++cnt].next=head[u];//连接的边 
	head[u]=cnt; //连接的下一条边 
	e[cnt].to=v; //这条边到达的点 
}
void dfs1(int x,int fa){
	size[x]=1;//每个位置初始为一个结点 
	dep[x]=dep[fa]+1;//子结点的深度=父节点深度+1 
	for(int i=head[x];i;i=e[i].next){//遍历x的子结点 
		int j=e[i].to ;//连接的点 
		if(j==fa)continue;
		dfs1(j,x);
		size[x]+=size[j];//加上孩子为根时所拥有的节点数 
	}
}
void dfs2(int x,int fa){
	for(int i=head[x];i;i=e[i].next){//遍历x的子结点 
		int y=e[i].to;
		if(y==fa)continue;
		//y为x的子结点 
		f[y]=f[x]+n-2*size[y];//x:当前结点 y:每个儿子结点 
		dfs2(y,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<n;i++){
		int v,u;cin>>u>>v;
		add(u,v);	add(v,u);
	}
	dfs1(1,0);//以1为根寻找每个子树的结点数 
	for(int i=1;i<=n;i++)f[1]+=dep[i];//计算以1为根时的深度和 
	dfs2(1,0);
	for(int i=1;i<=n;i++)
		if(ans<f[i]){
			ans=f[i];id=i;
		}
	cout<<id<<endl;
	return 0;
}
2：vector：
推荐这样使用
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
typedef long long ll;
vector<int>e[N]; 
int n,cnt,id;
ll f[N],dep[N],size[N],ans;
//size[i]:i的孩子的个数
//dep[i]:i的深度
//f[i]:以i为根的树的深度和 
void dfs1(int x,int fa){
	size[x]=1;//每个位置初始为一个结点 
	dep[x]=dep[fa]+1;//子结点的深度=父节点深度+1 
	for(int i=0;i<e[x].size();i++){//遍历x的子结点 
		int y=e[x][i];
		if(y==fa)continue;
		dfs1(y,x);
		size[x]+=size[y];
	}
}
void dfs2(int x,int fa){
	for(int i=0;i<e[x].size();i++){//遍历x的子结点 
		int y=e[x][i];
		if(y==fa)continue;
		f[y]=f[x]+n-2*size[y];
		dfs2(y,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<n;i++){
		int v,u;cin>>u>>v;
		e[u].push_back(v);e[v].push_back(u);
	}
	dfs1(1,0);//以1为根寻找每个子树的结点数 
	for(int i=1;i<=n;i++)f[1]+=dep[i];//计算以1为根时的深度和 
	dfs2(1,0);
	for(int i=1;i<=n;i++)
		if(ans<f[i]){
			ans=f[i];id=i;
		}
	cout<<id<<endl;
	return 0;
}
另一种
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
typedef long long ll;
vector<int>e[N]; 
int n,cnt,id;
ll f[N],dep[N],size[N],ans;
//size[i]:i的孩子的个数
//dep[i]:i的深度
//f[i]:以i为根的树的深度和 
void dfs1(int x,int fa){
	size[x]=1;//每个位置初始为一个结点 
	dep[x]=dep[fa]+1;//子结点的深度=父节点深度+1 
	for(auto i:e[x]){//遍历x的子结点 
		if(i==fa)continue;
		dfs1(i,x);
		size[x]+=size[i];
	}
}
void dfs2(int x,int fa){
	for(auto i:e[x]){//遍历x的子结点 
		if(i==fa)continue;
		f[i]=f[x]+n-2*size[i];
		dfs2(i,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<n;i++){
		int v,u;cin>>u>>v;
		e[u].push_back(v);e[v].push_back(u);
	}
	dfs1(1,0);//以1为根寻找每个子树的结点数 
	for(int i=1;i<=n;i++)f[1]+=dep[i];//计算以1为根时的深度和 
	dfs2(1,0);
	for(int i=1;i<=n;i++)
		if(ans<f[i]){
			ans=f[i];id=i;
		}
	cout<<id<<endl;
	return 0;
}

求树的边权值最小

LINK

在这里插入图片描述
输出格式
一行一个整数，表示最小的不方便值。

输入输出样例
输入
5
1
1
0
0
2
1 3 1
2 3 2
3 4 3
4 5 3
输出
15

思路：

以1为树的根统计此时每个节点下的牛奶数量以及从叶子到此位置时的价值；
以下例子简单理解一下：
在这里插入图片描述

代码：
数组：（更快）
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long ll;
struct node{
	int to,next,w;
}e[N<<1];
ll n,sum,ans,cnt;
int head[N];
ll f[N],size[N],a[N];
inline void add(int u,int v,int w){
	e[++cnt].next=head[u];
	head[u]=cnt;
	e[cnt].to=v;e[cnt].w=w;
}
void dfs1(int x,int fa){
	size[x]=a[x];
	for(int i=head[x];i;i=e[i].next){
		int v=e[i].to ,w=e[i].w ;
		if(v==fa)continue;
		dfs1(v,x);
		size[x]+=size[v];//统计奶牛数量 
		f[x]+=f[v]+w*size[v];//从x的子树到x所用的价值 
	}
}
void dfs2(int x,int fa){
	for(int i=head[x];i;i=e[i].next ){
		int y=e[i].to ,w=e[i].w ;
		if(y==fa)continue;
		f[y]=f[x]-w*size[y]+(sum-size[y])*w;
		ans=min(ans,f[y]);
		dfs2(y,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i],sum+=a[i];
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		add(u,v,w);add(v,u,w);
	}
	dfs1(1,0);
	ans=f[1];
	dfs2(1,0);
	cout<<ans<<endl;
	return 0;
}
vector:（两个只是循环上的差别，速度差不多 int相对比auto快一点点）
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long ll;
vector<pair<int,int>>e[N]; 
ll n,sum,ans;
ll f[N],size[N],a[N];
void dfs1(int x,int fa){
	size[x]=a[x];
	for(int i=0;i<e[x].size();i++){
		int v=e[x][i].first,w=e[x][i].second;
		if(v==fa)continue;
		dfs1(v,x);
		size[x]+=size[v];//统计奶牛数量 
		f[x]+=f[v]+w*size[v];//从x的子树到x所用的价值 
	}
}
void dfs2(int x,int fa){
	for(int i=0;i<e[x].size();i++){
		int y=e[x][i].first,w=e[x][i].second;
		if(y==fa)continue;
		f[y]=f[x]-w*size[y]+(sum-size[y])*w;
		ans=min(ans,f[y]);
		dfs2(y,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i],sum+=a[i];//sum:统计奶牛总数
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		e[u].push_back({v,w});
		e[v].push_back({u,w});
	}
	dfs1(1,0);
	ans=f[1];
	dfs2(1,0);
	cout<<ans<<endl;
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long ll;
vector<pair<int,int>>e[N]; 
ll n,sum,ans;
ll f[N],size[N],a[N];
void dfs1(int x,int fa){
	size[x]=a[x];
	for(auto i:e[x]){
		int v=i.first,w=i.second;
		if(v==fa)continue;
		dfs1(v,x);
		size[x]+=size[v];//统计奶牛数量 
		f[x]+=f[v]+w*size[v];//从x的子树到x所用的价值 
	}
}
void dfs2(int x,int fa){
	for(auto i:e[x]){
		int y=i.first,w=i.second;
		if(y==fa)continue;
		f[y]=f[x]-w*size[y]+(sum-size[y])*w;
		ans=min(ans,f[y]);
		dfs2(y,x);
	}
}
signed main(){
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i],sum+=a[i];
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		e[u].push_back({v,w});
		e[v].push_back({u,w});
	}
	dfs1(1,0);
	ans=f[1];
	dfs2(1,0);
	cout<<ans<<endl;
	return 0;
}

指定树枝数量求保留树枝边权和最大

树形dp+01背包

（太菜了 这居然是简单题？？？）
LINK
在这里插入图片描述
输入输出样例
输入
5 2
1 3 1
1 4 10
2 3 20
3 5 20
输出
21
说明/提示
1 ⩽ Q < N ⩽ 100 ， 每 根 树 枝 上 的 苹 果 ⩽ 3 × 1 0 4 1 \leqslant Q < N \leqslant 100，每根树枝上的苹果 \leqslant 3 \times10^4 1⩽Q<N⩽100，每根树枝上的苹果⩽3×104 。

思路：

题目要求以1为根，用dfs从叶子节点向上更新，利用01背包存放各点保留枝条数目的权值和；
(前提：以1为根）
f[i][j]:i的子树上保留j条边时最大权值和
注意在dp时f的[j-k-1]操作中-1是因为x与y之间也有一条边，所以后面需要加上它们之间的边权值

代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e2+10;
typedef long long ll;
ll n,m;
ll f[N][N],size[N],a[N];
//size[i]:i子树的边数 
vector<pair<int,int>>e[N];
void dfs(int x,int fa){
	for(int i=0;i<e[x].size();i++){//遍历儿子 
		int y=e[x][i].first,w=e[x][i].second;
		if(y==fa)continue;
		dfs(y,x);//从叶子节点开始向上 
		size[x]+=size[y]+1;//统计边数 
		for(int j=min(size[x],m);j;j--){//x边的数量 
			for(int k=0;k<=min(size[y],j-1ll);k++)//y边的数量 
//			for(int k=min(size[y],j-1ll);k>=0;k--)	//也可以		
				f[x][j]=max(f[x][j],f[x][j-k-1]+f[y][k]+w);//w:x与y之间的边权 
		}
	}
}
signed main(){
	cin>>n>>m;
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		e[u].push_back({v,w});
		e[v].push_back({u,w});
	}
	dfs(1,0);
	cout<<f[1][m];
	return 0;
}
Looy_cai
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++高级算法之树形DP——如何找树的重心（包看包懂）
C20200521的博客
02-12 1448
前言 最近在学树形DP，感触颇多。下面就写出来了。 题目 问题 C(2078): 求树的重心 时间限制:1 Sec内存限制:128 MB 题目描述 树的重心定义为树的某个节点，当去掉该节点后，树的各个连通分量中，节点数最多的连通分量其节点数达到最小值。树可能存在多个重心。如下图,当去掉点1后，树将分成两个连通块：（2,4,5），（3,6,7），则最大的连通块包含节点个数为3。...
树形换根DP
S_et_HKD的博客
07-11 387
树形DP之换根DP
算法【DP树】 | DP树求最大高度以及树的最大距离
weixin_45926547的博客
03-14 247
文章目录问题描述解析代码结果 问题描述 通过dp树获取树中最大距离，以及高度；使用结构体将树的信息一级一级往回传递； 解析 代码 /*---------------------------------------------------------------------- > File Name: getMaxdisDP.cpp > Author: Jxiepc > Mail: Jxiepc > Created Time: Mon 14 Mar 2022 08:20:
HDU Cotree(换根dp,树的重心)
嘘...一只bug
11-14 177
我是看了这位大佬的博客，感谢大佬他的博客 题目描述：有两颗树，需要在这两棵树之间添加一条边，这样就变成了一棵树，求这棵树任意两点之间的最小距离和 即$$\sum ^{N}{i=1}\sum ^{N}{j=i+1}dis\left( i,j\right)$$ 解题思路：首先考虑，我们要在哪两个点之间添加一条边呢？这个点实际上就是树的重心，树的重心是这样定义的：树的重心也叫树的质心。找到一个点,其所有...
树的换根(重心)
Sillver_的博客
04-01 653
题目链接： https://ac.nowcoder.com/acm/contest/4479/C 思想：树的换根 在一个树中，首先任意选一个点作为根开始深搜，计算每个子树的节点数量，和这个根节点的深度和，之后从邻接点依次转移，取最小值。 树根转换公式：dp[邻接点深度和]=dp[该点深度和]-num[该点为根的子树的节点数量]+(n-num[ ])； 公式来源：一个树的所有儿子节点的深度和可以通过...
树型dp和博弈型dp问题
yecuandu1534的博客
03-27 184
1. 树型dp. package com.sata.dp; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.*; public class TreeDp { /** * 圣诞party * Description * * 圣诞节马上就要来了，为了带动节日氛围并营造一个难得的交(tu)
树形DP-我的学习笔记
05-17
就是赚个积分啊
树形DP（动态规划）.pptx
01-12
这个问题的解决方案依赖于树形DP的核心思想，即把树的每个节点看作一个状态，并定义两个状态变量：dp[i][1] 表示节点i参与聚会且作为根时，子树内最大幽默系数之和；dp[i][0] 表示节点i不参与聚会时，子树内最大幽默...
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
概率dp 树形dp经典题目加解析
04-28
概率dp 树形dp经典题目加解析........高斯求期望...............
最大疯子树：树形DP优化：二次扫描+换根法(poj3585)
Karshilov的博客
03-22 2199
    相信看这篇文的人应该是会一些简单的线性树形dp的吧……    如果有不会的请先看看树形dp基础吧……比如这道题没有上司的舞会    其实之所以想写这篇文是因为前段时间被教练骗去叫去参加一场UESTC组织主办的线下赛，叫什么……2018青少年信息学科普活动春季体验营，然后测试的时候第一题我是用的换根法A的，于是决定皮一皮写一写。    先上题面：    最大疯子树    【题目描述】    ...
【18】输出字符菱形
2301_78786609的博客
07-19 183
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
m0_61862494的博客
07-19 95
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 157
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 119
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 128
完全二叉树的节点个数-递归
【算法】算法模板
qq_44765647的博客
07-19 148
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
树形DP详解：动态规划在信息学竞赛中的应用
"NOIP 提高2_树形DP" 树形动态规划（Tree Dynamic Programming，简称树形DP）是算法设计中的一个重要概念，特别是在解决与树结构相关的问题时显得尤为重要。NOIP（全国青少年信息学奥林匹克联赛）作为一项重要的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值