树的直径的两种求法

树的直径：给定一颗树，树的每条边都有一个权值, 树中任意两点都有一条唯一路径，路径长度为连接两点的路径上的边权之和，路径长度最长的一条为树的直径，往往说的直径既可以指路径长度，也可以指具体路径(即经过哪些点)。直径不唯一。
求直径一般有两种求法：两次dfs/bfs，树形dp，时间复杂度都为O(n)

两次dfs/bfs: 好理解，具体路径记录方便，但处理不了负权边

思路：由于树上任意两点都有唯一的路径，所以直径可用其两个端点p, q表示. 从直径一端p出发进行dfs/bfs，dist[i]表示p到i的路径长度，那么dist最大的点就是q，此时dist[q]就是直径长度，所以已知p就可以求出q。如何求p？
从任意点出发，找到距离出发点最远的节点，该节点就是p。

算法流程：先用从任意点出发进行一遍dfs/bfs找到p, 再从p出发进行一遍dfs/bfs找到q。

#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> e[maxn];
int n, dist[maxn], pre[maxn]; // pre:前驱(父)节点
void dfs(int u, int fa, int &p) {
    pre[u] = fa;
    if (dist[u] > dist[p])
        p = u;
    for (int v : e[u]) {
        if (v == fa)
            continue;
        dist[v] = dist[u] + 1;
        dfs(v, u, p);
    }
}
// 输出具体路径, pre[p] == 0
void print(int x) {
    if (x == 0)
        return;
    print(pre[x]);
    cout << x << ' ';
}
int main() {
    cin >> n;
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }
    int p, q;
    dist[1] = 0;
    dfs(1, 0, p = 1);
    dist[p] = 0;
    dfs(p, 0, q = p);
    print(q);
    cout << '\n' << dist[q] << '\n';
    return 0;
}

树形dp：可以处理边权为负的情况，但不易记录路径

思路：枚举树上的所有链, 链长最大值就是直径。
如何求链长？

         设u的为链上一点
              u
            / | \ \
           v1 v2 v3 ...
        设于u相连的节点有v1, v2, v3, ...(vi可能存在与vi相连的其他节点(省略))
        那么以u作为折点的链有
        ...->v1->u->v2
        ...->v1->u->v3
        ...->v2->u->v3
        ...
        dist[i]表示以i为根节点的子树中, 从i出发能够到达的最远节点的距离
        经过u的最大链长 = max{dist[vi] + w[u][vi] + dist[vj]}
        接下来，需要求dist[i], 用树形dp
        不难写出如下伪代码(假设边权都为1)
        int maxd;
        void dp(int u, int fa) {
            for (u的子节点v) {
                if (v == fa) continue;
                dp(v, u);
                dist[u] = max(dist[u], dist[v] + 1);
            }
        }
        
        统计链长最大值maxd(直径)
        发现在遍历u的子节点vi过程中， 对于不同的两个子节点v2, v3(v3先于v2被遍历)
        当枚举到v3时， dist[v1], dist[v2]已经被求解出来，并进行更新：dist[u] = max(dist[u], dist[vi] + 1)(i<3)
        此时dist[u]保存的就是dist[vi] + w[u][vi](i < 3)的最大值
        在求出dist[v3]后, 将经过u, v3的链考虑进答案maxd = max(maxd, dist[u] + dist[v3] + w[u][v3])
        所以只需在每次更新dist[u]之前更新maxd即可
        int maxd;
         void dp(int u, int fa) {
            for (u的子节点v) {
                if (v == fa) continue;
                dp(v, u);
                maxd = max(maxd, dist[u] + 1 + dist[v]);
                dist[u] = max(dist[u], dist[v] + 1);
            }
        }

完整代码

#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> e[maxn];
int n, dist[maxn];
int maxd;
void dp(int u, int fa) {
    for (int v : e[u]) {
        if (v == fa)
            continue;
        dp(v, u);
        maxd = max(maxd, dist[u] + dist[v] + 1);
        dist[u] = max(dist[u], dist[v] + 1);
    }
}
int main() {
    cin >> n;
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }
    memset(dist, 0, sizeof dist);
    dp(1, 0);
    cout << maxd << '\n';
    return 0;
}