import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

import numpy as np

from numba import njit





def EulerTour(graph, root=1):

    N = len(graph) - 1

    parent = [0] * (N + 1)

    stack = [-root, root]

    tour = []

    ind_L = [0] * (N + 1)

    ind_R = [0] * (N + 1)

    i = -1

    while stack:

        v = stack.pop()

        tour.append(v)

        i += 1

        if v > 0:

            ind_L[v] = i

            p = parent[v]

            for w in graph[v]:

                if w == p:

                    continue

                parent[w] = v

                stack.append(-w)

                stack.append(w)

        else:

            ind_R[-v] = i

    return tour, ind_L, ind_R, parent





@njit('i8[:](i8[:],i8[:],i8[:],i8[:],i8[:])', cache=True)

def main(C, tour, ind_L, ind_R, parent):

    N = len(C) - 1

    removed = np.zeros(N + 1, np.int64)

    answer = np.full_like(removed, N * (N + 1) // 2)

    memo = np.zeros_like(answer)

    for v in tour:

        if v > 0:

            memo[v] = removed[C[parent[v]]]

        else:

            v = -v

            removed[C[v]] += 1

            p = parent[v]

            x = (ind_R[v] - ind_L[v]) // 2 + 1  # subtree size

            x -= removed[C[p]] - memo[v]

            answer[C[p]] -= x * (x + 1) // 2

            removed[C[p]] += x

    for i, x in enumerate(removed):

        x = N - x

        answer[i] -= x * (x + 1) // 2

    return answer





N = int(readline())

graph = [[] for _ in range(N + 1)]

C = np.zeros(N + 1, np.int64)

C[1:] = np.array(readline().split(), np.int64)

m = list(map(int, read().split()))

for a, b in zip(m, m):

    graph[a].append(b)

    graph[b].append(a)



tour, ind_L, ind_R, parent = [np.array(x, np.int64) for x in EulerTour(graph)]



answer = main(C, tour, ind_L, ind_R, parent)

print(('\n'.join(answer[1:].astype(str))))

import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

import numpy as np

from numba import njit



@njit('(i4[:],i4[:],i4[:],i4)', cache=True)

def EulerTour(head, nxt, to, root):

    N = len(head) - 1

    parent = np.zeros_like(head)

    ind_L = np.empty_like(head)

    ind_R = np.empty_like(head)

    tour = np.empty(N + N, np.int32)

    stack = np.empty(N + N, np.int32)

    stack[0] = -root

    stack[1] = root

    t = -1

    s = 2

    while s > 0:

        s -= 1

        v = stack[s]

        t += 1

        tour[t] = v

        if v > 0:

            ind_L[v] = t

            p = parent[v]

            k = head[v]

            while k != -1:

                w = to[k]

                if w == p:

                    k = nxt[k]

                    continue

                parent[w] = v

                stack[s] = -w

                s += 1

                stack[s] = w

                s += 1

                k = nxt[k]

        else:

            ind_R[-v] = t

    return tour, ind_L, ind_R, parent





@njit('(i4[:],i4[:],i4[:],i4[:],i4[:])', cache=True)

def main(C, tour, ind_L, ind_R, parent):

    N = len(C) - 1

    removed = np.zeros(N + 1, np.int64)

    answer = np.full_like(removed, N * (N + 1) // 2)

    memo = np.zeros_like(answer)

    for v in tour:

        if v > 0:

            memo[v] = removed[C[parent[v]]]

        else:

            v = -v

            removed[C[v]] += 1

            p = parent[v]

            x = (ind_R[v] - ind_L[v]) // 2 + 1  # subtree size

            x -= removed[C[p]] - memo[v]

            answer[C[p]] -= x * (x + 1) // 2

            removed[C[p]] += x

    for i, x in enumerate(removed):

        x = N - x

        answer[i] -= x * (x + 1) // 2

    return answer





@njit('(i4[:],i4[:],i4,i4)', cache=True)

def edges_to_array(A, B, N, M):

    head = np.full(N + 1, -1, np.int32)

    nxt = np.empty(M + M, np.int32)

    to = np.empty(M + M, np.int32)

    for i in range(M):

        a = A[i]

        b = B[i]

        nxt[i << 1] = head[a]

        to[i << 1] = b

        head[a] = i << 1

        nxt[i << 1 | 1] = head[b]

        to[i << 1 | 1] = a

        head[b] = i << 1 | 1

    return head, nxt, to





N = int(readline())

C = np.zeros(N + 1, np.int32)

C[1:] = np.array(readline().split(), np.int32)

AB = np.array(read().split(), np.int32)

head, nxt, to = edges_to_array(AB[::2], AB[1::2], N, N - 1)



tour, ind_L, ind_R, parent = EulerTour(head, nxt, to, 1)

answer = main(C, tour, ind_L, ind_R, parent)

print(('\n'.join(answer[1:].astype(str))))

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from numba import njit


def EulerTour(graph, root=1):
    N = len(graph) - 1
    parent = [0] * (N + 1)
    stack = [-root, root]
    tour = []
    ind_L = [0] * (N + 1)
    ind_R = [0] * (N + 1)
    i = -1
    while stack:
        v = stack.pop()
        tour.append(v)
        i += 1
        if v > 0:
            ind_L[v] = i
            p = parent[v]
            for w in graph[v]:
                if w == p:
                    continue
                parent[w] = v
                stack.append(-w)
                stack.append(w)
        else:
            ind_R[-v] = i
    return tour, ind_L, ind_R, parent


@njit("i8[:](i8[:],i8[:],i8[:],i8[:],i8[:])", cache=True)
def main(C, tour, ind_L, ind_R, parent):
    N = len(C) - 1
    removed = np.zeros(N + 1, np.int64)
    answer = np.full_like(removed, N * (N + 1) // 2)
    memo = np.zeros_like(answer)
    for v in tour:
        if v > 0:
            memo[v] = removed[C[parent[v]]]
        else:
            v = -v
            removed[C[v]] += 1
            p = parent[v]
            x = (ind_R[v] - ind_L[v]) // 2 + 1  # subtree size
            x -= removed[C[p]] - memo[v]
            answer[C[p]] -= x * (x + 1) // 2
            removed[C[p]] += x
    for i, x in enumerate(removed):
        x = N - x
        answer[i] -= x * (x + 1) // 2
    return answer


N = int(readline())
graph = [[] for _ in range(N + 1)]
C = np.zeros(N + 1, np.int64)
C[1:] = np.array(readline().split(), np.int64)
m = list(map(int, read().split()))
for a, b in zip(m, m):
    graph[a].append(b)
    graph[b].append(a)
tour, ind_L, ind_R, parent = [np.array(x, np.int64) for x in EulerTour(graph)]
answer = main(C, tour, ind_L, ind_R, parent)
print(("\n".join(answer[1:].astype(str))))

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from numba import njit


@njit("(i4[:],i4[:],i4[:],i4)", cache=True)
def EulerTour(head, nxt, to, root):
    N = len(head) - 1
    parent = np.zeros_like(head)
    ind_L = np.empty_like(head)
    ind_R = np.empty_like(head)
    tour = np.empty(N + N, np.int32)
    stack = np.empty(N + N, np.int32)
    stack[0] = -root
    stack[1] = root
    t = -1
    s = 2
    while s > 0:
        s -= 1
        v = stack[s]
        t += 1
        tour[t] = v
        if v > 0:
            ind_L[v] = t
            p = parent[v]
            k = head[v]
            while k != -1:
                w = to[k]
                if w == p:
                    k = nxt[k]
                    continue
                parent[w] = v
                stack[s] = -w
                s += 1
                stack[s] = w
                s += 1
                k = nxt[k]
        else:
            ind_R[-v] = t
    return tour, ind_L, ind_R, parent


@njit("(i4[:],i4[:],i4[:],i4[:],i4[:])", cache=True)
def main(C, tour, ind_L, ind_R, parent):
    N = len(C) - 1
    removed = np.zeros(N + 1, np.int64)
    answer = np.full_like(removed, N * (N + 1) // 2)
    memo = np.zeros_like(answer)
    for v in tour:
        if v > 0:
            memo[v] = removed[C[parent[v]]]
        else:
            v = -v
            removed[C[v]] += 1
            p = parent[v]
            x = (ind_R[v] - ind_L[v]) // 2 + 1  # subtree size
            x -= removed[C[p]] - memo[v]
            answer[C[p]] -= x * (x + 1) // 2
            removed[C[p]] += x
    for i, x in enumerate(removed):
        x = N - x
        answer[i] -= x * (x + 1) // 2
    return answer


@njit("(i4[:],i4[:],i4,i4)", cache=True)
def edges_to_array(A, B, N, M):
    head = np.full(N + 1, -1, np.int32)
    nxt = np.empty(M + M, np.int32)
    to = np.empty(M + M, np.int32)
    for i in range(M):
        a = A[i]
        b = B[i]
        nxt[i << 1] = head[a]
        to[i << 1] = b
        head[a] = i << 1
        nxt[i << 1 | 1] = head[b]
        to[i << 1 | 1] = a
        head[b] = i << 1 | 1
    return head, nxt, to


N = int(readline())
C = np.zeros(N + 1, np.int32)
C[1:] = np.array(readline().split(), np.int32)
AB = np.array(read().split(), np.int32)
head, nxt, to = edges_to_array(AB[::2], AB[1::2], N, N - 1)
tour, ind_L, ind_R, parent = EulerTour(head, nxt, to, 1)
answer = main(C, tour, ind_L, ind_R, parent)
print(("\n".join(answer[1:].astype(str))))

-def EulerTour(graph, root=1): -    N = len(graph) - 1 -    parent = [0] * (N + 1) -    stack = [-root, root] -    tour = [] -    ind_L = [0] * (N + 1) -    ind_R = [0] * (N + 1) -    i = -1 -    while stack: -        v = stack.pop() -        tour.append(v) -        i += 1 +@njit("(i4[:],i4[:],i4[:],i4)", cache=True) +def EulerTour(head, nxt, to, root): +    N = len(head) - 1 +    parent = np.zeros_like(head) +    ind_L = np.empty_like(head) +    ind_R = np.empty_like(head) +    tour = np.empty(N + N, np.int32) +    stack = np.empty(N + N, np.int32) +    stack[0] = -root +    stack[1] = root +    t = -1 +    s = 2 +    while s > 0: +        s -= 1 +        v = stack[s] +        t += 1 +        tour[t] = v -            ind_L[v] = i +            ind_L[v] = t -            for w in graph[v]: +            k = head[v] +            while k != -1: +                w = to[k] +                    k = nxt[k] -                stack.append(-w) -                stack.append(w) +                stack[s] = -w +                s += 1 +                stack[s] = w +                s += 1 +                k = nxt[k] -            ind_R[-v] = i +            ind_R[-v] = t -@njit("i8[:](i8[:],i8[:],i8[:],i8[:],i8[:])", cache=True) +@njit("(i4[:],i4[:],i4[:],i4[:],i4[:])", cache=True) +@njit("(i4[:],i4[:],i4,i4)", cache=True) +def edges_to_array(A, B, N, M): +    head = np.full(N + 1, -1, np.int32) +    nxt = np.empty(M + M, np.int32) +    to = np.empty(M + M, np.int32) +    for i in range(M): +        a = A[i] +        b = B[i] +        nxt[i << 1] = head[a] +        to[i << 1] = b +        head[a] = i << 1 +        nxt[i << 1 | 1] = head[b] +        to[i << 1 | 1] = a +        head[b] = i << 1 | 1 +    return head, nxt, to + + -graph = [[] for _ in range(N + 1)] -C = np.zeros(N + 1, np.int64) -C[1:] = np.array(readline().split(), np.int64) -m = list(map(int, read().split())) -for a, b in zip(m, m): -    graph[a].append(b) -    graph[b].append(a) -tour, ind_L, ind_R, parent = [np.array(x, np.int64) for x in EulerTour(graph)] +C = np.zeros(N + 1, np.int32) +C[1:] = np.array(readline().split(), np.int32) +AB = np.array(read().split(), np.int32) +head, nxt, to = edges_to_array(AB[::2], AB[1::2], N, N - 1) +tour, ind_L, ind_R, parent = EulerTour(head, nxt, to, 1)