#include <bits/stdc++.h>
using namespace std;
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
	#include <boost/multiprecision/cpp_int.hpp>
	#include <boost/multiprecision/cpp_dec_float.hpp>
	using bll = boost::multiprecision::cpp_int;
	using bdouble = boost::multiprecision::cpp_dec_float_100;
	using namespace boost::multiprecision;
#endif
#ifdef LOCAL_DEV
	void debug_impl() { std::cerr << '\n'; }
	template<typename Head, typename... Tail> void debug_impl(Head head, Tail... tail) { std::cerr << " " << head << (sizeof...(tail) ? "," : ""); debug_impl(tail...); }
	#define debug(...) do { std::cerr << "(" << #__VA_ARGS__ << ") ="; debug_impl(__VA_ARGS__); } while (false)
#else
	#define debug(...) do {} while (false)
#endif
#ifdef LOCAL_TEST
	#define BOOST_STACKTRACE_USE_ADDR2LINE
	#define BOOST_STACKTRACE_ADDR2LINE_LOCATION /usr/local/opt/binutils/bin/addr2line
	#define _GNU_SOURCE
	#include <boost/stacktrace.hpp>
	namespace std {
		template<typename T> class dvector : public std::vector<T> {
		public:
			dvector() : std::vector<T>() {}
			explicit dvector(size_t n, const T& value = T()) : std::vector<T>(n, value) {}
			dvector(const std::vector<T>& v) : std::vector<T>(v) {}
			dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
			dvector(const std::string::iterator first, const std::string::iterator last) : std::vector<T>(first, last) {}
			dvector(const typename std::vector<T>::iterator first, const typename std::vector<T>::iterator last) : std::vector<T>(first, last) {}
			dvector(const typename std::vector<T>::reverse_iterator first, const typename std::vector<T>::reverse_iterator last) : std::vector<T>(first, last) {}
			dvector(const typename std::vector<T>::const_iterator first, const typename std::vector<T>::const_iterator last) : std::vector<T>(first, last) {}
			dvector(const typename std::vector<T>::const_reverse_iterator first, const typename std::vector<T>::const_reverse_iterator last) : std::vector<T>(first, last) {}
			T& operator[](size_t n) {
				try { return this->at(n); } catch (const std::exception& e) {
					std::cerr << boost::stacktrace::stacktrace() << '\n'; return this->at(n);
				}
			}
			const T& operator[](size_t n) const {
				try { return this->at(n); } catch (const std::exception& e) {
					std::cerr << boost::stacktrace::stacktrace() << '\n'; return this->at(n);
				}
			}
		};
	}
	class dbool {
	private:
		bool boolvalue;
	public:
		dbool() : boolvalue(false) {}
		dbool(bool b) : boolvalue(b) {}		
		dbool(const dbool&) = default;
		dbool(dbool&&) = default;
		dbool& operator=(const dbool&) = default;
		dbool& operator=(dbool&&) = default;
		operator bool&() { return boolvalue; }
		operator const bool&() const { return boolvalue; }
	};
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::dvector<T>& v) {
		for (size_t i = 0; i < v.size(); ++i){ s << v[i]; if (i < v.size() - 1) s << "\t"; } return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::dvector<std::dvector<T>>& vv) {
		s << "\\\n"; for (size_t i = 0; i < vv.size(); ++i){ s << vv[i] << "\n"; } return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::deque<T>& v) {
		for (size_t i = 0; i < v.size(); ++i){ s << v[i]; if (i < v.size() - 1) s << "\t"; } return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::set<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::multiset<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template <typename T, size_t N> std::ostream& operator<<(std::ostream& s, const std::array<T, N>& a) {
		s << "{ "; for (size_t i = 0; i < N; ++i){ s << a[i] << "\t"; } s << "}"; return s; }
	template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::map<T1, T2>& m) {
		s << "{\n"; for (auto itr = m.begin(); itr != m.end(); ++itr){ s << "\t" << (*itr).first << " : " << (*itr).second << "\n"; } s << "}"; return s; }
	template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::pair<T1, T2>& p) {
		return s << "(" << p.first << ", " << p.second << ")"; }
	#define vector dvector
	#define bool dbool
	class SIGFPE_exception : std::exception {};
	class SIGSEGV_exception : std::exception {};
	void catch_SIGFPE([[maybe_unused]] int e) { std::cerr << boost::stacktrace::stacktrace() << '\n'; throw SIGFPE_exception(); }
	void catch_SIGSEGV([[maybe_unused]] int e) { std::cerr << boost::stacktrace::stacktrace() << '\n'; throw SIGSEGV_exception(); }
	signed convertedmain();
	signed main() { signal(SIGFPE, catch_SIGFPE); signal(SIGSEGV, catch_SIGSEGV); return convertedmain(); }
	#define main() convertedmain()
#endif
//#define int long long
using ll = long long;
//constexpr int INF = 1e9;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18;//(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1LL, 0LL, -1LL, 0LL};
constexpr ll dy[4] = {0LL, 1LL, 0LL, -1LL};
constexpr ll dx8[8] = {1LL, 0LL, -1LL, 0LL, 1LL, 1LL, -1LL, -1LL};
constexpr ll dy8[8] = {0LL, 1LL, 0LL, -1LL, 1LL, -1LL, 1LL, -1LL};
#define rep(i, n)   for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define rrep(i, n)   for(ll i=(n)-1; i>=0; --i)
#define rrepeq(i, n) for(ll i=(n)  ; i>=1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\n'; }
template<typename Head, typename... Tail> void p(Head head, Tail... tail) { std::cout << head << (sizeof...(tail) ? " " : ""); p(tail...); }
template<typename T> inline void pv(std::vector<T>& v) { for(ll i=0, N=v.size(); i<N; i++) std::cout << v[i] << " \n"[i==N-1]; }
template<typename T> inline bool chmax(T& a, T b) { return a < b && (a = b, true); }
template<typename T> inline bool chmin(T& a, T b) { return a > b && (a = b, true); }
template<typename T> inline void uniq(std::vector<T>& v) { v.erase(std::unique(v.begin(), v.end()), v.end()); }

/*-----8<-----template-----8<-----*/

/*
vt[i]->val: 頂点i自身の値
vt[i]->dat: 頂点iの部分木の総和(頂点i自身の値は含まない)
vt[i]->sum: 頂点iを含む木全体のval総和

evert(t) : 
　t をもともとの木の根にする。

expose(t) : 
　t と根との間を Heavy-edge でつなげて, t を Heavy-edge の Splay 木の根にする。
　戻り値は t ではないので注意。

link(child, parent) : 
　child の親を parent にする
　(もともと parent の連結成分に child がつながってたらこわれるので注意すること)。
　もともとの child は木の根である必要がある
　(根ではない場合は事前に lct.evert(child); を呼び出すこと)。

cut(child) : 
　child の親と child を切り離す。
*/
template<typename T>
struct LinkCutTree{
	struct Node{
		T val, dat, sum;
		int sz;
		bool rev;
		Node *l, *r, *p;
		
		Node(T val):val(val), dat(0), sum(val), sz(1), rev(false), l(nullptr), r(nullptr), p(nullptr){}
		bool is_root(){
			return !p || (p->l!=this && p->r!=this);
		}
	};

	LinkCutTree(){}
	void toggle(Node *t){
		if(!t) return;
		swap(t->l, t->r);
		t->rev^=true;
	}
	void push(Node *t){
		if(!t) return;
		if(t->rev){
			toggle(t->l);
			toggle(t->r);
			t->rev=false;
		}
	}
	void update(Node *t){
		t->sz=1, t->sum=t->val+t->dat;
		if(t->l) t->sz+=t->l->sz, t->sum+=t->l->sum;
		if(t->r) t->sz+=t->r->sz, t->sum+=t->r->sum;
	}
	void rotate(Node *t){
		Node *p=t->p, *pp=p->p, *ch;
		if(p->l==t) ch=t->r;
		else ch=t->l;
		if(pp){
			if(pp->l==p) pp->l=t;
			else if(pp->r==p) pp->r=t;
		}
		t->p=pp;
		if(p->l==t) t->r=p;
		else t->l=p;
		p->p=t;
		if(p->l==t) p->l=ch;
		else p->r=ch;
		if(ch) ch->p=p;
		update(p);
		update(t);
	}
	int state(Node *t){
		if(t->is_root()) return 0;
		else if(t->p->l==t) return 1;
		else return -1;
	}
	void splay(Node *t){
		push(t);
		while(state(t)){
			if(!state(t->p)){
				push(t->p); push(t);
				rotate(t);
			}else{
				push(t->p->p); push(t->p); push(t);
				if(state(t->p)==state(t)){
					rotate(t->p);
					rotate(t);
				}else{
					rotate(t);
					rotate(t);
				}
			}
		}
	}
	Node *expose(Node *t){
		Node *rp=nullptr;
		for(Node *now=t; now; now=now->p){
			splay(now);
			if(rp) now->dat-=rp->sum;
			if(now->r) now->dat+=now->r->sum;
			now->r=rp;
			update(now);
			rp=now;
		}
		splay(t);
		return rp;
	}
	void link(Node *c, Node *p){//c:root
		expose(c);
		expose(p);
		p->r=c;
		c->p=p;
		update(p);
	}
	void cut(Node *c){//c->l != nullptr
		expose(c);
		c->l->p=nullptr;
		c->l=nullptr;
		update(c);
	}
	void evert(Node *t){
		expose(t);
		toggle(t);
		push(t);
	}
};

/*-----8<-----library-----8<-----*/

//https://www.slideshare.net/iwiwi/2-12188845
//https://atcoder.jp/contests/abc163/tasks/abc163_f
void ABC163F() {
	LinkCutTree<ll> lct;
	using node=LinkCutTree<ll>::Node;

	ll N;
	cin>>N;
	//v[i]:色iの頂点集合
	vector<vector<ll>> v(N);
	for(ll i=0; i<N; i++){
		ll c;
		cin>>c;
		c--;
		v[c].push_back(i);
	}
	vector<vector<pair<ll,ll>>> g(N);
	vector<bool> used(N,false);
	vector<node*> vt(N);

	//node初期化　各頂点のvalに1をセット
	for(ll i=0; i<N; i++) vt[i]=new node(1);

	for(ll i=0; i<N-1; i++){
		ll a, b;
		cin>>a>>b;
		a--; b--;
		g[a].push_back({b, i});
		g[b].push_back({a, i});
		//node aにnode bをつなげる
		lct.evert(vt[a]);
		lct.link(vt[a], vt[b]);
	}
	for(ll i=0; i<N; i++){
		//ans:色iを含まない単純パスの数 単純パスの総数から引いていく
		ll ans=N*(N+1)/2;
		//色iの頂点xを走査
		for(ll x:v[i]){
			//q:頂点xとつながっている頂点pair
			for(pair<ll,ll> q:g[x]){
				ll i=q.second; //i:辺番号
				if(used[i]) continue;
				used[i]=true;
				ll y=q.first; //y:頂点xとつながっている頂点
				lct.evert(vt[x]); //xをrootにする
				ll c=vt[x]->sum; //c:xの部分木の頂点数
				lct.cut(vt[y]); //yをcut
				ll c1=vt[y]->sum; //c1:yの部分木の頂点数
				ans-=c*(c+1)/2;
				ans+=c1*(c1+1)/2;
				ans+=(c-c1)*(c-c1+1)/2;
			}
		}
		ans-=v[i].size();
		//色iを通る単純パス=総数-ans
		cout<<N*(N+1)/2-ans<<endl;

		//cutした部分をlinkして元に戻す
		for(ll x:v[i]){
			for(pair<ll,ll> q:g[x]){
				ll i=q.second;
				if(!used[i]) continue;
				used[i]=false;
				ll y=q.first;
				lct.evert(vt[x]);
				lct.link(vt[x], vt[y]);
			}
		}
	}
}

//https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_subtree_sum
void dynamic_tree_vertex_add_subtree_sum(){
	LinkCutTree<ll> lct;
	using node=LinkCutTree<ll>::Node;

	ll N,Q;
	cin>>N>>Q;
	vector<bool> used(N,false);
	vector<node*> vt(N);

	//node初期化　各頂点のvalに値aiをセット
	for(ll i=0; i<N; i++){
		ll a;
		cin>>a;
		vt[i]=new node(a);
	}

	for(ll i=0; i<N-1; i++){
		ll a, b;
		cin>>a>>b;
		//node aにnode bをつなげる
		lct.evert(vt[a]);
		lct.link(vt[a], vt[b]);
	}

	vector<ll> anslist;
	while(Q--){
		ll query;
		cin>>query;
		if(query==0){
			ll a,b,c,d;
			cin>>a>>b>>c>>d;
			lct.evert(vt[a]);
			lct.cut(vt[b]);
			lct.evert(vt[c]);
			lct.link(vt[c], vt[d]);
		}else if(query==1){
			ll v,x;
			cin>>v>>x;
			lct.evert(vt[v]);
			vt[v]->val+=x;
		}else if(query==2){
			ll v,par;
			cin>>v>>par;
			lct.evert(vt[par]);
			lct.expose(vt[v]);
			anslist.push_back(vt[v]->val+vt[v]->dat);
		}
	}

	rep(i,anslist.size())p(anslist[i]);
}

signed main() {
	ABC163F();
	//dynamic_tree_vertex_add_subtree_sum();

	return 0;
}


Measured memory_bytes: 41476