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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
class Solve{
    List<int>[] G;
    List<long>[] C;
    int[] child;
    long[] cost;
    public Solve(){}
    StringBuilder sb;
    public static int Main(){
        new Solve().Run();
        return 0;
    }
    void Run(){
        sb = new StringBuilder();
        Calc();
        Console.Write(sb.ToString());
    }
    void Calc(){
        int N = int.Parse(Console.ReadLine());
        G = new List<int>[N];
        C = new List<long>[N];
        child = new int[N];
        for(int i=0;i<N;i++){
            G[i] = new List<int>();
            C[i] = new List<long>();
        }
        for(int i=0;i<N-1;i++){
            string[] str = Console.ReadLine().Split(' ');
            G[int.Parse(str[0])-1].Add(int.Parse(str[1])-1);
            C[int.Parse(str[0])-1].Add(int.Parse(str[2]));
            G[int.Parse(str[1])-1].Add(int.Parse(str[0])-1);
            C[int.Parse(str[1])-1].Add(int.Parse(str[2]));
        }
        GetChild(0,-1);
        int Center = Central(0,N/2,-1);
        GetChild(Center,-1);
        long count = 0;
        cost = new long[N];
        Cost(Center,0,-1);
        for(int i=0;i<N;i++){
            count += 2*cost[i];
        }
        int Center2 = -1;
        if(N % 2 == 0){
            for(int i=0;i<N;i++){
                if(child[i] == N/2){
                    Center2 = i;
                }
            }
        }
        long min = 100000000;
        if(Center2 == -1){
            for(int i=0;i<G[Center].Count;i++){
                min = Math.Min(min,C[Center][i]);
            }
        }
        else{
            min = cost[Center2];
        }
        count -= min;
        sb.Append(count+"\n");
    }
    void Cost(int v,long c,int f){
        for(int i=0;i<G[v].Count;i++){
            int t = G[v][i];
            if(t != f){
                Cost(t,c+C[v][i],v);
            }
        }
        cost[v] = c;
    }
    int Central(int v,int c,int f){
        for(int i=0;i<G[v].Count;i++){
            int t = G[v][i];
            if(t != f && child[t] > c){
                return Central(t,c,v);
            }
        }
        return v;
    }
    int GetChild(int v,int f){
        int count = 1;
        for(int i=0;i<G[v].Count;i++){
            int t = G[v][i];
            if(t != f){
                count += GetChild(t,v);
            }
        }
        child[v] = count;
        return count;
    }
}