/*#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5, M = 1e6 + 5, B = 500;

int n, m, f[N], rt, ans[M], dfn[N], dfc, st[N][18], col[N], dep[N], lg[N];
vector<int> e[N];
set<int> s[N];

struct Q {
  int l, r, x, id;
  bool operator<(const Q &e) const {
    return l / B != e.l / B ? l / B < e.l / B : (l / B & 1 ? r < e.r : r > e.r);
  }
} q[M];

int Get(int x, int y) {
  return dfn[x] < dfn[y] ? x : y;
}

void Dfs(int x, int fa) {
  dfn[x] = ++dfc, col[dfc] = x, dep[x] = dep[fa] + 1, st[dfc][0] = fa;
  for (int i = 1, j = dfc - 1; i < 18 && j >= 1; j -= 1 << i, ++i) {
    st[i][j] = Get(st[j][i - 1], st[j + (1 << i - 1)][i - 1]);
  }
  for (int i : e[x]) {
    Dfs(i, x);
  }
}

int LCA(int x, int y) {
  if (x == y) {
    return x;
  }
  if (!x || !y) {
    return 0;
  }
  x = dfn[x], y = dfn[y];
  if (x > y) {
    swap(x, y);
  }
  int d = lg[y - x];
  return Get(st[x + 1][d], st[y - (1 << d) + 1][d]);
}

struct Block {
  int s[N], t[N];
  void Add(int x, int v) {
    if (!x) {
      return;
    }
    x = n - x + 1, s[(x - 1) / B + 1] += v, t[x] += v;
  }
  int Query(int x) {
    x = n - x + 1;
    int pos = (x - 1) / B + 1, res = 0;
    for (int i = 1; i < pos; ++i) {
      res += s[i];
    }
    for (int i = (pos - 1) * B + 1; i <= x; ++i) {
      res += t[i];
    }
    return res;
  }
} A;

void Add(int x, int v) {
  if (v == 1) {
    s[dep[x]].insert(dfn[x]);
  }
  auto it = s[dep[x]].find(dfn[x]);
  int l = col[*prev(it)], r = col[*next(it)], d = max(dep[LCA(l, x)], dep[LCA(x, r)]);
  A.Add(dep[x] - d - 1, v);
  if (v == -1) {
    s[dep[x]].erase(it);
  }
}

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  cin >> n >> m;
  for (int i = 1; i <= n; ++i) {
    cin >> f[i];
    s[i].insert(0), s[i].insert(n + 1);
    e[f[i]].emplace_back(i), rt = f[i] ? rt : i;
  }
  lg[0] = -1;
  for (int i = 1; i <= n; ++i) {
    lg[i] = lg[i >> 1] + 1;
  }
  Dfs(rt, 0);
  for (int i = 1; i <= m; ++i) {
    cin >> q[i].l >> q[i].r >> q[i].x;
    q[i].id = i;
  }
  sort(q + 1, q + m + 1);
  for (int i = 1, l = 1, r = 0; i <= m; ++i) {
    while (r < q[i].r) {
      Add(++r, 1);
    }
    while (l > q[i].l) {
      Add(--l, 1);
    }
    while (r > q[i].r) {
      Add(r--, -1);
    }
    while (l < q[i].l) {
      Add(l++, -1);
    }
    ans[q[i].id] = A.Query(q[i].x);
  }
  for (int i = 1; i <= m; ++i) {
    cout << ans[i] << '\n';
  }
  return 0;
}