#pragma GCC optimize("Ofast,unroll-loops")
#include <bits/extc++.h>
#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using db = double;
using pii = pair<int, int>;

#define il inline
#define mkp make_pair
#define eb emplace_back
#define fi first
#define se second
#define ssz(x) ((signed)((x).size()))
#define For(i, j, k) for (int i = (j); i <= (k); i++)
#define ForDown(i, j, k) for (int i = (j); i >= (k); i--)
template <typename T> il void cmin(T &x, const T &y) { x = min(x, y); }
template <typename T> il void cmax(T &x, const T &y) { x = max(x, y); }

using namespace __gnu_pbds;

namespace {
constexpr int MAXN = 1e5 + 5;
int n, m, rt, fa[MAXN], dep[MAXN], id[MAXN], dfn[MAXN], seq[17][MAXN],
    Ans[MAXN * 10], cnt = 0, qwq[MAXN];
vector<int> T[MAXN];
vector<tuple<bool, int, int, int>> todo[MAXN];
int bit[MAXN];

void bit_add(int p, int v) {
  for (; p <= n; p += p & -p)
    bit[p] += v;
}
void bit_add(int l, int r, int v) {
  // cerr << "A " << l << ' ' << r << ' ' << v << '\n';
  assert(l <= r), bit_add(l, v), bit_add(r + 1, -v);
}
int bit_qry(int p) {
  int ans = 0;
  // cerr << "Q " << p << ' ';
  for (cmin(p, n); p; p -= p & -p)
    ans += bit[p];
  return ans;
}

il int LCA(int x, int y) {
  if (x == y)
    return x;
  const auto [l, r] = minmax(dfn[x], dfn[y]);
  int f = 31 ^ __builtin_clz(r - l), u = seq[f][l + 1],
      v = seq[f][r - (1 << f) + 1];
  return fa[dep[u] < dep[v] ? u : v];
}
auto split(set<tuple<int, int, int>> &x, int lim) {
  auto it = x.upper_bound({lim + 1, 0, 0});
  if (it == x.begin())
    return x.begin();
  --it;
  auto [l, r, c] = *it;
  if (r == lim)
    return next(it);
  x.erase(it);
  x.emplace(l, lim, c);
  return x.emplace(lim + 1, r, c).fi;
}

struct VTree {
  int DEP;
  vector<vector<int>> T;
  vector<int> fa, rdep, sz, hson, bottom, top;
  vector<set<tuple<int, int, int>>> ODT;
  void dfs1(int x, int pre) {
    fa[x] = pre, sz[x] = 1, hson[x] = -1;
    for (int v : T[x]) {
      dfs1(v, x), sz[x] += sz[v];
      if (!~hson[x] || sz[v] > sz[hson[x]])
        hson[x] = v;
    }
  }
  void dfs2(int x, int _top) {
    top[x] = _top;
    if (~hson[x])
      dfs2(hson[x], _top);
    else
      bottom[_top] = x;
    for (int v : T[x])
      dfs2(v, v);
    if (x == _top) {
      int up = (~fa[x]) ? rdep[fa[x]] + 1 : 1;
      ODT[x].emplace(up, rdep[bottom[x]], 0);
      assert(up <= rdep[bottom[x]]);
    }
  }
  void build(int _dep, vector<int> &nodes) {
    nodes.eb(rt), DEP = _dep;
    sort(nodes.begin(), nodes.end(),
         [&](int x, int y) { return dfn[x] < dfn[y]; });
    int m = ssz(nodes);
    // cerr << DEP << ' ' << m << '\n';
    For(i, 1, m - 1) nodes.eb(LCA(nodes[i - 1], nodes[i]));
    sort(nodes.begin(), nodes.end(),
         [&](int x, int y) { return dfn[x] < dfn[y]; });
    nodes.erase(unique(nodes.begin(), nodes.end()), nodes.end());
    m = ssz(nodes);
    T.resize(m), fa.resize(m), rdep.resize(m), sz.resize(m), hson.resize(m),
        ODT.resize(m), bottom.resize(m), top.resize(m);
    For(i, 0, m - 1) {
      qwq[nodes[i]] = i, rdep[i] = dep[nodes[i]];
      if (rdep[i] == DEP)
        id[nodes[i]] = i;
    }

    For(i, 1, m - 1) T[qwq[LCA(nodes[i - 1], nodes[i])]].eb(i);
    // For(i, 0, m - 1) for (int j : T[i]) cerr << "E " << i << ' ' << j <<
    // '\n';
    dfs1(0, -1), dfs2(0, 0);
  }
  void upd(int x, int y) {
    // cerr << "!!! " << x << ' ' << y << '\n';
    while (~x) {
      auto R = split(ODT[top[x]], rdep[x]);
      for (auto it = ODT[top[x]].begin(); it != R; it = ODT[top[x]].erase(it)) {
        auto [l, r, col] = *it;
        assert(l <= r);
        if (col)
          todo[y].eb(0, DEP - r + 1, DEP - l + 1, -col);
      }
      int up = (~fa[top[x]]) ? rdep[fa[top[x]]] + 1 : 1;
      todo[y].eb(0, DEP - rdep[x] + 1, DEP - up + 1, y);
      ODT[top[x]].emplace(up, rdep[x], y);
      // cerr << "I " << DEP << ' ' << up << ' ' << rdep[x] << '\n';
      x = fa[top[x]];
    }
  }
} virt[MAXN];
void dfs(int x, int pre) {
  seq[0][dfn[x] = ++cnt] = x, dep[x] = dep[pre] + 1;
  for (int v : T[x])
    dfs(v, x);
}
void solve(int l, int r) {
  auto _cmp = [](auto x, auto y) {
    return abs(get<3>(x)) != abs(get<3>(y)) ? abs(get<3>(x)) > abs(get<3>(y))
                                            : get<0>(x) < get<0>(y);
  };
  if (l == r) {
    // cerr << "---\n";
    sort(todo[l].begin(), todo[l].end(), _cmp);
    for (auto [tp, x, y, _] : todo[l]) {
      if (!tp)
        bit_add(x, y, (_ > 0) ? 1 : -1);
      else
        Ans[y] += bit_qry(x);
    }
    for (auto [tp, x, y, _] : todo[l]) {
      if (!tp)
        bit_add(x, y, (_ > 0) ? -1 : 1);
    }
    return;
  }
  int mid = (l + r) >> 1;
  solve(l, mid), solve(mid + 1, r);
  const auto &L = todo[l], &R = todo[mid + 1];
  // cerr << "---\n";
  for (int p = 0, q = 0; p < ssz(L) || q < ssz(R);) {
    if (p < ssz(L) && (q == ssz(R) || _cmp(L[p], R[q]))) {
      auto [tp, x, y, _] = L[p++];
      if (!tp)
        bit_add(x, y, (_ > 0) ? 1 : -1);
    } else {
      auto [tp, x, y, _] = R[q++];
      if (tp)
        Ans[y] += bit_qry(x);
    }
  }
  for (auto [tp, x, y, _] : L)
    if (!tp)
      bit_add(x, y, (_ > 0) ? -1 : 1);
  static vector<tuple<bool, int, int, int>> tmp;
  tmp.resize(ssz(L) + ssz(R));
  merge(L.begin(), L.end(), R.begin(), R.end(), tmp.begin(), _cmp);
  todo[l].swap(tmp);
}

vector<int> bl_dep[MAXN];

void Main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> m;
  For(i, 1, n) {
    cin >> fa[i];
    if (!fa[i])
      rt = i;
    else
      T[fa[i]].eb(i);
  }
  dfs(rt, 0);
  For(i, 1, 16) For(j, 1, n - (1 << i) + 1) {
    int u = seq[i - 1][j], v = seq[i - 1][j + (1 << (i - 1))];
    seq[i][j] = (dep[u] < dep[v]) ? u : v;
  }
  For(i, 1, n) bl_dep[dep[i]].eb(i);
  For(i, 1, n) {
    if (!bl_dep[i].empty())
      virt[i].build(i, bl_dep[i]);
    else
      break;
  }
  For(i, 1, m) {
    int l, r, x;
    cin >> l >> r >> x, todo[r].eb(1, x + 1, i, l);
  }
  cerr << "ok " << 1. * clock() / CLOCKS_PER_SEC << '\n';
  For(i, 1, n) virt[dep[i]].upd(id[i], i);
  solve(1, n);
  For(i, 1, m) cout << Ans[i] << '\n';
}
} // namespace

int main() { return Main(), 0; }