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 Ruby (judge verdict: Time Limit Exceeded)

class Node
  attr_accessor :child, :visited
  def initialize
    @child = {}
  end
end

## recursive version
# def f(i, j, g)
#   unless $known[i][j]
#     max = 0
#     g[j].child.each{|k, w|
#       next if i == k
#       ret = f(j, k, g)
#       max = ret if max < ret
#     }
#     $known[i][j] = g[i].child[j] + max
#   end
#   return $known[i][j]
# end

def f(i, j, g)
  stack = [i, j]
  max = {}
  done = {}
  done[i] = true
  while stack.size > 1
    s = stack[-2]
    t = stack[-1]
    flag = true
    unless $known[s][t]
      g[t].child.each{|u, w|
        next if done[u]
        next if s == u
        stack << u
        done[u] = true
        flag = false
        break
      }
      if flag
        max[t] ||= 0
        $known[s][t] = g[s].child[t] + max[t]
        max[s] = $known[s][t] if max[s] == nil || max[s] < $known[s][t]
        stack.pop
      end
    else
      max[s] = $known[s][t] if max[s] == nil || max[s] < $known[s][t]
      stack.pop
    end
  end
  # p $known
  # p max
  return $known[i][j]
end

$known = Hash.new{|h, k| h[k] = {}}
n = gets.to_i
g = Array.new(n){Node.new}

(n-1).times{
  s, t, w = gets.split.map(&:to_i)
  g[s].child[t] = w
  g[t].child[s] = w
}

n.times{|i|
  max = 0
  g[i].child.each{|j, w|
    ret = f(i, j, g)
    max = ret if max < ret
  }
  puts max
}