Codeforces 600E Lomsat gelral

You are given a rooted tree with root in vertex 1. Each vertex is coloured in some colour.

Let’s call colour c dominating in the subtree of vertex v if there are no other colours that appear in the subtree of vertex v more times than colour c. So it’s possible that two or more colours will be dominating in the subtree of some vertex.

The subtree of vertex v is the vertex v and all other vertices that contains vertex v in each path to the root.

For each vertex v find the sum of all dominating colours in the subtree of vertex v.

Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of vertices in the tree.

The second line contains n integers ci (1 ≤ ci ≤ n), ci — the colour of the i-th vertex.

Each of the next n - 1 lines contains two integers xj, yj (1 ≤ xj, yj ≤ n) — the edge of the tree. The first vertex is the root of the tree.

Output
Print n integers — the sums of dominating colours for each vertex.

Sample test(s)
input
4
1 2 3 4
1 2
2 3
2 4
output
10 9 3 4
input
15
1 2 3 1 2 3 3 1 1 3 2 2 1 2 3
1 2
1 3
1 4
1 14
1 15
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
output
6 5 4 3 2 3 3 1 1 3 2 2 1 2 3

解题思路：简单树形DP，在合并map的时候需要一定的技巧，总是将小的map合并到大的map。

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <functional>
using namespace std;
const int maxn = 100010;
typedef long long ll;

int color[maxn];
int rcol[maxn];
int id[maxn];
ll num[maxn];
ll ans[maxn];
map<int,int> cm[maxn];

struct Edge {
    int v, next;
    Edge() { }
    Edge(int _v, int _next) : v(_v), next(_next) { }
}edges[2*maxn];
int head[maxn], edge_sum;

void init_graph() {
    edge_sum = 0;
    memset(head, -1, sizeof(head));
}

void add_edge(int u, int v) {
    edges[edge_sum].v = v;
    edges[edge_sum].next = head[u];
    head[u] = edge_sum++;

    edges[edge_sum].v = u;
    edges[edge_sum].next = head[v];
    head[v] = edge_sum++;
}

void merge(int &u, int &v) {
    if(cm[u].size() < cm[v].size()) swap(u, v);
    for(map<int,int>::iterator it = cm[v].begin(); it != cm[v].end(); ++it) {
        cm[u][it->first] += it->second;
        if(rcol[u] < cm[u][it->first]) {
            rcol[u] = cm[u][it->first];
            num[u] = it->first;
        } else if(rcol[u] == cm[u][it->first]) {
            num[u] += it->first;
        }
    }
    return ;
}

void dfs(int u, int fa) {

    rcol[u] = 1;
    num[u] = color[u];
    cm[u][color[u]]++;
    for(int i = head[u]; i != -1; i = edges[i].next) {
        int v = edges[i].v;
        if(v == fa) continue;
        dfs(v, u);
        merge(id[u], id[v]);
    }
    ans[u] = num[id[u]];
    return ;
}

int main() {

    //freopen("aa.in", "r", stdin);
    int n, u, v;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        id[i] = i;
        scanf("%d", &color[i]);
    }
    init_graph();
    for(int i = 1; i < n; ++i) {
        scanf("%d %d", &u, &v);
        add_edge(u, v);
    }
    dfs(1, -1);
    for(int i = 1; i <= n; ++i) {
        printf("%I64d ", ans[i]);
    }
    printf("\n");
    return 0;
}