【ACWing】1073. The center of the tree

Subject address:

https://www.acwing.com/problem/content/1075/

Given a tree, the tree contains $n$ nodes (number$1\sim n$ ) and$n-1$ undirected edge, and each edge has a weight. Please find a point in the tree so that the farthest distance from this point to other nodes in the tree is the closest.

Input format: the
first line contains the integer $n$ . Next$n-1$ line, each line contains three integers$a_i,b_i,c_i$, Which means point $a_i$Japanese $b_i$There is a weight between $c_i$的边。 The side.

Output format:
output an integer, representing the farthest distance from the requested point to other nodes in the tree.

Data range:
$1\le n\le 10000$
$1\le a_i,b_i\le n$
$1\le c_i\le 10^5$

The idea is DFS, to enumerate each vertex, it may be set to enumerate $x$ , find the length of the longest path starting from the vertex, and then find the node with the shortest longest path. We take any vertex as the root of the tree, and then treat the entire tree as a rooted tree, so that all paths can be classified according to the highest point it passes, and then the vertices are enumerated$x$ , find out as$x$ is the longest path length of the highest point. Let$f\left(x\right)$ is from$The$ longest path among all paths that$x$ goes down, let$g\left(x\right)$ is from$x$ is the longest path of all the paths going up. LetxxThe children of$x$ have$c_1,c_2,...,c_k$， 那么$f(x)=|(x,c_i)|+f(c_i)$ , this can be solved directly by DFS. But for$g\left(x\right)$ is a little more complicated, let$p_x$Is xxthe father of$x$ , then$g\left(x\right)$ must go up one step first, but how to go next has to be classified. First, it is possible to continue to go upward, then it is$|(x,p_x)|+g(p_x)$ ; It is also possible to go down, but you can't go back toxx ifyou go down$x$ , we can think about it this way, if$f(p_x)$ Is not passed$x$ , then the way down can be taken to$f\left(p_x\right)$ ; otherwise, find and remove the passxxAfter the path of$x$ , the longest path in the remaining paths. So we are counting$When\; f$ , also record from$The$ longest and the second longest path in the downward path of$x$ have passed through which son (note that the longest and second longest paths here are classified according to which son passed, that is,$f(c_i)$ Take the largest and second largest$c_i$). code show as below:

#include <iostream>
#include <cstring>
using namespace std;

// 边数是顶点数乘以2
const int N = 10010, M = 2 * N;
int n;
int h[N], e[M], ne[M], w[M], idx;
// d1[x]是从x向下走的第一长的路径长度，d2[x]是从x向下走的第二长的路径长度；
// p1[x]是从x向下走的第一长的路径长度经过的孩子节点编号，p2[x]是从x向下走的
// 第二长的路径长度经过的孩子节点编号；up[x]是从x向上走的最长路径长度；
// 以上所说路径都是不自交的路径
int d1[N], d2[N], p1[N], p2[N], up[N];

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

// 求从u出发向下走的最长和次长路径长度，及它们经过的孩子编号
int dfs_d(int u, int parent) {
    
    
	// 枚举u的孩子
    for (int i = h[u]; i != -1; i = ne[i]) {
    
    
        int j = e[i];
        // 不走回头路
        if (j == parent) continue;
		
		// 递归求解从j出发向下的最长路径长度
        int d = dfs_d(j, u) + w[i];
        if (d >= d1[u]) {
    
    
            d2[u] = d1[u], d1[u] = d;
            p2[u] = p1[u], p1[u] = j;
        } else if (d > d2[u]) {
    
    
            d2[u] = d;
            p2[u] = j;
        }
    }

    return d1[u];
}

// 求从u出发向上走的最长路径长度
void dfs_u(int u, int parent) {
    
    
    for (int i = h[u]; i != -1; i = ne[i]) {
    
    
        int j = e[i];
        if (j == parent) continue;
		
		// 如果从u出发向下走的最长路就是通过j的，那么就应该累加从u向上走的
		// 最长路长度和从u向下走的第二长路长度之更大者；否则累加从u向上走的
		// 最长路长度和从u向下走的最长路长度之更大者；
        if (p1[u] == j) up[j] = max(up[u], d2[u]) + w[i];
        else up[j] = max(up[u], d1[u]) + w[i];

        dfs_u(j, u);
    }
}

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_d(1, -1);
    dfs_u(1, -1);

    int res = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++) res = min(res, max(d1[i], up[i]));

    cout << res << endl;

    return 0;
}

Time and space complexity $O\left(n\right)$。