树的直径【详解树形DP】

😊😊 😊😊
不求点赞，只求耐心看完，指出您的疑惑和写的不好的地方，谢谢您。本人会及时更正感谢。希望看完后能帮助您理解算法的本质
😊😊 😊😊

目录

• 题目描述：
• 小白到进阶各种解法：
• • 一、暴搜：待更新😊
  • • 代码：
  • 二、记忆化搜索：待更新😊
  • • 代码：
  • 三、本题考察算法：树形DP😊
  • • 思路一：
    • 思路二：
    • 代码：

题目描述：

小白到进阶各种解法：

一、暴搜：待更新😊

代码：

二、记忆化搜索：待更新😊

代码：

三、本题考察算法：树形DP😊

思路一：

关键是明白 $f[u]$ 的含义是什么：
$f[u]$：表示以$u$ 为根的子树内的所有路径的集合。
属性：路径的最大值。

思路二：

首先思考答案的子集，大致算一下子集的数量，看是否可以暴力枚举所有的子集，若可以的话，则采用暴力枚举的方法即可！反之如果子集数量太多的话，则思考优化点。
本题的子集数量如下：任意两个点之间都具有唯一的路径，$n$ 个点，两两成对的话 ⇒ （起点，终点）；那么请思考这种组合有多少个？固定起点枚举终点：

for (int i=1; i <= n; i ++)
	for (int j=1; j <= n; j ++)
		...

$O（n^2）$ 级别的复杂度，$n$ 最大可取10000级别，所以时间复杂度最坏为：1e8级别。存在极大风险。这还是在没有考虑求路径长度下的时间，只是枚举起点和终点的时间复杂度。必然不行。

造成的原因在于：子集数量太多了，查找路径的时间复杂度为：$O(lo{g}_{2}n)$，而枚举起点和终点：$O(n^2)$；所以应该往枚举起点和终点上进行优化。而枚举起点和终点是什么造成的呢？是因为两个点之间的组合数量太多了，但是若能进行分类处理，则会显著减少枚举的数量。所以我们需要将原本的众多子集，进行集合的划分！分为几类，然后题目是求两个点之间的最大距离，那么我们求出每一类的最大值，最好再让每一类的最大值取一个 $max$ 即可！

采用什么样的集合划分呢？

1. 观察子集的特征，既然是一类，那么必然是具有相同的特性啦，寻找特点。
2. 我们考虑换一种 枚举方式：枚举路径的 起点和终点 → 枚举路径的 中间节点
   即从 $O(n^2)\Rightarrow O(n)$ 那么时间上就能取到最优解了。
   枚举的是中间节点，现在我们选定 6 号点这个点，且由模拟样例可知，最大距离路径也经过该点 6；不难得出，经过 6 号点的路径有3条：
   
   不难看出可以将经过 6 号节点的路径划分为2类：

第一种：以6号节点为根节点的子树的最大距离路径。
备注：第一种又可以细分为两类：一类是以6号节点为终点，6号点的子树的任意一点为起点的路径。另一种是：起点和终点都在以6号点为根节点的路径里。

第二种：选取6号点的子树中的某个节点作为起点，然后非子树中的某点作为终点，二者连接成最大值。

这里只是以 6 号点举例，其实对于任意一个节点都是这样的推导。

思考下怎么计算对于这两种，计算它的路径值。

第一种：求出根节点到每个子节点的距离，然后存取到子节点的最大距离 $d1$，和次大距离 $d2$，然后 $d[u]=d1+d2；$ 不就是以 $u$ 为根节点的子树的直径了吗？

第二种：求出非子树节点到子树节点的距离。而这一类我们可以归结到当前子树的根节点的父节点那一类里去计算。即层层递归，回溯的时候，更新每个节点的答案。回溯的时候必然会更新每棵子树的根节点到子节点的距离。再结合 $f1[u],f2[u]$ 记录每个每个u节点的最大距离和次大距离。

假设现在递归到叶子节点了，即以 $u$ 为根的子树的第一个叶子节点。由于该叶子节点没有办法再往下递归了，所以会开始回溯。而我们要计算的是：从子树的根节点 $u$ 到叶子节点的距离。那么回溯的时候应该记录：

首先肯定要加上两个点之间的边权。另外我们还要记录的是以 $u$ 号点为根节点的子树中距离 u 的最大边和次大边，记录最大边是为了往上回溯的时候用的，记录次大边是为了求出当前子树内的最大路径。

$f_1[u]=w[1]+f_1[son]；$

然后 u 的次大边的来源只有可能是：由其他分支回溯所求的新距离 $d$，

$if(d>f_1[u]),f_2[u]=f_1[u],f_1[u]=d；$

$if(d>f_2[u])f_2[u]=d；$

代码：

#include<iostream>
#include<cstring>
#include<algorithm>
 
using namespace std;

const int N = 1e4 + 10, M = 2e4 + 10;

int f1[N], f2[N];	//负责记录的是当前节点的 
int h[N], e[M], ne[M], w[M], idx;
int n;
int res;

void add (int a, int b, int c)
{
	w[idx] = c, e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

int dfs(int u, int father)
{
//初始的时候，u号节点到自己的距离等于0，因为到其他节点的距离可能为负数，
//且题目允许路径只包含一个点，只不过自己到自己的距离为0而已。 
	f1[u] = f2[u] = 0;
	for (int i=h[u]; ~i; i = ne[i])
	{
		int j = e[i];
		if (j == father) continue;
		int d = dfs(j, u) + w[i];
		
		//此时必然已经回溯到了叶子节点的父节点，即u此时为父节点！
		if (d >= f1[u]) f2[u] = f1[u], f1[u] = d;
		else if (d > f2[u]) f2[u] = d;
 	}
	res = max (res, f1[u] + f2[u]);
	return f1[u];
}

int main()
{
	cin >> n;
	memset(h, -1, sizeof(h));
	
	for (int i=0; i < n-1; i ++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add (a, b, c);
		add (b, a, c);
	}
	
	dfs(1, -1);
	cout << res << endl;
	return 0;
}

第二种写法：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1e4 + 10, M = 2e4 + 10;
int h[N], e[M], ne[M], w[M], idx;
int n;
int res;

void add (int a, int b, int c)
{
	w[idx] = c, e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

int dfs(int u, int father)
{
	int d1=0, d2=0;
	for (int i=h[u]; ~i; i = ne[i])
	{
		int j = e[i];
		if (j == father)
			continue;
		int dist = dfs(j, u) + w[i];
		if(dist > d1) d2 = d1, d1 = dist;
		else if (dist > d2) d2 = dist;
	}
	
	res = max(res, d1 + d2);
	return d1;
}

int main()
{
	cin >> n;
	memset (h, -1, sizeof (h));
	for (int i=1; i <= n-1; i ++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add (a, b, c);
		add (b, a, c);
	}
	
	dfs(1, -1);
	cout << res << endl;
	
	return 0;
}