树的直径

无权树的直径

对于一棵含有$n$个节点$n-1$条边的树，其直径定义为树上的最长链(最长路径)。而且容易得到，再连接首尾两点，会形成一个最大环。

求无权树的直径的两种思路：DFS和树形DP。

DFS

思路：从任意一点$u$先做一次$dfs$找到最远的一点$tail$，在从$tail$做一次$dfs$找到最远的距离，而第二次的距离就是树的直径。

证明：假设$s->t$这条路径为树的直径。现有结论，从任意一点$u$出发搜到的最远的点一定是$s$、$t$中的一点，然后再从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍深搜就可以找出树的最长路。

以树的边为基础DFS，假设当前的边为 $u->v$ ，初始时边为$0$到根节点，其中节点$0$是虚构的节点。每次将最大深度$maxd$和当前深度比较，如果小则更新$maxd$并记录$v$。

const int maxn = 1e4 + 10;
vector<int> G[maxn];
int maxd, head, tail;

int dfs(int u, int v, int cur) {
    if (maxd < cur) {
        maxd = cur;
        tail = v;
    }
    for (int i = 0; i < G[v].size(); i++) {
        if (u != G[v][i]) {
            dfs(v, G[v][i], cur + 1);
        }
    }
}

int main() {
	maxd = 0;
	dfs(0, 1, 0);
	maxd = 0;      //清空最大深度
    head = tail;    //第一次求出的起点并保存
	dfs(0, tail, 0);  //tail变成了最长路的终点
    return 0;
}

树形DP

对于任意节点$i$，经过$i$的最长路就是连接$i$的两棵不同子树$u$和$v$的最深叶子的路径。

状态转移：设$d(i)$表示以根为节点$i$的子树中根到叶子的最大距离，$j$为$i$的子节点，那么状态转移方程为： d ( i ) = m a x { d ( j ) } + 1 d(i)=max\{d(j)\}+1 d(i)=max{d(j)}+1。

求出所有的$d(root)$后，设$d(son[root])$值前两大的子节点分别为$u,v$，那么树的直径就是$d(u)+d(v)+2$。

vector<int> G[maxn];
int d[maxn];
int ans;

void dfs(int u, int fa) {
    d[u] = 0;
    for (auto v: G[u]) {
        if (v != fa) {
            dfs(v, u);
            d[u] = max(d[u], d[v] + 1);
        }
    }
    if (u == 1) {
        int fmax = 0, smax = 0;
        for (auto i: G[u]) {
            if (i != fa) {
                if (d[i] > fmax) {
                    smax = fmax;
                    fmax = d[i];
                } else if (d[i] > smax && d[i] <= fmax)
                    smax = d[i];
            }
        }
        ans = fmax + smax + 2;
    }
}

带权树的直径

权值在点上

例题链接

设$d(u)$表示以节点$u$为根，延伸到叶子节点的最长路径的长度，路径可以是节点本身

初始化$d(u)=w[u]$

状态转移：$d(u)=max(d(u),d(v)+w[u])$

答案更新：如果叶子节点就是起点，该节点就是终点，那么只需在$dfs$的最后更新$ans=max(ans,d(u))$；但是也有可能是$u$节点为中间节点，那么最长的路径应该考虑该根节点下的两个叶子连成的路径$ans=max(ans,d(u)+d(v))$

vector<int> G[maxn];
ll d[maxn], w[maxn];
ll ans = -inf;

void dfs(int u, int fa) {
    d[u] = w[u];
    for (auto v: G[u])
        if (v != fa) {
            dfs(v, u);
            ans = max(ans, d[u] + d[v]);  //注意先更新ans
            d[u] = max(d[u], d[v] + w[u]);
        }
    ans = max(ans, d[u]);
}

权值在边上

例题链接

不难发现权值在边上相当于无权树的边权不为$1$的情况。两次$dfs$可以解决非负权树但是无法解决负权树，而树形DP都可以解决

建树采用前向星存边的方式，大体思路和权值在点上一致，只是这里从叶子节点转移而来相当于权值为0

struct node {
    int next, to, w;
} edge[maxn];

int head[maxn], tot;
ll d[maxn], ans = -inf;

void add_edge(int u, int v, int w) {
    tot++;
    edge[tot] = {head[u], v, w};
    head[u] = tot;

    tot++;
    edge[tot] = {head[v], u, w};
    head[v] = tot;
}

void dfs(int u, int fa) {
    d[u] = 0;
    for (int i = head[u]; i; i = edge[i].next){
        int v = edge[i].to, w = edge[i].w;
        if (v == fa) continue;
        dfs(v, u);
        ans = max(ans, d[u] + d[v] + w);
        d[u] = max(d[u], d[v] + w);
    }
}