树形DP，动态规划

已于 2024-03-30 16:18:27 修改
阅读量249 收藏 1
点赞数 3
分类专栏： C/C++ 文章标签： 算法 c++ 动态规划
于 2024-03-28 21:35:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73337964/article/details/137125241
版权

#树形DP

文章目录

一、自上而下树形DP

1、模板题

#include<bits/stdc++.h>
using namespace std;
// 例：给一棵有根树，每个点都有一个权值ai，要选择一些点使得权值和最大，且一个点被选择，其儿子不能被选择，问最大值？ 
// f[i][0],f[i][1] 表示当前点不选和选的方案得到的最大值
const int N = 1e5+2;
int n,a[N];
int f[N][2];
int head[N],cnt;

struct Edge{
	int nex,to;
}edge[N<<1];

void add(int from,int to){
	edge[++cnt].nex=head[from];
	head[from]=cnt;
	edge[cnt].to=to;
	return;
}
void dfs(int u,int fa){
	for(int i=head[u];i;i=edge[i].nex){
		int v=edge[i].to;
		if(v!=fa)continue;
		dfs(v,u);
		//代表v这个儿子的状态已经处理好了
		f[u][0]+=max(f[v][0],f[v][1]);
		//代表u这个点不选，那么v可选可不选
		f[u][1]+=f[v][0]; 
	}
}
int main(){
	ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
 	cin>>n;
 	for(int i=1;i<=n;i++){
 		cin>>a[i];
 		f[i][1]=a[i];
	 }
 	for(int i=1;i<n;i++){
 		int u,v;cin>>u>>v;
 		add(u,v);add(v,u);
	}
	dfs(1,0);
	cout<<max(f[1][0],f[1][1]);
	return 0;
}

2、树形dp关联背包问题

#include<bits/stdc++.h>
using namespace std;
const int N = 1e2+2;
int n,V;
int f[N][N]; // f[u][v]表示以u为根的子树内用了v体积的 所对应的答案
int w[N],v[N]; // w[i]表示第i个节点的权值，v[i]表示第i个节点的体积
int head[N],cnt; // 邻接表存储树的边信息
struct Edge{
    int nex,to;
}edge[N<<1];
// 添加边信息到邻接表
void add(int from,int to){
    edge[++cnt].nex=head[from];
    head[from]=cnt;
    edge[cnt].to=to;
    return;
}
// 深度优先搜索遍历树
void dfs(int u,int fa){
    // 初始化以当前节点u为根的子树内用体积0~V的所有情况的答案为-1
    memset(f[u],-1,sizeof(f[u]));
    // 如果当前节点的体积小于等于背包容量V，则初始化以当前节点u为根的子树内用当前体积的答案为当前节点的权值
    if(v[u]<=V) f[u][v[u]]=w[u];
    // 遍历当前节点u的所有子节点
    for(int i=head[u];i;i=edge[i].nex){
        int v=edge[i].to;
        // 如果子节点v等于父节点fa，则跳过，避免重复访问
        if(v==fa)continue;
        // 递归调用dfs函数，遍历子节点v
        dfs(v,u);
        // 使用动态规划更新以当前节点u为根的子树内的答案
        // 通过遍历当前节点u的子节点的体积v2，更新当前节点u的答案f[u][v1+v2]
        vector<int> nf(f[u],f[u]+V+1); // 复制当前答案到nf数组
        for(int v1=0;v1<=V;v1++){ // 遍历当前节点u已用体积v1的情况
            for(int v2=0;v1+v2<=V;v2++){ // 遍历子节点v用体积v2的情况
                nf[v1+v2]=max(nf[v1+v2],f[u][v1]+f[v][v2]); // 更新答案
            }
        }
        // 将更新后的答案nf复制回当前节点u的答案f[u]
        for(int v=0;v<=V;v++)f[u][v]=nf[v];
    }
    return;
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
	cin>>n>>V; // 输入树的节点数n和背包容量V
 	// 输入树的边信息，并构建邻接表
 	for(int i=1;i<n;i++){
 		int u,v;cin>>u>>v;
 		add(u,v);add(v,u);
	}
    // 从根节点1开始深度优先搜索遍历树
    dfs(1,0);
    // 计算最终答案，即以根节点为根的子树内的最大权值和
    int ans=0;
    for(int i=0;i<=V;i++)ans=max(ans,f[1][i]);
    // 输出最终答案
    cout<<ans;
    return 0;
}

二、自下而上树形DP

1、最大独立集

#include<bits/stdc++.h>
using namespace std;
/*	
	例题；最大独立集
	有n名职员，编号为 1~n，他们的关系就像一棵以老板为根的树，父节点就是子节点的直接上司。
	每个职员有一个快乐指数，用整数 ai 给出，现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。
 	在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。
 	即
	一个有根树，选择若干个点，使得没有相邻的两个点均被选择。最大化被选择的点的点权和。 
	状态：
		dp[u][0] 表示以u为根节点的子树中选择两两不相邻的若干个点，不选点u的最大权值和 
		dp[u][1] 表示以u为根节点的子树中选择两两不相邻的若干个点，选了点u的最大权值和
	转移：
		dp[u][0]=max(dp[v][0],dp[v][1]);
		dp[u][1]=a[u]+dp[v][0];
	答案：
		ans=max(dp[root][0],dp[root][1]); 
*/
const int N = 1e5+2;
int n, a[N]; // n表示职员数量，a[i]表示第i个职员的快乐指数
long long dp[N][2]; // dp[u][0]表示以u为根节点的子树中选择两两不相邻的若干个点，不选点u的最大权值和；dp[u][1]表示以u为根节点的子树中选择两两不相邻的若干个点，选了点u的最大权值和
vector<int> e[N]; // 存储树的邻接表

// 深度优先搜索遍历树
void dfs(int u){
	// 遍历当前节点u的所有子节点
	for(auto v : e[u]){
		// 递归调用dfs函数，遍历子节点v
		dfs(v);
		// 更新dp[u][1]和dp[u][0]
		dp[u][1] += dp[v][0]; // 选择了点u，那么点u的快乐指数就会加上所有子节点v未选择点的快乐指数和
		dp[u][0] += max(dp[v][0], dp[v][1]); // 不选择点u，那么点u的快乐指数就会加上所有子节点v中选择和不选择点的最大值
	}
	dp[u][1] += a[u]; // 最后要加上点u的快乐指数
}

int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
	cin >> n; // 输入职员数量
	set<int> st; // 使用set记录所有职员编号
	for(int i = 1; i <= n; i++){
		cin >> a[i]; // 输入每个职员的快乐指数
		st.insert(i); // 将职员编号加入set中
	}
	// 构建树的边信息
	for(int i = 1, x, y; i < n; i++){
		cin >> x >> y;
		e[y].push_back(x); // 存储树的邻接表信息
		st.erase(x); // 移除已经有父节点的节点，留下根节点
	}
	int root = *st.begin(); // 找到根节点编号
	dfs(root); // 从根节点开始深度优先搜索遍历树
	cout << max(dp[root][0], dp[root][1]); // 输出最大快乐指数和
    return 0;
}

在这里插入图片描述

2、最小点覆盖

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5+3;
int n, dp[N][2]; // dp[u][0]表示以u为根的子树中，u未被覆盖时的最小覆盖数，dp[u][1]表示以u为根的子树中，u被覆盖时的最小覆盖数
vector<int> e[N]; // 存储树的邻接表

// 深度优先搜索遍历树
void dfs(int u, int fa){
	// 遍历当前节点u的所有子节点
	for(auto v : e[u]){
		if(v == fa) continue; // 如果子节点v是当前节点u的父节点，则跳过，避免重复遍历
		dfs(v, u); // 递归调用dfs函数，遍历子节点v
		// 更新以当前节点u为根的子树中，u未被覆盖和被覆盖时的最小覆盖数
		dp[u][0] += dp[v][1]; // 如果当前节点u未被覆盖，则子节点v必须被覆盖，所以dp[u][0]加上dp[v][1]
		dp[u][1] += min(dp[v][0], dp[v][1]); // 如果当前节点u被覆盖，则可以选择子节点v被覆盖或不被覆盖中的最小值加上dp[v][1]
	} 
	dp[u][1] += 1; // 当前节点u被覆盖，所以dp[u][1]加上1
}

int main(){
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	cin >> n; // 输入节点个数
	// 构建树的边信息
	for(int i = 1; i < n; i++){
		int x, y; cin >> x >> y;
		e[x].push_back(y); // 存储树的邻接表信息
		e[y].push_back(x); // 存储树的邻接表信息
	}
	dfs(1, 0); // 从根节点1开始深度优先搜索遍历树
	cout << min(dp[1][0], dp[1][1]); // 输出以根节点1为根的子树的最小覆盖数
	return 0;
}

3、最小支配集

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

// dp[u][0]表示以u为根节点的子树中，每一个点都被支配，选了点u的最小点权和 
// dp[u][1]表示以u为根节点的子树中，未选点u的最小点权和 
// dp[u][2]表示以u为根节点的子树中，除了点u之外的其它点均被支配，但点u没有被支配的最小点权和
using ll = long long;
const int N = 1e5+3;
ll n, dp[N][3], a[N], d[N]; // n表示节点个数，dp数组存储动态规划状态，a数组存储每个节点的点权，d数组存储每个节点的入度
vector<ll> e[N]; // 存储树的邻接表

// 深度优先搜索遍历树
void dfs(int u){
	ll minn = 1e18; // 初始最小值设置为一个很大的数
	// 遍历当前节点u的所有子节点
	for(auto v : e[u]){
		dfs(v); // 递归调用dfs函数，遍历子节点v
		// 更新以当前节点u为根的子树中，每种情况的最小点权和
		dp[u][0] += min({dp[v][0], dp[v][1], dp[v][2]}); // 选了点u的情况下，子树中每个点都被支配的最小点权和是子节点v中各种情况的最小值之和
		dp[u][1] += min(dp[v][0], dp[v][1]); // 未选点u的情况下，子树中每个点都被支配的最小点权和是子节点v中选点u或不选点u的最小值之和
		minn = min(minn, dp[v][0] - min(dp[v][0], dp[v][1])); // 计算子节点v中除了点u之外的其它点均被支配，但点u没有被支配的最小点权和
		dp[u][2] += dp[v][1]; // 子树中除了点u之外的其它点均被支配，但点u没有被支配的最小点权和是子节点v中未选点u的情况下的点权和之和
	}
	dp[u][0] += a[u]; // 加上当前节点u的点权
	dp[u][1] += minn; // 加上当前节点u的最小点权和
}

int main(){
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	cin >> n; // 输入节点个数
	// 构建树的边信息和节点点权
	for(int i = 1; i <= n; i++){
		int id, m; cin >> id >> a[id] >> m; // 输入节点编号、节点点权和子节点个数
		while(m--){
			int x; cin >> x; // 输入子节点编号
			e[id].push_back(x); // 存储树的邻接表信息
			d[x]++; // 子节点入度加1
		}
	}
	int rt; // 根节点
	for(int i = 1; i <= n; i++){
		if(d[i] == 0) rt = i; // 找到根节点
	}
	dfs(rt); // 从根节点开始深度优先搜索遍历树
	cout << min(dp[rt][0], dp[rt][1]); // 输出以根节点为根的子树的最小点权和
	return 0;
}

三、路径相关树形DP

1、找到n条路经，其权值之和要求最大

#include<bits/stdc++.h>
using namespace std;

/*
    给你一个n个点的树。给你m条树上的简单路径，每个路径有个权值ai。
    要求选择一些路径，使得每个点至多在一条路径上，并且路径的权值和最大。
    状态：
    f[i][j]表示以i为节点的子树中，选择了通过节点i的路径j的最大路径权值和。
    g[i]表示节点 i 没向 i 上面延伸出去的最优解。
    转移：
    j=0，i不在任何路径中，f[i][j]=g[v]
    j!=0,i不在路径j上，f[i][j]=f[?][j]=g[?]+g[v] 
*/

// 定义长整型
using ll = long long;
// 定义树的最大节点数量
const int N = 1e3+2;

// 定义树的邻接表结构体
vector<int> e[N], t;
// 定义操作结构体
struct rig {
    vector<int> vec;  // 路径节点向量
    ll val;           // 操作权值
};
// 定义每个节点的操作信息数组
vector<rig> w[N];
// 定义每个节点的最大路径权值和数组
ll dp[N];
// 定义节点数量、操作数量、节点深度数组和父节点数组
int n, m, dep[N] = {1}, f[N];

// 深度优先搜索遍历树
void dfs(int u) {
    // 遍历当前节点u的所有子节点
    for(auto v : e[u]) {
        dfs(v);            // 递归调用dfs函数，遍历子节点v
        dp[u] += dp[v];    // 更新当前节点u的最大路径权值和，累加子节点v的最大路径权值和
    }

    // 遍历当前节点u的操作信息
    for(auto t : w[u]) {
        ll sum = dp[u];    // 初始化sum为当前节点u的最大路径权值和
        // 遍历操作涉及的节点路径
        for(auto nw : t.vec) {
            sum -= dp[nw];  // 减去路径节点的最大路径权值和
            // 遍历路径节点的子节点
            for(auto v : e[nw]) sum += dp[v];  // 加上路径节点的子节点的最大路径权值和
        }
        // 更新当前节点u的最大路径权值和，取sum加上操作权值t.val的最大值
        dp[u] = max(dp[u], sum + t.val);
    }
}

int main() {
    // 解除cin与cout的绑定，提高输入输出效率
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);

    // 输入节点数量和操作数量
    cin >> n >> m;
    // 构建树的结构信息和深度信息
    for(int i = 2; i <= n; i++) {
        cin >> f[i];              // 输入每个节点的父节点
        e[f[i]].push_back(i);    // 构建树的邻接表
        dep[i] = dep[f[i]] + 1;  // 计算每个节点的深度
    }

    // 读入操作信息
    for(int i = 1, x, y; i <= m; i++) {
        ll val;
        cin >> x >> y >> val;   // 输入操作的起点、终点和权值
        t.clear();              // 清空临时路径数组
        // 计算操作的节点路径
        while(x != y) {
            if(dep[x] > dep[y]) t.push_back(x), x = f[x];
            else t.push_back(y), y = f[y];
        }
        t.push_back(x);         // 加入终点
        w[x].push_back({t, val});  // 存储操作信息
    }

    // 从根节点开始深度优先搜索遍历树
    dfs(1);
    // 输出根节点的最大路径权值和
    cout << dp[1];
    return 0;
}

2、找到n条路经，其权值之和要求最小

#include<bits/stdc++.h>
using namespace std;

/*
    给你一个n个点的树。给你m条树上的简单路径，每个路径有个权值ai。这里保证每条路径都是从一个点到它的祖先。 
    要求选择一些路径，使得每个点至多在一条路径上，并且路径的权值和最小。如果不存在输出-1。 
    状态：
    dp[i][j]表示以i为根的子树中全部覆盖，且往根最高延伸到深度j的节点的最小代价。相当于每条路径在最低点考虑。 
    转移：
    不选择以i为最低点的路径：dp[i][j]=dp[v][dep[i]+1]=min(dp[i][j]-dp[v][dep[i]+1]); 
	对于每一条以i为最低点的路径v，dp[i][dep[v.x]]=min(dp[i][dep[v.x]],v.val+dp[v][dep[i]+1]); 
*/

// 定义长整型
using ll = long long;
// 定义树的最大节点数量
const int N = 1e3+2;

// 定义树的邻接表结构体
vector<int> e[N];
// 定义操作结构体
struct rig {
    int x;  // 路径节点向量
    ll val;           // 操作权值
};
// 定义每个节点的操作信息数组
vector<rig> w[N];
// 定义每个节点的最大路径权值和数组
ll dp[N][N];
// 定义节点数量、操作数量、节点深度数组和父节点数组
int dep[N],n,m;

// 深度优先搜索遍历树
void dfs(int u) {
    // 遍历当前节点u的所有子节点
    ll sum = 0;  // 记录以当前节点u为根的子树的最小代价
    // 初始化每个深度的节点的最小代价为无穷大
    for(int i = 1; i <= dep[u]; i++) dp[u][i] = LLONG_MAX;
    // 遍历当前节点u的每一个子节点v
    for(auto v : e[u]) {
        dfs(v);            // 递归调用dfs函数，遍历子节点v
        sum += dp[v][dep[u]+1];  // 计算以当前节点u为根的子树的最小代价
        // 如果子树的最小代价已经足够大，无法继续延伸
        if(sum >= LLONG_MAX){
            cout << "-1";  // 输出-1表示不存在解
            exit(0);       // 退出程序
        } 
        // 更新当前节点u的每个深度的节点的最小代价
        for(int i = 1; i <= dep[u]; i++) dp[u][i] = min(dp[u][i], dp[v][i] - dp[v][dep[u] + 1]);
    }
    // 对于每一个操作路径v，更新当前节点u的每个深度的节点的最小代价
    for(auto v : w[u]) {
        dp[u][dep[v.x]] = min(dp[u][dep[v.x]], sum + v.val);  // 更新最小代价
    }
    // 处理当前节点u的每个深度的节点的最小代价，保证递增性质
    for(int i = 2; i <= dep[u]; i++) dp[u][i] = min(dp[u][i], dp[u][i - 1]);
}

int main() {
    // 解除cin与cout的绑定，提高输入输出效率
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    // 输入节点数量和操作数量
	cin >> n >> m;
	// 构建树的结构信息和深度信息
	for(int i = 2; i <= n; i++) {
		int f;  // 父节点
		cin >> f;  // 输入每个节点的父节点
		e[f].push_back(i);  // 构建树的邻接表
		dep[i] = dep[f] + 1;  // 计算每个节点的深度
	}
	// 读入操作信息
	for(int i = 1, x, y; i <= m; i++) {
		ll val;  // 操作权值
		cin >> x >> y >> val;  // 输入操作的起点、终点和权值
		if(dep[x] > dep[y]) swap(x, y);  // 交换x和y保证x为较低的节点
		w[y].push_back({x, val});  // 存储操作信息
	}
	// 从根节点开始深度优先搜索遍历树
	dfs(1);
	// 输出根节点的最小路径权值和
	cout << dp[1][1];
    return 0;
}

四、换根DP

换根DP，又叫做二次扫描，是树形DP的一种。
特点：以树上的不同点作为根，其解不同，无法通过一次搜索完成答案的求解，因为一次搜索只能得到一个节点的答案。
题目一般为：一棵树…求一哪一个节点为根的时候，xxx最大或最小…
先以树形DP的形式求出以某一个点为根的时候的答案，然后在进行一次自上而下的DFS计算答案。1.树形dp 2.dfs

例题：

给定一棵n个点的无根树，点带权，边带权，求一个点，使得其他点的距离和最小。
距离：a->b的距离为a的点权乘以a->b的路径长度。

分析：

考虑f[i]表示以i为根子树中到i的距离之和。
第一次dfs从下至上递推出各点的f[i]和子树siz[i]
ans[v]=ans[u]-siz[v]*a[i].w+(cnt-siz[v])*a[i].w；
步骤：
1、指定某个节点为根节点；
2、第一次搜索完成预处理(子树大小），同时得到该节点的解；
3、第二次搜索进行换根的dp，由已知解的节点推出相连节点的解。

示例代码：

#include<bits/stdc++.h> // 引入标准 C++ 库的所有头文件
using namespace std;
using ll = long long; // 定义 long long 类型的别名 ll
const int N = 1e3+2; // 定义数组大小常量 N

// 定义边结构体
struct edge{
	int nex, to, dis; // 下一条边的索引，目标节点，边的距离
} e[N<<1]; // 边数组

int n, c[N], dist[N]; // 节点数、节点颜色数组、节点到根节点的距离数组
int siz[N], head[N], cnt, tot; // 子树大小数组、邻接表头、计数器、节点颜色总和

// 添加边的函数
void add(int from, int to, int dis){
	e[++cnt] = {head[from], to, dis}; // 新建边，更新邻接表
	head[from] = cnt; // 更新头节点指针
	return;
}

int sum[N]; // 子树节点颜色和数组
ll f[N]; // 子树颜色调整的代价数组

// 深度优先搜索计算子树大小和节点颜色和
void dfs(int x, int fa){
	siz[x] = 1; // 初始化节点 x 的子树大小为 1
	sum[x] = c[x]; // 初始化节点 x 的子树颜色和为 c[x]
	for(int i = head[x]; i; i = e[i].nex){ // 遍历节点 x 的邻接节点
		int v = e[i].to; // 邻接节点的索引
		if(v == fa) continue; // 如果邻接节点是父节点，则跳过
		dist[v] = dist[x] + e[i].dis; // 更新邻接节点到根节点的距离
		dfs(v, x); // 递归计算邻接节点的子树大小和颜色和
		siz[x] += siz[v]; // 更新节点 x 的子树大小
		sum[x] += sum[v]; // 更新节点 x 的子树颜色和
	}
	return;
}

// 深度优先搜索计算子树颜色调整的代价
void dfs1(int x, int fa){
	for(int i = head[x]; i; i = e[i].nex){ // 遍历节点 x 的邻接节点
		int v = e[i].to; // 邻接节点的索引
		if(v == fa) continue; // 如果邻接节点是父节点，则跳过
		f[v] = f[x] - sum[v] * e[i].dis + (tot - sum[v]) * e[i].dis; // 计算邻接节点的代价
	}
	return;
}

int main(){
	ios::sync_with_stdio(false); // 关闭输入输出流同步，加快 I/O 速度
	cin.tie(nullptr); // 解除 cin 和 cout 的绑定
	cout.tie(nullptr);
	cin >> n; // 输入节点数
	for(int i = 1; i <= n; i++) cin >> c[i], tot += c[i]; // 输入节点颜色并更新颜色总和
	for(int i = 1; i < n; i++){ // 输入 n-1 条边的起点、终点和距离
		int a, b, c; cin >> a >> b >> c;
		add(a, b, c); // 添加边 (a, b)
		add(b, a, c); // 添加边 (b, a)
	}
	dfs(1, 0); // 计算节点 1 的子树大小和颜色和
	ll ans = 1e18; // 初始化答案为一个很大的数
	for(int i = 1; i <= n; i++) ans = min(ans, f[i]); // 更新答案为最小的代价
	cout << ans; // 输出答案
	return 0; // 返回 0，表示程序正常结束
}
席万里
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树形DP（动态规划）.pptx
01-12
树形DP.pptx
树形DP-我的学习笔记
05-17
就是赚个积分啊
动态规划（树形dp）
dzy521的博客
07-04 705
#### 四、树形dp ##### （一）、基础 树形$dp$是在树的$dfs$中进行$dp$， 在树形$dp$中，我们动态规划的过程大概就是先递归访问所有子树，再在根上合并，我们求解的往往是所有的在子树范围内的最优解 ##### （二）、例题 1、子树大小 （1）、题意：计算每个点的子树的大小 （2）、题解： 状态表示：$sz[u]$代表$u$为根的子树大小 状态转移：$sz[u]=1+\sum sz[v]$，指本节点的子树大小等于子节点的所有子树大小之和加一 ```cpp int sz
动态规划——树形dp
qq_57150526的博客
01-03 2495
树形 DP，即在树上进行的 DP。由于树固有的递归性质，树形 DP 一般都是递归进行的。在树上设计动态规划算法时，一般就以节点从深到浅（子树从小到大）的顺序作为DP的“阶段”，DP的状态表示中，第一维通常是节点编号（代表以该节点为根的子树）。自底向上dfs，属于树的后序遍历
树形DP1【2024蓝桥杯0基础】-学习笔记
m0_66538833的博客
03-09 289
自上而下的树形DP相关内容
动态规划：树形DP
sdfzhqy的博客
01-14 398
动态规划：树形dp
动态规划之树形DP
小L的博客
08-01 1835
本文主要讨论动态规划中的一种常见应用——树形DP。树形DP通常应用于树状结构的问题中，通过从叶子节点到根节点的动态规划过程，计算出每个节点的状态值，并最终得出问题的解。文章将介绍树形DP的基本思想、常用解法和优化技巧，并给出实例说明。通过本文的学习，读者将对树形DP有一个更深入的理解，能够更好地应用于实际问题解决中。
树形动态规划（dp）
Conqueror_demons的博客
01-13 943
一、基本概念 树形动态规划，顾名思义，就是在“树”的数据结构上做动态规划， 通过有限次地遍历树，记录相关信息，以求解问题。通常，动态规划 都是线性的或者是建立在图上的，线性的动态规划的顺序有两种方向 即向前和向后，相应的状态转移方程有两种，即顺推与逆推，而树形 动态规划是建立在树上的，树中的父子关系天然就是个递归（子问题） 结构，所以也相应的有两个方向。 （1）叶→根，即根的子结点传递有用的信息给根，之后由根得出 最优解的过程。这种方式DP的题目应用比较多。 （2）根→叶，即需要取所有点作为一次根结点
动态规划报告（树形DP+概率DP
wangym1111的博客
02-07 3072
树形DP 概率DP
动态规划：树形DP入门（四道例题c++）
ylh的博客
02-08 787
树形DP基本概念，生命之树，没有上司的舞会，二叉苹果树，选课
动态规划之树形动态规划
rsz364110的博客
08-17 236
无
树形DP(树形动态规划)算法 + 例题(树的重心，树上最远距离...)
Gaoithe的博客
08-22 1191
一、 简介： 树形DP就是在树的数据结构上计算DP值。 树形DP有两个方向：叶->根、根->叶。 树形DP通过记忆化搜索实现，因此采用递归实现。 时间复杂度一般为O(n)，若有维数m，则为O(n*m)。 二、 经典问题： 1. 树的重心：http://poj.org/problem?id=1655 叶->根 所谓重心就是各分支大小围绕该点能较均匀的分...
树形dp 入门模板题
qq_33969563的博客
05-20 848
树形dp • 树型dp一般先算子树然后进行合并，在实现上与树的后序遍历（这个说法并不准确，因为其实很多都不是二叉树）类似——遍历子树，遍历完之后把子树的值合并给父亲。 • 大部分的树形dp都是利用递归，先确定叶子结点的特征，然后推上去，即状态转移方程一般都是有该点的某些特征 = 其子节点的一些特征 • 有的树形dp以哪个点为根节点无所谓，有的有所谓。 引入 • 给你一棵n个点的树（1号点为根节点），求以点i为根的子树的大小 • f[i]以点i为根的子树的点的个数 • f[i] = 1+Σf[k] (k是i的
树形dp_树形动态规划_讲解PPT
05-03
暂时看的一个比较好地讲解树形DP的课件，对初步了解树形DP有帮助
树形动态规划详细讲解
01-19
树形DP详细讲解
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 310
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 380
动态规划理论基础（主要就是确定动态规划的几个步骤）
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
最新发布
2201_75456895的博客
05-30 1181
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
python树形dp
04-08
树形动态规划（Tree DP）是一种常用的动态规划算法，用于解决树结构相关的问题。在Python中，可以使用递归或者迭代的方式实现树形DP。 树形DP的基本思想是，从树的叶子节点开始，逐层向上计算每个节点的状态，并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

席万里

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值