Problem:
Score : 1100 points

Problem Statement

There is a tree with N vertices, numbered 1 through N.
The i-th edge in this tree connects Vertices A_i and B_i and has a length of C_i.

Joisino created a complete graph with N vertices.
The length of the edge connecting Vertices u and v in this graph, is equal to the shortest distance between Vertices u and v in the tree above.

Joisino would like to know the length of the longest Hamiltonian path (see Notes) in this complete graph.
Find the length of that path.

Notes

A Hamiltonian path in a graph is a path in the graph that visits each vertex exactly once.

Constraints

2 \leq N \leq 10^5

1 \leq A_i < B_i \leq N

The given graph is a tree.

1 \leq C_i \leq 10^8

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{N-1} B_{N-1} C_{N-1}

Output

Print the length of the longest Hamiltonian path in the complete graph created by Joisino.

Sample Input 1

5
1 2 5
3 4 7
2 3 3
2 5 2

Sample Output 1

38

The length of the Hamiltonian path 5 → 3 → 1 → 4 → 2 is 5+8+15+10=38. Since there is no Hamiltonian path with length 39 or greater in the graph, the answer is 38.

Sample Input 2

8
2 8 8
1 5 1
4 8 2
2 5 4
3 8 6
6 8 9
2 7 12

Sample Output 2

132

Solution in Rust (1.42.0) (judge verdict: Accepted)

use proconio::*;
use proconio::marker::*;

#[fastout]
fn run() {
    input! {
        n: usize,
        e: [(Usize1, Usize1, u64); n - 1],
    }
    let mut g = vec![vec![]; n];
    for (a, b, c) in e {
        g[a].push((b, c));
        g[b].push((a, c));
    }
    let mut q = vec![0];
    let mut parent = vec![0; n];
    for i in 0..n {
        let v = q[i];
        let p = parent[v];
        for &(u, _) in g[v].iter().filter(|e| e.0 != p) {
            parent[u] = v;
            q.push(u);
        }
    }
    let mut size = vec![1; n];
    let mut sum = 0;
    for &v in q.iter().rev() {
        let p = parent[v];
        for &(u, w) in g[v].iter().filter(|e| e.0 != p) {
            sum += 2 * std::cmp::min(n as u64 - size[u], size[u]) * w;
            size[v] += size[u];
        }
    }
    let mut pos = 0;
    loop {
        let mut next = (0, 0, 0);
        for &(u, w) in g[pos].iter().filter(|e| e.0 != parent[pos]) {
            next = std::cmp::max(next, (size[u], u, w));
        }
        if 2 * next.0 > n as u64 {
            pos = next.1
        } else if 2 * next.0 == n as u64 {
            sum -= next.2;
            break;
        } else {
            sum -= g[pos].iter().map(|e| e.1).min().unwrap();
            break;
        }
    }
    println!("{}", sum);
}

fn main() {
    run();
}