Tree and Queries CodeForces - 375D

You have a rooted tree consisting of n vertices. Each vertex of the tree has some color. We will assume that the tree vertices are numbered by integers from 1 to n. Then we represent the color of vertex v as c_v. The tree root is a vertex with number 1.

In this problem you need to answer to m queries. Each query is described by two integers v_j, k_j. The answer to query v_j, k_j is the number of such colors of vertices x, that the subtree of vertex v_j contains at least k_j vertices of color x.

You can find the definition of a rooted tree by the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory).

Input

The first line contains two integers n and m (2 ≤ n ≤ 10⁵; 1 ≤ m ≤ 10⁵). The next line contains a sequence of integers c₁, c₂, ..., c_n (1 ≤ c_i ≤ 10⁵). The next n - 1 lines contain the edges of the tree. The i-th line contains the numbers a_i, b_i (1 ≤ a_i, b_i ≤ n; a_i ≠ b_i) — the vertices connected by an edge of the tree.

Next m lines contain the queries. The j-th line contains two integers v_j, k_j (1 ≤ v_j ≤ n; 1 ≤ k_j ≤ 10⁵).

Output

Print m integers — the answers to the queries in the order the queries appear in the input.

Examples

Input

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

Output

2
2
1
0
1

Input

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

Output

4

Note

A subtree of vertex v in a rooted tree with root r is a set of vertices {u : dist(r, v) + dist(v, u) = dist(r, u)}. Where dist(x, y) is the length (in edges) of the shortest path between vertices x and y.

先把代码抄一遍再说：）

记录颜色那个很懵。。。

cnt[i]：记录 i 这种颜色出现的次数

cnk[i]：记录颜色出现 i 次的个数

#pragma warning(disable:4996)
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 100005;

int n, m, unit, DFS_clock;
int Start[maxn], End[maxn], arr[maxn], color[maxn], cnt[maxn], cnk[maxn], ans[maxn];

vector<int> Tree[maxn];

struct node {
    int l, r, k;
    int id;
}q[maxn];


bool cmp(const node& a, const node& b) {
    if (a.l / unit == b.l / unit) return a.r < b.r;
    return a.l < b.l;
}

void DFS(int u, int pa) {
    Start[u] = ++DFS_clock;
    arr[DFS_clock] = color[u];
    for (int i = 0; i < Tree[u].size(); i++) if (Tree[u][i] != pa) DFS(Tree[u][i], u);
    End[u] = DFS_clock;
}

void add(int pos) {
    cnt[arr[pos]]++;
    cnk[cnt[arr[pos]]]++;
}

void remove(int pos) {
    cnk[cnt[arr[pos]]]--;
    cnt[arr[pos]]--;
}

void Inite() {
    DFS_clock = 0;
    unit = sqrt(n);
    memset(cnt, 0, sizeof(cnt));
    memset(cnk, 0, sizeof(cnk));
    for (int i = 0; i <= n; i++) Tree[i].clear();
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF) {
        Inite();
        for (int i = 1; i <= n; i++) scanf("%d", &color[i]);
        for (int i = 2; i <= n; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            Tree[u].push_back(v);
            Tree[v].push_back(u);
        }
        DFS(1, -1);
        for (int i = 1; i <= m; i++) {
            int v, k;
            scanf("%d%d", &v, &k);
            q[i].l = Start[v];
            q[i].r = End[v];
            q[i].k = k;
            q[i].id = i;
        }
        sort(q + 1, q + m + 1, cmp);
        int L = q[1].l, R = L - 1;
        for (int i = 1; i <= m; i++) {
            while (L > q[i].l) add(--L);
            while (L < q[i].l) remove(L++);
            while (R < q[i].r) add(++R);
            while (R > q[i].r) remove(R--);
            ans[q[i].id] = cnk[q[i].k];
        }
        for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
    }
    return 0;
}