output_description: Print the answers for k = 1, 2, ..., N in order, each in its own line.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      c_1 c_2 ... c_N
      a_1 b_1
      :
      a_{N-1} b_{N-1}
attempt: import sys
  
  sr = lambda: sys.stdin.readline().rstrip()
  ir = lambda: int(sr())
  lr = lambda: list(map(int, sr().split()))
  sys.setrecursionlimit(10**6)
  
  
  class Bit:
      def __init__(self, n):
          self.size = n
          self.tree = [0] * (n + 1)
  
      def sum(self, i):
          s = 0
          while i > 0:
              s += self.tree[i]
              i -= i & (-i)
          return s
  
      def add(self, i, x):
          while i <= self.size:
              self.tree[i] += x
              i += i & (-i)
  
  
  def resolve():
      N = ir()
      c = lr()
      ab = [[] for i in range(N)]
      for i in range(N - 1):
          a, b = lr()
          ab[a - 1].append(b - 1)
          ab[b - 1].append(a - 1)
      tot = N * (N + 1) // 2
      il = [0] * N
      ol = [0] * N
      cnt = [0]
  
      def dfs(u, p):
          cnt[0] += 1
          il[u] = cnt[0]
          for i in ab[u]:
              if i != p:
                  dfs(i, u)
          ol[u] = cnt[0]
  
      dfs(0, -1)
      vs = [[] for i in range(N)]
      for i in range(N):
          vs[c[i] - 1].append(i)
      sl = Bit(N)
      for i in range(1, N + 1):
          sl.add(i, 1)
      for i in range(N):
          his = []
          ans = tot
          tvs = sorted(vs[i], key=lambda x: il[x])[::-1]
          for v in tvs:
              n = 1
              for j in ab[v]:
                  if il[j] > il[v]:
                      tmp = sl.sum(ol[j]) - sl.sum(il[j] - 1)
                      ans -= tmp * (tmp + 1) // 2
                      n += tmp
              sl.add(il[v], -n)
              his.append([il[v], n])
          tmp = sl.sum(ol[0]) - sl.sum(0)
          ans -= tmp * (tmp + 1) // 2
          for h in his:
              sl.add(h[0], h[1])
          print(ans)
  
  
  resolve()
  
problem_description: Statement
  
  We have a tree with N vertices numbered 1 to N. The i-th edge in this tree
  connects Vertex a_i and b_i. Additionally, each vertex is painted in a color,
  and the color of Vertex i is c_i. Here, the color of each vertex is
  represented by an integer between 1 and N (inclusive). The same integer
  corresponds to the same color; different integers correspond to different
  colors.
  
  For each k=1, 2, ..., N, solve the following problem:
  
    * Find the number of simple paths that visit a vertex painted in the color k one or more times.
  
  **Note:** The simple paths from Vertex u to v and from v to u are not
  distinguished.
samples: [{"input": "3\n    1 2 1\n    1 2\n    2 3", "output": "5\n    4\n    0\n    \n\nLet P_{i,j} denote the simple path connecting Vertex i and j.\n\nThere are 5 simple paths that visit a vertex painted in the color 1 one or\nmore times:  \nP_{1,1}\\,,\\, P_{1,2}\\,,\\, P_{1,3}\\,,\\, P_{2,3}\\,,\\, P_{3,3}\n\nThere are 4 simple paths that visit a vertex painted in the color 2 one or\nmore times:  \nP_{1,2}\\,,\\, P_{1,3}\\,,\\, P_{2,2}\\,,\\, P_{2,3}\n\nThere are no simple paths that visit a vertex painted in the color 3 one or\nmore times.\n\n* * *"}, {"input": "1\n    1", "output": "1\n    \n\n* * *"}, {"input": "2\n    1 2\n    1 2", "output": "2\n    2\n    \n\n* * *"}, {"input": "5\n    1 2 3 4 5\n    1 2\n    2 3\n    3 4\n    3 5", "output": "5\n    8\n    10\n    5\n    5\n    \n\n* * *"}, {"input": "8\n    2 7 2 5 4 1 7 5\n    3 1\n    1 2\n    2 7\n    4 5\n    5 6\n    6 8\n    7 8", "output": "18\n    15\n    0\n    14\n    23\n    0\n    23\n    0"}]