【算法专题】树的直径

树的直径

定义：树中距离最远的两个点之间的距离被称为树的直径。

1 做法

做法一

• （1）任取一点作为起点x，找到距离该点最远的一个点y；

• （2）再找到距离y最远的一点z，那么y、z之间的路径就是一条直径。

---

证明：核心是证明y一定是直径的一个端点。使用反证法证明，存在如下两种情况。

假设y不是直径的一个端点。假设uv是直径。

• 对于情况一：因为y是距离x最远的一个点，因此有ya + ax >= ua + ax，所以ya >= ua，所以yv >= uv，因此yv才是直径，矛盾。

• 对于情况二：因为y是距离x最远的一个点，因此有ya + ax >= ub + ba + ax，所以ya >= ub + ba，所以ya + ab >= ub，因此ya+ab+bv才是直径，矛盾。

做法二

• 任意选择一个点作为根节点，将整棵树“拎”起来，然后将路径分为若干类，每个点代表一类，每个点代表的集合是经过该点且该点是此路径最高点的所有路径的集合，属性是路径权值和最大值。如下图：

• 在递归求解的过程中记录每个点所有子树的路径和最大值和次大值（可能相等）即可，最长路径就是两者之和。

2 例题

AcWing 1207. 大臣的旅费

问题描述

• 问题链接：AcWing 1207. 大臣的旅费

分析

• 本题中假设最终形式的路径长度为s千米，则第1千米需要花费10+1，第2千米需要花费10+2…，因此最终的费用是10s + s(s+1)/2。

• 可见费用随着s的增加而增加，因此最大费用对应最大路程，即求解树的直径。

• 本题使用做法一求解。

代码

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int N = 100010;

struct Edge {
    int id, w;
};

int n;  // 图中的点数
vector<Edge> g[N];  // 存储图
int dist[N];  // 从某点出发到其他点的距离

void dfs(int u, int father, int distance) {
    dist[u] = distance;
    
    for (auto node : g[u]) {
        if (node.id == father) continue;
        dfs(node.id, u, distance + node.w);
    }
}

int main() {
    
    scanf("%d", &n);
    for (int i = 0; i < n - 1; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }
    
    dfs(1, -1, 0);
    
    int u = 1;
    for (int i = 1; i <= n; i++)
        if (dist[i] > dist[u])
            u = i;
    
    dfs(u, -1, 0);
    
    for (int i = 1; i <= n; i++)
        if (dist[i] > dist[u])
            u = i;
    
    int s = dist[u];
    
    printf("%lld\n", 10 * s + s * (s + 1ll) / 2);
    
    return 0;
}

AcWing 1072. 树的最长路径

问题描述

• 问题链接：AcWing 1072. 树的最长路径

分析

• 本题是个裸题，这里使用做法二求解。

代码

#include <iostream>
#include <cstring>

using namespace std;

const int N = 10010, M = N * 2;

int n;
int h[N], e[M], w[M], ne[M], idx;
int ans;

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

int dfs(int u, int father) {  // father是为了防止向回遍历
    
    int d1 = 0, d2 = 0;  // d1: 表示从当前点往下走的最大长度
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == father) continue;
        int d = dfs(j, u) + w[i];
        
        if (d >= d1) d2 = d1, d1 = d;
        else if (d > d2) d2 = d;
    }
    
    ans = max(ans, d1 + d2);
    
    return d1;
}

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 << ans << endl;
    
    return 0;
}