树的直径总结

树的直径

一、定义

在一棵树中，最远的两个子节点之间的距离被称为树的直径；

链接这两个点的路径被称为树的最长链；

有两种求法，时间复杂度均为 $O(n)$ ；

二、树形DP

1. 状态

由于一个点的最长路通过其子节点转移来，所以定义状态为

$dp[i]$ 表示经过 $i$ 点的最长路；

2. 转移

设有子树根结点为 $i$ ，其子节点为$u_1,u_2,\dots ,u_n$ ；

则对于经过 $i$ 结点的最长路，即为经过其子节点 $u_j$ 与 $u_k$ 的最长路和+经过 $i$ 结点多走的两条边权；

则有
dp[i]=max⁡{dp[uj]+dp[uk]+edge[i][j]+edge[j][k]} dp[i] = \max \{ dp[u_j] + dp[u_k] + edge[i][j] + edge[j][k] \} dp[i]=max{dp[uj​]+dp[uk​]+edge[i][j]+edge[j][k]}
但转移时，不需要将 $j$ 与 $k$ 具体值进行枚举，后连接 $u_j$ 与 $u_k$ ，只需要将 $u_j$ 连接到 $i$ 的子节点的最长路的最大值即可；

枚举 $j$ 时，$dp[i]$ 保存了从节点 $i$ 出发走向以 $u_k(k<j)$ 为根的子树能够到达的最远距离，这个距离为，
dp[i]=max⁡1≤k<j{dp[uk]+edge[i][uk]} dp[i] = \max_{1 \leq k < j} \{ dp[u_k] +edge[i][u_k] \} dp[i]=1≤k<jmax​{dp[uk​]+edge[i][uk​]}
则此时经过 $i$ 的最长路为 $dp[i]+dp[u_j]+edge[i][u_j]$ ，但不能将这个值来更新 $dp[i]$ ，否则后面的转移不符合前提，则直接使用这个值更新答案，用 dp[i]=max⁡{dp[uj]+edge[i][uj]}dp[i] = \max\{dp[u_j] + edge[i][u_j] \}dp[i]=max{dp[uj​]+edge[i][uj​]} 更新 $dp[i]$ ，即可；

3. 代码

以带边权的双向建边邻接表存储树为例；

void dfs(int i) {
	flag[i] = true;
	for (int t = 0; t < g[i].size(); t++) {
		int u = g[i][t].to, tot = g[i][t].tot;
		if (!flag[u]) {
			dfs(u);
			ans = max(ans, dp[i] + dp[u] + tot);
			dp[i] = max(dp[i], dp[u] + tot);
		}
	}
	return;
}

三、DFS

1. 思路

向下最长路 + 向下次长路 == 经过此点的最长路；

证明如下

有

$down1[i]$ 表示 $i$ 结点的向下最长路；

$down2[i]$ 表示 i 结点的向下次长路；

$up[i]$ 表示 i 结点的向上最长路；

有一节点 $u$ ，其子节点为 $i_1$ 与 $i_2$ ，父节点为 $v$ ;

对于 $u$ 点的最长路，有两种情况，

1. $up[u]+down1[u]$；
2. $down1[u]+down2[u]$；

则两种情况的最大值为经过 $u$ 点的最长路；

若 $up[u]+down1[u]$ 为最大值，则对于 $u$ 的父节点 $v$ ，过 $v$ 的最短路为 $down1[v]+down2[v]$ ，

即最长路为向下最长路 + 向下次长路；

则证明成立；

2. 实现

用一个 DFS 从上向下搜索，在返回时，用过子结点的最长路更新父节点的向下最长路；

关于向下次长路，有

当向下最长路值更新时，其原来的值便为向下次长路值；

则搜索每个结点的向下最长路与向下次长路；

直径便是向下最长与向下次长路的和的最大值；

3. 代码

以带边权的双向建边邻接表存储树为例；

void dfs1(int i) {
	flag[i] = true;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t].to, tot = g[i][t].tot;
		if (!flag[v]) {	
			dfs1(v);
			int val = down1[v] + tot;
			if (val > down1[i]) {
				down2[i] = down1[i];
				down1[i] = val;
			} else {
				down2[i] = max(down2[i], val);
			}
		}
	}
	ans = max(ans, down1[i] + down2[i]);
	return;
}

四、求直径的点

判断一点是否在直径上，即判断经过此点的最长路是否为直径即可；

因为有

向下最长路 + 向下次长路 = 经过此点的最长路；

所以存储向下最长路与向下次长路；

但是，又因为树的直径可能有多条，即树的直径经过一点时可能有两种情况，

1. 将此点作为转折点，此时有

   向下最长路 + 向下次长路 == 直径；

2. 将此点作为不转折的点，此时有

   向下最长路 + 向上最长路 == 直径；

所以还要存储向上最长路；

当一个点的 向下最长路 + 向下次长路 = 直径 或 向下最长路 + 向上最长路 = 直径 时，则说明此点在直径上；

求向上最长路

思路

从上向下搜索，用父节点的向上最长路更新子节点的向上最长路；

则有 $i$ 为父结点， $u$ 为子节点时， $u$ 的向上最长路即为 $i$ 的向上最长路与 $i$ 的向下最长路的最大值；
up[u]=max⁡{max⁡{up[i],down1[i]}+edge[i][u]} up[u] = \max \{ \max \{ up[i], down1[i] \} + edge[i][u] \} up[u]=max{max{up[i],down1[i]}+edge[i][u]}
但是，$i$ 的向下最长路可能包含 $u$ ，即 $down1[i]-down1[u]==edge[i][u]$ 时，此时则会重复走过 $u$ 点；

所以此时判断是否有其余的 $u_1$ 使 $down1[i]-down1[u_1]==edge[i][u_1]$ 成立；

若有，则说明上转移式可以满足，即从 $u$ 走到父节点 $i$ 经过满足条件的点 $u_1$ 向下走；

若没有，则说明上转移式最大值时不能取 $down1[i]$ 则取 $down2[i]$ ，即
up[u]=max⁡{max⁡{up[i],down2[i]}+edge[i][u]} up[u] = \max \{ \max \{ up[i], down2[i] \} + edge[i][u] \} up[u]=max{max{up[i],down2[i]}+edge[i][u]}

代码

以带边权的双向建边邻接表存储树为例；

void dfs2(int i) {
	flag[i] = true;
	int ans = 0;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t].to, tot = g[i][t].tot;
		if (!flag[v]) {
			if (down1[i] == down1[v] + tot) {
				ans++;
			}
		}
	}
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t].to, tot = g[i][t].tot;
		if (!flag[v]) {
			if (down1[i] != down1[v] + tot || (ans > 1 && down1[i] == down1[v] + tot)) {
				up[v] = max(up[v], max(up[i], down1[i]) + tot);
			} else {
				up[v] = max(up[v], max(up[i], down2[i]) + tot);
			}
			dfs2(v);
		}
	}
	return;
}

五、例题

旅游规划

题目描述

W 市的交通规划出现了重大问题，市政府下定决心在全市各大交通路口安排疏导员来疏导密集的车流。但由于人员不足，W 市市长决定只在最需要安排人员的路口安排人员。

具体来说，W 市的交通网络十分简单，由 n 个交叉路口和 n - 1 条街道构成，交叉路口路口编号依次为 $0,1,\dots ,n-1$ 。任意一条街道连接两个交叉路口，且任意两个交叉路口间都存在一条路径互相连接。

经过长期调查，结果显示，如果一个交叉路口位于 W 市交通网最长路径上，那么这个路口必定拥挤不堪。所谓最长路径，定义为某条路径 $p=(v_1,v_2,v_3,\cdots ,v_k)$ ，路径经过的路口各不相同，且城市中不存在长度大于 k 的路径，因此最长路径可能不唯一。因此 Ｗ 市市长想知道哪些路口位于城市交通网的最长路径上。

输入格式

第一行一个整数 n ；

之后 n - 1 行每行两个整数 u, v ，表示 u 和 v 的路口间存在着一条街道。

输出格式

输出包括若干行，每行包括一个整数——某个位于最长路径上的路口编号。为了确保解唯一，请将所有最长路径上的路口编号按编号顺序由小到大依次输出。

分析

此题意为求直径上的点；

代码

#include <cstdio>
#include <vector>
#include <algorithm>
#define MAXN 200005
using namespace std;
int n, down1[MAXN], down2[MAXN], up[MAXN], dis = -1;
bool flag[MAXN];
vector < int > g[MAXN];
void dfs1(int i) {
	flag[i] = true;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t];
		if (!flag[v]) {	
			dfs1(v);
			int tot = down1[v] + 1;
			if (tot > down1[i]) {
				down2[i] = down1[i];
				down1[i] = tot;
			} else {
				down2[i] = max(down2[i], tot);
			}
		}
	}
	flag[i] = false;
	dis = max(dis, down1[i] + down2[i]);
	return;
}

void dfs2(int i) {
	flag[i] = true;
	int tot = 0;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t];
		if (!flag[v]) {
			if (down1[i] == down1[v] + 1) {
				tot++;
			}
		}
	}
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t];
		if (!flag[v]) {
			if (down1[i] != down1[v] + 1 || (tot > 1 && down1[i] == down1[v] + 1)) {
				up[v] = max(up[v], max(up[i], down1[i]) + 1);
			} else {
				up[v] = max(up[v], max(up[i], down2[i]) + 1);
			}
			dfs2(v);
		}
	}
	return;
}
int main() {
	scanf("%d", &n);
	for (int i = 1; i < n; i++) {
		int x, y;
		scanf("%d %d", &x, &y);
		g[x].push_back(y);
		g[y].push_back(x);
	}
	dfs1(0);
	dfs2(0);
	for (int i = 0; i < n; i++) {
		if (down1[i] + max(down2[i], up[i]) == dis) {
			printf("%d\n", i);
		}
	}
	return 0;
}