Problem:
Height of a Tree

Given a tree T with non-negative weight, find the height of each node of the tree. For each node, the height is the distance to the most distant leaf from the node.

Input

n
s1 t1 w1
s2 t2 w2
:
sn-1 tn-1 wn-1

The first line consists of an integer n which represents the number of nodes in the tree. Every node has a unique ID from 0 to n-1 respectively.

In the following n-1 lines, edges of the tree are given.

si and ti represent end-points of the i-th edge (undirected) and wi represents the weight (distance) of the i-th edge.

Output

The output consists of n lines. Print the height of each node 0, 1, 2, ..., n-1 in order.

Constraints

1 ≤ n ≤ 10,000

0 ≤ wi ≤ 1,000

Sample Input 1

4
0 1 2
1 2 1
1 3 3

Sample Output 1

5
3
4
5

Solution in Rust (judge verdict: Accepted)

fn far_reaching(graph: &[Vec<(usize, i64)>], start: usize) -> Vec<i64> {
    let size = graph.len();
    let mut is_reached: Vec<bool> = vec![false; size];
    let mut dist = vec![-1; size];
    let mut stack = vec![start];
    dist[start] = 0;
    'dfs: while !stack.is_empty() {
        let from = *stack.last().unwrap();
        if !is_reached[from] {
            is_reached[from] = true;
        }
        for &(to, weight) in &graph[from] {
            if !is_reached[to] {
                dist[to] = dist[from] + weight;
                stack.push(to);
                continue 'dfs;
            }
            // For each edgse.
        }
        // Postorder
        let _from = stack.pop().unwrap();
    }
    dist
}

fn solve(graph: Vec<Vec<(usize, i64)>>) {
    let (x, _) = far_reaching(&graph, 0)
        .into_iter()
        .enumerate()
        .max_by_key(|e| e.1)
        .unwrap();
    let x_dfs = far_reaching(&graph, x);
    let (y, _) = x_dfs
        .clone()
        .into_iter()
        .enumerate()
        .max_by_key(|e| e.1)
        .unwrap();
    let y_dfs = far_reaching(&graph, y);
    for i in 0..graph.len() {
        let max = std::cmp::max(x_dfs[i], y_dfs[i]);
        println!("{}", max);
    }
}

use std::io::{BufRead, BufReader};
fn main() {
    let mut read = BufReader::new(std::io::stdin())
        .lines()
        .filter_map(|e| e.ok());
    let v = {
        let line = read.next().unwrap();
        let line: Vec<&str> = line.split(' ').collect();
        let v: usize = line[0].parse().unwrap();
        v
    };
    let graph = {
        let mut graph: Vec<Vec<_>> = vec![vec![]; v]; // Adj list
        for edge in read {
            let mut edge = edge.split(' ');
            let start: usize = edge.next().unwrap().parse().unwrap();
            let end: usize = edge.next().unwrap().parse().unwrap();
            let weight: i64 = edge.next().unwrap().parse().unwrap();
            graph[start].push((end, weight));
            graph[end].push((start, weight));
        }
        graph
    };
    solve(graph);
}