description: Petya has a rooted tree with an integer written on each vertex. The vertex 1 is the root. You are to answer some questions about the tree.
  
  A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. The parent of a node v is the next vertex on the shortest path from v to the root.
  
  Each question is defined by three integers v, l, and k. To get the answer to the question, you need to perform the following steps: 
  
    * First, write down the sequence of all integers written on the shortest path from the vertex v to the root (including those written in the v and the root). 
    * Count the number of times each integer occurs. Remove all integers with less than l occurrences. 
    * Replace the sequence, removing all duplicates and ordering the elements by the number of occurrences in the original list in increasing order. In case of a tie, you can choose the order of these elements arbitrary. 
    * The answer to the question is the k-th number in the remaining sequence. Note that the answer is not always uniquely determined, because there could be several orderings. Also, it is possible that the length of the sequence on this step is less than k, in this case the answer is -1. 
  
  
  
  For example, if the sequence of integers on the path from v to the root is [2, 2, 1, 7, 1, 1, 4, 4, 4, 4], l = 2 and k = 2, then the answer is 1.
  
  Please answer all questions about the tree.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^6). Description of the test cases follows.
  
  The first line of each test case contains two integers n, q (1 ≤ n, q ≤ 10^6) — the number of vertices in the tree and the number of questions.
  
  The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the number written on the i-th vertex.
  
  The third line contains n-1 integers p_2, p_3, …, p_n (1 ≤ p_i ≤ n), where p_i is the parent of node i. It's guaranteed that the values p define a correct tree.
  
  Each of the next q lines contains three integers v, l, k (1 ≤ v, l, k ≤ n) — descriptions of questions.
  
  It is guaranteed that the sum of n and the sum of q over all test cases do not exceed 10^6.
  
  Output
  
  For each question of each test case print the answer to the question. In case of multiple answers, print any.
  
  Example
  
  Input
  
  
  2
  3 3
  1 1 1
  1 2
  3 1 1
  3 1 2
  3 2 1
  5 5
  1 2 1 1 2
  1 1 2 2
  3 1 1
  2 1 2
  4 1 1
  4 2 1
  4 2 2
  
  
  Output
  
  
  1 -1 1 
  1 1 2 1 -1 
solution: #include <bits/stdc++.h>
  #pragma GCC optimize("Ofast")
  #pragma GCC target("avx2")
  using namespace std;
  const int N = 1e6 + 10;
  set<int> se[N];
  vector<vector<int> > g(N);
  int cnt[N], a[N], ans[N], sum[4 * N];
  vector<vector<pair<int, pair<int, int> > > > req(N);
  void build(int v, int l, int r) {
    if (l == r) {
      sum[v] = 0;
      return;
    }
    int mid = (r + l) / 2;
    build(2 * v, l, mid);
    build(2 * v + 1, mid + 1, r);
    sum[v] = 0;
  }
  void upd(int v, int l, int r, int pos, int val) {
    if (l > pos || r < pos) {
      return;
    }
    if (l == r) {
      sum[v] += val;
      return;
    }
    int mid = (r + l) / 2;
    upd(2 * v, l, mid, pos, val);
    upd(2 * v + 1, mid + 1, r, pos, val);
    sum[v] = sum[2 * v] + sum[2 * v + 1];
  }
  int get_sum(int v, int l, int r, int tl, int tr) {
    if (l > tr || r < tl) {
      return 0;
    }
    if (l >= tl && r <= tr) {
      return sum[v];
    }
    int mid = (r + l) / 2;
    return get_sum(2 * v, l, mid, tl, tr) +
           get_sum(2 * v + 1, mid + 1, r, tl, tr);
  }
  int n, row;
  void get(int v, int l, int r, int k) {
    if (l == r) {
      row = l;
      return;
    }
    int mid = (r + l) / 2;
    if (sum[2 * v] >= k) {
      get(2 * v, l, mid, k);
    } else {
      get(2 * v + 1, mid + 1, r, k - sum[2 * v]);
    }
  }
  void dfs(int v, int pr) {
    if (cnt[a[v]] != 0) {
      upd(1, 1, n, cnt[a[v]], -1);
      se[cnt[a[v]]].erase(a[v]);
    }
    cnt[a[v]]++;
    se[cnt[a[v]]].insert(a[v]);
    upd(1, 1, n, cnt[a[v]], 1);
    for (int i = 0; i < req[v].size(); i++) {
      int pos = req[v][i].first, l = req[v][i].second.first,
          k = req[v][i].second.second;
      int val;
      if (l == 1) {
        val = 0;
      } else {
        val = get_sum(1, 1, n, 1, l - 1);
      }
      k += val;
      if (sum[1] < k) {
        ans[pos] = -1;
      } else {
        get(1, 1, n, k);
        ans[pos] = *se[row].begin();
      }
    }
    for (auto i : g[v]) {
      if (i == pr) {
        continue;
      }
      dfs(i, v);
    }
    se[cnt[a[v]]].erase(a[v]);
    upd(1, 1, n, cnt[a[v]], -1);
    cnt[a[v]]--;
    if (cnt[a[v]] != 0) {
      upd(1, 1, n, cnt[a[v]], 1);
      se[cnt[a[v]]].insert(a[v]);
    }
  }
  void solve() {
    int q;
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
      cin >> a[i];
      g[i].clear();
      cnt[a[i]] = 0;
      req[i].clear();
    }
    build(1, 1, n);
    for (int i = 2; i <= n; i++) {
      int p;
      cin >> p;
      g[i].push_back(p);
      g[p].push_back(i);
    }
    for (int i = 1; i <= q; i++) {
      int v, l, k;
      cin >> v >> l >> k;
      req[v].push_back({i, {l, k}});
    }
    dfs(1, 1);
    for (int i = 1; i <= q; i++) {
      cout << ans[i] << " ";
    }
    cout << "\n";
  }
  signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    while (t--) {
      solve();
      cout << "\n";
    }
  }
  