Problem:
Diameter of a Tree

Given a tree T with non-negative weight, find the diameter of the tree.

The diameter of a tree is the maximum distance between two nodes in a tree.

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

Print the diameter of the tree in a line.

Constraints

1 ≤ n ≤ 100,000

0 ≤ wi ≤ 1,000

Sample Input 1

4
0 1 2
1 2 1
1 3 3

Sample Output 1

5

Sample Input 2

4
0 1 1
1 2 2
2 3 4

Sample Output 2

7

Solution in Rust (judge verdict: Accepted)

fn far_reaching(graph: &[Vec<(usize, i64)>], start: usize) -> (usize, 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.into_iter().enumerate().fold(
        (0, -1),
        |(node, dist), (n, d)| if dist < d { (n, d) } else { (node, dist) },
    )
}

fn solve(graph: Vec<Vec<(usize, i64)>>) {
    let start = 0;
    let (node, _) = far_reaching(&graph, start);
    let (_, dist) = far_reaching(&graph, node);
    println!("{}", dist);
}

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);
}