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 Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_imports)]
use num::Integer;
use proconio::*;
use std::ops::*;
use std::collections::VecDeque;

fn main() {
   input! {
       n: usize,
       mut c: [usize; n],
       e: [(usize, usize); n-1]
   }
   let mut to = vec![Vec::<usize>::new(); n];
   for (a, b) in &e {
      to[a - 1].push(b - 1);
      to[b - 1].push(a - 1);
   }
   for x in &mut c {
      *x -= 1;
   }
   let mut vin = vec![0; n];
   let mut vout = vec![0; n];

   {
       let mut stack = VecDeque::<usize>::new();
       stack.push_back(0);
       let mut k = 0;
       let mut yet = vec![false; n];
       while let Some(v) = stack.back().map(|v| *v as usize) {
           if !yet[v] {
               vin[v] = k;
               k += 1;
               yet[v] = true;
           }
           let mut flag = true;
           for u in to[v].iter().copied() {
               if yet[u] {
                   continue;
               }
               flag = false;
               stack.push_back(u);
           }
           if flag {
               vout[v] = k;
               stack.pop_back();
           }
       }
   }

   let mut vs = vec![Vec::<usize>::new(); n];
   for (i, x) in c.iter().enumerate() {
      vs[*x].push(i);
   }

   let mut res = vec![c2(n as i64); n];
   let mut d = BIT::<i64>::new(n, 0);
   for i in 0..n {
      d.add(i, 1);
   }
   for i in 0..n {
      vs[i].sort_by_key(|a| -(vin[*a] as i32));
      let mut history = Vec::<(usize, i64)>::new();
      for v in vs[i].iter().copied() {
         let mut cnt = 1;
         for u in to[v].iter().copied() {
            if (vin[u] < vin[v]) {
               continue;
            }
            let num = d.range(vin[u], vout[u]);
            res[i] -= c2(num as i64);
            cnt += num;
         }
         d.add(vin[v], -cnt);
         history.push((vin[v], cnt));
      }
      res[i] -= c2(d.range(0, n));
      for (i, cnt) in history {
         d.add(i, cnt);
      }
   }
   for r in res {
      println!("{}", r);
   }
}

fn c2(n: i64) -> i64 {
   n * (n + 1) / 2
}

#[derive(Debug, Clone)]
struct BIT<T> {
   n: usize,
   d: Vec<T>,
}

impl<T: Copy + Clone + Sub + AddAssign> BIT<T> {
   fn new(n: usize, x: T) -> BIT<T> {
      BIT {
         n: n,
         d: vec![x; n + 1],
      }
   }

   fn add(&mut self, i: usize, a: T) {
      let mut i = (i + 1) as i32;
      while i <= self.n as i32 {
         self.d[i as usize] += a;
         i += i & (-i);
      }
   }

   fn sum(&self, i: usize) -> T {
      let mut i = (i + 1) as i32;
      let mut sum = self.d[0];
      while i > 0 {
         sum += self.d[i as usize];
         i -= i & (-i);
      }
      sum
   }

   // [l, r)
   fn range(&self, l: usize, r: usize) -> <T as Sub>::Output {
      match (l, r) {
         (0, r) => self.sum(r - 1) - self.d[0],
         (_, _) => self.sum(r - 1) - self.sum(l - 1),
      }
   }
}