## [$AcWing$ $1073$. 树的中心](https://www.acwing.com/problem/content/description/1075/)


### 一、题目描述
给定一棵树，树中包含 $n$ 个结点（编号$1$~$n$）和 $n−1$ 条无向边，每条边都有一个权值。

请你在树中找到一个点，**使得该点到树中其他结点的最远距离最近**。

**输入格式**
第一行包含整数 $n$。

接下来 $n−1$ 行，每行包含三个整数 $a_i,b_i,c_i$，表示点 $a_i$ 和 $b_i$
 之间存在一条权值为 $c_i$ 的边。

**输出格式**
输出一个整数，表示所求点到树中其他结点的最远距离。

**数据范围**
$1≤n≤10000,$
$1≤a_i,b_i≤n,$
$1≤c_i≤10^5$

**输入样例：**
```cpp {.line-numbers}
5 
2 1 1 
3 2 1 
4 3 1 
5 1 1
```
**输出样例：**
```cpp {.line-numbers}
2
```

### 二、暴力大法
国际惯例上来就写暴力:
对每一个点都求得它的 **最远距离**, 答案=$min($所有点的最远距离$)$
通过 $7/11$个数据然后$TLE$

```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;

const int INF = 0x3f3f3f3f;
const int N = 10010, M = 20010;
int n;
int ans;
int res = INF;
int st[N];

// 邻接表
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c = 0) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

void dfs(int u, int sum) {
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (st[j]) continue;
        dfs(j, sum + w[i]);
    }
    if (sum > ans) ans = sum;
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 1; i < n; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    for (int i = 1; i <= n; i++) {
        ans = 0;
        memset(st, 0, sizeof st);
        dfs(i, 0);
        res = min(res, ans);
    }
    printf("%d\n", res);
    return 0;
}
```

### 三、换根$DP$【模板，背诵】
<font color='red' size=4><b>注：与前一题类似，也是怕两重循环导致时间复杂度上升到$O(N^2)$,不能遍历每两个节点，只能是遍历每个节点，尝试构建此节点的上下游信息，再用这些信息找出树的中心。</b></font>

换根$DP$就是根据父亲的属性来更新他更新儿子的属性，相当于只需要考虑把顶点移到儿子对结果造成的影响。


同样，先来想一下如何暴力求解该问题：先 **枚举** 目标节点，然后求解该节点到其他节点的 **最远距离**

时间复杂度为 $O(n^2)$，对于本题的 **数据规模**，十分极限，经测试只能过 $6/10$

#### 考虑如何优化求解该问题的方法
思考一下：在确定树的 **拓扑结构** 后单独求一个节点的 **最远距离** 时，会在该树上去比较哪些 **路径** 呢？

1. 从当前节点往下，直到子树中某个节点的最长路径
2. 从当前节点往上走到其父节点，再从其父节点出发且不回到该节点的最长路径

此处就要引入 **换根$DP$** 的思想了

换根$DP$ 一般分为三个步骤：

1. 指定任意一个根节点
2. 一次$dfs$遍历，统计出当前子树内的节点对当前节点的贡献
3. 一次$dfs$遍历，统计出当前节点的父节点对当前节点的贡献，然后合并统计答案

那么我们就要先 $dfs$ 一遍，预处理出当前子树对于根的 **最大贡献(距离)** 和 **次大贡献（距离）**

处理 **次大贡献（距离）** 的原因是：

如果 **当前节点** 是其 **父节点子树** 的 **最大路径** 上的点，则 **父节点子树** 的 **最大贡献** 不能算作对该节点的贡献

因为我们的路径是 **简单路径**，不能 **走回头路**

然后我们再 $dfs$ 一遍，求解出每个节点的父节点对他的贡献（即每个节点往上能到的最远路径)

两者比较，取一个 $max$ 即可

我们用 $d1[u],d2[u],up[u],p1[u]$分别存一下需要的信息，这些数据存的是：
$d1[u]$：存下$u$节点向下走的最长路径的长度
$d2[u]$：存下$u$节点向下走的第二长的路径的长度
$p1[u]$：存下$u$节点向下走的最长路径是从哪一个节点下去的
$up[u]$：存下$u$节点向上走的最长路径的长度

#### 图解
<center><img src='https://cdn.acwing.com/media/article/image/2021/01/15/42785_5954f63056-QQ%E6%B5%8F%E8%A7%88%E5%99%A8%E6%88%AA%E5%9B%BE20210115135517.png'></center>

<center><img src='https://cdn.acwing.com/media/article/image/2021/01/15/42785_6a42693256-QQ%E6%B5%8F%E8%A7%88%E5%99%A8%E6%88%AA%E5%9B%BE20210115135059.png'></center>

<center><img src='https://cdn.acwing.com/media/article/image/2022/09/01/64630_72b7979429-42785_6dab43be56-QQ浏览器截图20210115135251.png'></center>


#### 实现代码
```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;

const int N = 10010;
const int M = N << 1;
const int INF = 0x3f3f3f3f;

int n;

int d1[N]; // d1[u]：存下u节点向下走的最长路径的长度
int d2[N]; // d2[u]：存下u节点向下走的次长路径的长度
int p1[N]; // p1[u]：存下u节点向下走的最长路径是从哪一个节点下去的
int up[N]; // up[u]：存下u节点向上走的最长路径的长度
int st[N];
// 邻接表
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c = 0) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

// 功能:以u为根，向叶子进行递归，利用子节点返回的最长信息，更新自己的最长和次长,并记录最长是从哪个节点来的
void dfs1(int u) {
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (st[j]) continue;

        // 递归完才能有数据
        dfs1(j);

        if (d1[j] + w[i] >= d1[u]) {     // 更新最长
            d2[u] = d1[u];               // ① 更新次长,必须在第一位，因为下面d1[u]会被改写
            d1[u] = d1[j] + w[i];        // ② 更新最长
            p1[u] = j;                   // ③ 记录最长来源
        } else if (d1[j] + w[i] > d2[u]) // 更新次长
            d2[u] = d1[j] + w[i];
    }
}

// 功能：完成向上的信息填充
void dfs2(int u) {
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (st[j]) continue;

        // 三者取其一
        up[j] = w[i] + up[u];
        if (p1[u] == j)
            up[j] = max(up[j], w[i] + d2[u]);
        else
            up[j] = max(up[j], w[i] + d1[u]);
        // 准备好了信息，再进入递归
        dfs2(j);
    }
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 1; i < n; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    memset(st, 0, sizeof st);
    dfs1(1); // 选择任意一个节点进行dfs,用儿子更新父亲的统计信息
    memset(st, 0, sizeof st);
    dfs2(1); // 向上

    int res = INF;
    for (int i = 1; i <= n; i++) res = min(res, max(d1[i], up[i]));
    printf("%d\n", res);

    return 0;
}
```

**$Q1$:为什么$dfs1$中要 先安排工作，后统计信息？**
$A$:因为后面$u$统计的信息，是根据多个子节点$j$的信息汇集统计来的，儿子的信息没出来，爹的信息就统计不出来，儿子需要先计算。

**$Q2$:为什么$dfs2$中要 先统计信息，后安排工作？**
$A$:这取决于继续递归前，是否需要前序提供信息，比如此处在处理子节点$j$时，需要更新$up[j]$,但$up[j]$是依赖于$up[u],d1[u],d2[u]$的，$d1[u],d2[u]$在$dfs1$中已完成填充，没有问题，但$up[u]$如果还没正确填充内容，后续就无法完成计算了,所以必须在进入递归前完成统计信息计算，为后面的子递归提供数据信息。

**$Q3$:为什么非得跑一遍$dfs1$,再跑一遍$dfs2$,只跑一遍不行吗？**
$A$:第一遍$dfs$，解决的是我的孩子到我有多远的问题，没有记录，也没法记录 我爹，我爷爷离我有多远的问题，那需要再跑一遍反向的才能知道。
<center><img src='https://cdn.acwing.com/media/article/image/2020/05/10/15856_0c72c86892-%E6%A0%91%E7%9A%84%E4%B8%AD%E5%BF%83%E8%BE%85%E5%9B%BE1.jpg.png'></center>

**$Q4$:据说边权要是负的，需要修改代码，该怎么改？**
$A:$如下,把下面两句注释的话放开即可

```cpp {.line-numbers}
void dfs1(int u) {    
    //  d1[u] = d2[u] = -INF;  //这题所有边权都是正的，可以不用初始化为负无穷
    st[u]=1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (st[j]) continue;

        dfs1(j);

        if (d1[j] + w[i] >= d1[u]) {     
            d2[u] = d1[u];               
            d1[u] = d1[j] + w[i];        
            p1[u] = j;                   
        } else if (d1[j] + w[i] > d2[u]) 
            d2[u] = d1[j] + w[i];
    }
    // if (d1[u] == -INF) d1[u] = d2[u] = 0; //特判叶子结点
}
```       
### 四、下一步需研读
https://blog.csdn.net/weixin_44232130/article/details/116567482
https://www.cnblogs.com/hxxO-o/p/16558801.html