#include <iostream>
#include <stack>
#include <vector>
#include <map>
#include <algorithm>

constexpr int ntiers = 17;

int lca(int a, int b, const std::vector<int> &firstidx, const std::vector<int> &lastidx, const std::vector<int> &lift)
{
    int n = firstidx.size();
    int tier = ntiers-1;
    while(lastidx[b] < firstidx[a] || lastidx[b] > lastidx[a])
    {
        while(tier > 0 && firstidx[lift[tier*n + a]] <= lastidx[b] && lastidx[b] <= lastidx[lift[tier*n + a]])
            tier--;
        a = lift[tier*n+a];
    }
    return a;
}

int main()
{
    int n;
    std::cin >> n;
    std::vector<int> nodecolor(n);
    for(int i=0; i<n; i++)
    {
        int c;
        std::cin >> c;
        nodecolor[i] = c-1;
    }
    std::vector<std::pair<int, int> > edges(n-1);
    std::vector<std::vector<int> > adj(n);
    for(int i=0; i<n-1; i++)
    {
        int v1, v2;
        std::cin >> v1 >> v2;
        edges[i] = {v1-1, v2-1};
        adj[v1-1].push_back(v2-1);
        adj[v2-1].push_back(v1-1);
    }
    
    // build tree
    std::vector<std::vector<int> > children(n);
    std::vector<int> parent(n);
    std::vector<bool> visited(n);
    std::stack<int> tovisit;
    tovisit.push(0);
    parent[0] = 0;
    while(!tovisit.empty())
    {
        int next = tovisit.top();
        tovisit.pop();
        visited[next] = true;
        for(auto it : adj[next])
        {
            if(visited[it]) continue;
            children[next].push_back(it);
            parent[it] = next;
            tovisit.push(it);
        }
    }
    
    // LCA 
    std::vector<int> firstidx(n);
    std::vector<int> lastidx(n);
    struct Visit
    {
        int node;
        bool first;
    };
    std::stack<Visit> vs;
    vs.push({0, true});
    int idx=0;
    while(!vs.empty())
    {
        Visit v = vs.top();
        vs.pop();
        if(v.first)
        {
            firstidx[v.node] = idx;
            vs.push({v.node, false});
            for(auto c : children[v.node])
                vs.push({c, true});
        }
        else
        {
            lastidx[v.node] = idx;
        }
        idx++;
    }
    
    std::vector<int> lift(n*ntiers);
    for(int i=0; i<n; i++)
        lift[i] = parent[i];
    for(int tier=1; tier<ntiers; tier++)
    {
        for(int i=0; i<n; i++)
        {
            lift[tier*n + i] = lift[(tier-1)*n + lift[(tier-1)*n + i]];
        }
    }
    
    std::vector<std::map<int, int> > nodecolors(n);
    // fact: all nodes in the color-c subtree are LCAs of consecutive color c nodes
    struct ColoredNode
    {
        int node;
        int idx;
        bool operator<(const ColoredNode &other) const
        {
            return idx < other.idx;
        }        
    };
    std::vector<std::vector<ColoredNode> > colornodes(n);
    for(int i=0; i<n; i++)
    {
        colornodes[nodecolor[i]].push_back({i,lastidx[i]});
    }
    
    for(int i=0; i<n; i++)
    {
        if(colornodes[i].size() < 2)
            continue;
            
        std::sort(colornodes[i].begin(), colornodes[i].end());
        for(int j=0; j<colornodes[i].size(); j++)
        {
            int nextj = (j+1) % colornodes[i].size();
            int a = lca(colornodes[i][j].node, colornodes[i][nextj].node, firstidx, lastidx, lift);
            // touch a
            nodecolors[a][i] = 0;
            
//            std::cout << "lca " << colornodes[i][j].node << " " << colornodes[i][nextj].node << " " << a << std::endl;
        }
        for(auto it : colornodes[i])
            nodecolors[it.node][i] = 1;
    }
    
    // accumulate scores
    std::vector<int> colorparent(n);
    for(int i=0; i<n; i++)
        colorparent[i] = -1;
    std::vector<int64_t> nodescore(n);
    std::vector<int64_t> nodescoredelta(n);
    std::stack<std::pair<int, int> > undo;
    vs.push({0, true});
    while(!vs.empty())
    {
        Visit v = vs.top();
        vs.pop();
        if(v.first)
        {
            for(auto it : nodecolors[v.node])
            {
                undo.push({it.first, colorparent[it.first]});
                colorparent[it.first] = v.node;
            }
            vs.push({v.node, false});
            for(auto it : children[v.node])
                vs.push({it, true});
        }
        else
        {
            int64_t score = 0;
            for(auto it : children[v.node])
                score += nodescore[it];
            score += nodescoredelta[v.node];
            
            for(auto it : nodecolors[v.node])
            {
                colorparent[undo.top().first] = undo.top().second;
                undo.pop();
            }
            for(auto it : nodecolors[v.node])
            {
                int64_t nc = colornodes[it.first].size();
                int64_t c = it.second;
                int64_t delta = c * (nc - c);
                score += delta;

                int cparent = colorparent[it.first];
                if(cparent != -1)
                {
                    nodescoredelta[cparent] -= delta;
                    nodecolors[cparent][it.first] += it.second;
                }
            }
            
            nodescore[v.node] = score;
        }        
    }
    
    // finally, answer queries
    for(auto it : edges)
    {
        if(parent[it.first] == it.second)
        {
            std::cout << nodescore[it.first] << std::endl;
        }
        else
        {
            std::cout << nodescore[it.second] << std::endl;
        }
    }
}