关于我对树形dp的理解及一道例题的应用
树形dp介绍
树形动态规划(Tree DP)是指在树型结构上进行动态规划的一种算法思想。树形DP常用于解决在树中求解最优解问题,其核心思想是利用树的递归结构和动态规划的思想,将问题拆解成子问题,然后利用子问题的结果来求解原问题。
在树形DP中,一般需要定义一个适当的状态来表示子问题的最优解,并且需要确定递归求解子问题的顺序。常见的树形DP算法包括以下两种:
1. 自顶向下的递归算法:首先从根节点开始递归求解子问题,然后逐层向下递归,直到叶子节点。这种算法的关键是确定递归的顺序和边界条件。
2. 自底向上的递推算法:从叶子节点开始递推,逐层向上计算父节点的最优解,并用父节点的最优解更新子节点的状态。这种算法需要先确定边界条件,然后按照树的拓扑序进行递推。
树形DP的经典问题包括:
1. 求解树的最大独立集和最小顶点覆盖问题。
2. 求解树的最长路径和最大权重路径问题。
3. 求解树的最大权重度数为2的点集的最小顶点覆盖问题。
4. 求解树的最大权重度数为1的点集的最小顶点覆盖问题。
以上是对树形DP的简单介绍,树形DP算法的具体实现会根据具体问题的不同而有所差异。
我们讲以树的最大路径这个经典例题来学习
一、POJ2196Computer
输入与输出:第一行输入n,后面有n-1行,第i行表示某个结点;第i个结点连接到这个结点的距离,不超过1e9;
二、解题过程
1.树的处理构建与实现
dp作用及原理,假设边长均相等,假设如图1所示的树,1为根结点
![](https://i-blog.csdnimg.cn/blog_migrate/891249f15727e54a7692961e6cae822d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/921101cfa31234cdf598c7e163c1bf9f.png)
如果结点是1根结点时,显然最长时10-1-13(如图2),如何计算呢,我们首先能求出最大深度,1-6-8-11-12-13,那对于次长度如何求,这时候就得考虑最长度和次长度,由此我们需要设置dp[][0]来记录以i为结点的最大子树的长度,dp[][1]则是以i为结点的次要长度,但是认为这样就结束了,显然是没有考虑周全的。
如果结点是3或者是10又或者是13时,没有子树的结点情况就不一样,因此我们需要增加一个dp[][2]来记录这种情况,所以初始化时如下:
而在初始化时,我们要记录两个变量,x,y
x表示x编号的结点,y表示边长的大小,id则表示x结点与id结点连接
对于dfs的实现,我们可以先考虑子结点的处理,即只需要考虑最大长度和次长长度,我们设one为第一长,two为第二长
我们要先遍历此时father结点的所有子树,所以必然需要递归才能算出到底有多长,我们用child来作为临时变量,用来计算和递归,用临时变量cost来记录最大长度,通过递归不断更新迭代,当cost为最大时,我们需要进行替换,不能忘记第二种if的情况,在每次dfs结束前将one和two赋值给此结点的dp
只这样dfs搜索一次是不够的,对于第二次的dfs显然也不是重复第一次dfs的操作,我们要进行调整:
dfs2的搜索是要在dfs1后进行的,此时各结点的子树最长和次长已经确定好,我们从根结点出发,即最高的父结点,对它的儿子开始递归,用child作临时变量,首先我们需要判断两种情况:
1.假如结点是在最长子树上,假如我们要求结点6的最长路径,此时满足dp[6][0]+chil.cost=dp[father][0],即在最长距离的子树上,则最大值为上一个的dp[][2]的长度或者是父结点+自己到父结点的距离(黄+蓝)
2.假如结点不在最长子树上,则需要递归加上父结点的最长距离,我们以结点3来假设,3的父结点是2,2的最长子树是2-1-6-8-11-12,3并不在最长子树上,我们显然知道最长应该是3到2的距离加上2的最长子树
![](https://i-blog.csdnimg.cn/blog_migrate/7a88bb4f7f7c644db534cd3e83ef0bb1.png)
![](https://i-blog.csdnimg.cn/blog_migrate/1c2eeac3ff9bdaa84cff764144fdaefa.png)
因此我们的dfs2实现应该如下图所示:
2.代码实现
代码实现:
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 9;
struct Node
{
int id;//结点编号
int cost;//权值
};
vector<Node>tree[N];
//dp[i][0]为结点i到i的子树的最长距离
//dp[i][1]为结点i到i的子树的次长距离
//dp[i][2]为结点i往上走的最短距离
int dp[N][3];
int n;
void init_read()
{
for (int i = 1; i <= n; i++)
tree[i].clear();//初始化
memset(dp, 0, sizeof(dp));
for (int i = 2; i <= n; i++)
{
int x, y;
Node tmp;
cin >> x >> y;
tmp.cost = y;
tmp.id = i;
tree[x].push_back(tmp);
}
}
void dfs1(int father)//先处理子结点,后处理父结点
{
int one = 0, two = 0;
//遍历father 的所有子结点
for (int i = 0; i < tree[father].size(); i++)
{
Node child = tree[father][i];
dfs1(child.id);//递归到底部
int cost = dp[child.id][0] + child.cost;//等于此时i到i的子树最长距离
if (cost >= one)//如果大于已知的最长距离
{
two = one;
one = cost;
}
if (cost<one && cost>two)//判断次长距离
{
two = cost;
}
}
dp[father][0] = one;//得到最长距离
dp[father][1] = two;//得到次长距离
}
void dfs2(int father)//先处理父结点,后处理子结点
{
for (int i = 0; i < tree[father].size(); i++)
{
Node child = tree[father][i];
if (dp[child.id][0] + child.cost == dp[father][0])
//dp[i][1]为结点i到i的子树的次长距离
//dp[i][2]为结点i往上走的最短距离
dp[child.id][2] = max(dp[father][2], dp[father][1]) + child.cost;
else
//child不在最长距离的子树上
dp[child.id][2] = max(dp[father][2], dp[father][0]) + child.cost;
dfs2(child.id);
}
}
int main()
{
while (~scanf("%d ", &n))
{
init_read();
dfs1(1);
dp[1][2] = 0;
dfs2(1);
for (int i = 1; i <= n; i++)
{
cout << max(dp[i][0], dp[i][2]);
cout << '\n';
}
}
return 0;
}
三、例题应用(OJ3649最长乘积链)
1.题目与分析
题目:1.最长乘积链 - 蓝桥云课 (lanqiao.cn)
这题与树的最长路径异曲同工之妙,也是求最长边和次长边+向上的最长路径
如图所树,只有3,2入度不为1,则意味着只有这两个点有多种路径,可以总结为两种情况:1.向下的最长边+向下的次最长边 2.向下的最长边和向上的最长边 这两个情况取最大值即为答案
2.代码实现:
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 4;
struct Node {
int id;//编号
int len;//两点之间的边长
};
int n;
int dp[N][3];
//dp[i][0]表示以i为结点的最长子树
//dp[i][1]表示以i为结点的次最长子树、
//dp[i][2]表示以i为结点向上的最长树
vector<Node>tree[N];
//由于建立的无向图,所以要设立fa来控制,防止超内存
//dfs1先处理子结点
void dfs1(int u,int fa)
{
int one = 0, two = 0;
for (int i = 0; i < tree[u].size(); i++)
{
Node child = tree[u][i];
if (child.id == fa) continue;//如果子结点为上一个的父结点跳过
dfs1(child.id,u);//递归
int cost = dp[child.id][0] + child.len;//计算cost
if (cost > one)
{
two = one;
one = cost;
}
if (cost<one && cost>two)
{
two = cost; }
}
dp[u][0] = one;//赋值最大值
dp[u][1] = two;//赋值次大值
}
//dfs2处理父结点的问题
void dfs2(int u,int fa)
{
for (int i = 0; i < tree[u].size(); i++)
{
Node child = tree[u][i];
if (child.id == fa) continue;
if (dp[child.id][0]+child.len==dp[u][0])
//当子结点在最长子树的路径上时
//向上的话加上次最长的边长即可
dp[child.id][2] = child.len + max(dp[u][2], dp[u][1]);
else
//如果子结点不在最长子树的路径上时
//则向上加上最长子树的路径即可】
dp[child.id][2] == child.len + max(dp[u][2], dp[u][0]);
dfs2(child.id, u);//进行递归
}
}
int main()
{
cin >> n;
for (int i = 1; i < n; i++)
{
int a, b, c; cin >> a >> b >> c;
//建立无向图
tree[a].push_back({ b,c });
tree[b].push_back({ a,c });
}
dfs1(1,0);//第一次遍历
dfs2(1,0);//第二次遍历
ll ans = 0;
for (int i = 1; i <= n; i++)
{
ans = max(ans, max(1ll * dp[i][0] * dp[i][1], 1ll * dp[i][2] * dp[i][0]));
}
cout << ans << '\n';
return 0;
}
四、有点坑的例题(OJ4329树的连边II)
1.题目与分析:1.树的连边II - 蓝桥云课 (lanqiao.cn)
在此引入 树形DP 解题:
- 指定任意一个根节点。
- 一次dfs 遍历,统计出每个点向下走的最大值与次大值,以及最大值下去的方向与次大值下去的方向,最大值和次大值走的不是同一方向。
- 一次dfs 遍历,统计出先向上走的最大值。
最大值与次大值更新原理为:当前结点到子节点的距离加上子节点到叶子结点的最远距离,我们对这些子结点求最大值与次大值即可。
处理次大值的原因是:
当我们求向上走的最大值时,原理为我到父结点的距离加上父结点到别的点的最远距离,如果父结点到别的点的最远距离经过我时则不能使用,此时就得变成我到父结点的距离加上父结点到别的点的次远距离。
其他方法也异曲同工,值得注意的坑是,由于边长都为1,不能单纯的用下面这个等式判断
所以要引入p[i]来记录最近的子结点
p1[i]:记录以i为根节点最长路径走的最近子节点
p2[i]:记录以i为根节点次长路径走的最近子节点
2.代码实现:
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
int dp[N][3];
int p1[N],p2[N];
vector<int> tree[N];
int n;
void dfs1(int x, int fa)
{
int one = 0, two = 0;
for (int i = 0; i < tree[x].size(); i++)
{
int child = tree[x][i];
if (child == fa) continue;
dfs1(child, x);
int cost = dp[child][0] + 1;
if (cost > one)
{
two = one;
p2[x] = p1[x];
p1[x] = child;
one = cost;
}
if (cost<one && cost>two)
{
two = cost;
p2[x] = child;
}
}
dp[x][0] = one;
dp[x][1] = two;
}
void dfs2(int x, int fa)
{
for (int i = 0; i < tree[x].size(); i++)
{
int tmp = tree[x][i];
if (tmp == fa) continue;
if (p1[x] == tmp)
dp[tmp][2] = max(dp[x][2], dp[x][1]) + 1;
else
dp[tmp][2] = max(dp[x][2], dp[x][0]) + 1;
dfs2(tmp, x);
}
}
int main()
{
cin >> n;
for (int i = 1; i <= n - 1; i++)
{
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
dfs1(1, -1);
dp[1][2] = 0;
dfs2(1, -1);
int ans = 0;
for (int i = 1; i <= n; i++)
{
ans = max(ans, max(dp[i][0] + dp[i][2], dp[i][1] + dp[i][0]));
}
cout << ans << '\n';
return 0;
}
注释就不加了,可以去练练更多的题目了