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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Edge
    {
        internal int to, dist;

        public Edge(int to, int dist)
        {
            this.to = to;
            this.dist = dist;
        }
    }

    class Program
    {
        static Nullable<int>[] dp;

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            Dictionary<int, List<Edge>> nodeList = new Dictionary<int, List<Edge>>();
            for (int i = 0; i < n; i++) nodeList.Add(i, new List<Edge>());


            for (int i = 0; i < n - 1; i++)
            {
                string[] input = Console.ReadLine().Split(' ');
                int s = int.Parse(input[0]);
                int t = int.Parse(input[1]);
                int w = int.Parse(input[2]);

                nodeList[s].Add(new Edge(t, w));
                nodeList[t].Add(new Edge(s, w));
            }

            BFS(nodeList, 0);

            int? maxDist = 0;
            int target = 0;

            for (int i = 0; i < n; i++)
            {
                if (dp[i] == null) continue;

                if (maxDist < dp[i])
                {
                    maxDist = dp[i];
                    target = i;
                }
            }

            BFS(nodeList, target);

            maxDist = 0;

            for (int i = 0; i < n; i++)
            {
                if (dp[i] == null) continue;

                if (maxDist < dp[i]) maxDist = dp[i];
            }

            Console.WriteLine(maxDist);
        }

        static void BFS(Dictionary<int, List<Edge>> NL, int s)
        {
            int len = NL.Count;
            dp = new Nullable<int>[len];

            Queue<int> que = new Queue<int>();
            que.Enqueue(s);

            dp[s] = 0;

            while (que.Count > 0)
            {
                int u = que.Dequeue();
                int outDegree = NL[u].Count;

                for (int i = 0; i < outDegree; i++)
                {
                    Edge e = NL[u][i];

                    if (dp[e.to] == null)
                    {
                        dp[e.to] = dp[u] + e.dist;
                        que.Enqueue(e.to);
                    }
                }
            }
        }
    }
}