Problem:
Score : 600 points

Problem 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.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq c_i \leq N

1 \leq a_i,b_i \leq N

The given graph is a tree.

All values in input are integers.

Input

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}

Output

Print the answers for k = 1, 2, ..., N in order, each in its own line.

Sample Input 1

3
1 2 1
1 2
2 3

Sample Output 1

5
4
0

Let P_{i,j} denote the simple path connecting Vertex i and j.

There are 5 simple paths that visit a vertex painted in the color 1 one or more times:

P_{1,1}\,,\,
P_{1,2}\,,\,
P_{1,3}\,,\,
P_{2,3}\,,\,
P_{3,3}

There are 4 simple paths that visit a vertex painted in the color 2 one or more times:

P_{1,2}\,,\,
P_{1,3}\,,\,
P_{2,2}\,,\,
P_{2,3}

There are no simple paths that visit a vertex painted in the color 3 one or more times.

Sample Input 2

1
1

Sample Output 2

1

Sample Input 3

2
1 2
1 2

Sample Output 3

2
2

Sample Input 4

5
1 2 3 4 5
1 2
2 3
3 4
3 5

Sample Output 4

5
8
10
5
5

Sample Input 5

8
2 7 2 5 4 1 7 5
3 1
1 2
2 7
4 5
5 6
6 8
7 8

Sample Output 5

18
15
0
14
23
0
23
0

Solution in C++ (GCC 9.2.1) (judge verdict: Runtime Error)

#include <bits/stdc++.h>
using namespace std;

#define rep(i, n) for(int i = 0; i < (n); ++i)
#define repr(i, n) for(int i = (n-1); i >= 0; --i)

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

typedef long long ll;
typedef pair<int, int> P;

const int MAX = 200005;
const int INF = 1001001001;
const int MOD = 1000000007;

struct BIT {
    int N, id; vector<int> bit; vector<pair<int, int>> his;
    BIT(int N, int id=0) : N(N), id(id), bit(N+1), his() {
        for (int i = 1; i <= N; ++i) add(i, id, false);
    }
    void add(int i, int v, bool flg=true) {
        if (flg) his.emplace_back(i, v);
        for (int j = i; j <= N; j += j & -j) bit[j] += v;
    }
    int sum(int i) {
        int res = 0;
        for (int j = i; j > 0; j -= j & -j) res += bit[j];
        return res;
    }
    int sum(int l, int r) {return sum(r-1) - sum(l-1);}
    void clear() {
        for (auto &p : his) add(p.first, -p.second);
        his.clear();
    }
};

vector<int> G[MAX];

int dfs(int v, vector<int> &in, vector<int> &out, int p=-1, int k=1) {
    in[v] = k++;
    for (auto &u : G[v]) {
        if (u == p) continue;
        k = dfs(u, in, out, v, k);
    }
    return out[v] = k;
}

ll calc(ll x) {return x*(x+1)/2;}

int main(){
    int N;
    cin >> N;

    vector<int> C(N);
    for (auto &i : C) cin >> i, --i;

    rep(i, N-1) {
        int a, b;
        cin >> a >> b;
        a--, b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }

    vector<int> in(N), out(N);
    dfs(0, in, out);

    BIT bit = BIT(N, 1);

    vector<vector<int>> V(N);
    rep(i, N) V[C[i]].push_back(i);
    rep(i, N) {
        sort(V[i].begin(), V[i].end(), [&](int a, int b) {
            return in[a] > in[b];
        });
    }

    ll total = calc(N);

    rep(i, N) {
        ll ans = total;
        vector<int> &NV = V[i];
        for (auto &v : NV) {
            int cnt = 1;
            for (auto &u : G[v]) {
                if (in[v] > in[u]) continue;
                int num = bit.sum(in[u], out[u]);
                ans -= calc(num);
                cnt += num;
            }
            bit.add(in[v], -cnt);
        }
        int num = bit.sum(1, N+1);
        ans -= calc(num);
        cout << ans << endl;
        bit.clear();
    }
}