#pragma GCC optimize(2, 3, "Ofast")
#include <bits/stdc++.h>
using namespace std;
#define MAXN 100005
#define MAXM 1000005

bool st;

int urd(){char c; int x(0); while ((c=getchar())<48); do x=(x<<1)+(x<<3)+(c^48); while ((c=getchar())>47); return x;}

int n, q, m, rt, ct;
int fa[MAXN], dep[MAXN], siz[MAXN], top[MAXN], son[MAXN], dfn[MAXN], rt2[MAXN];
int ans[MAXM], col[MAXN*3], sz[MAXN*3]; set<int> ps[MAXN];
vector<int> e[MAXN], d[MAXN], g[MAXN*3]; unordered_map<int, int> ump[MAXN];
struct Node{int v, id;}; vector<Node> yyx; struct Que{int l, r, x, id;}que[MAXM];
struct Node2{int v, x, y, id;}; vector<Node2> qry;

void dfs1(int x){dep[x]=dep[fa[x]]+(siz[x]=1); for (auto i: e[x]) dfs1(i), siz[x]+=siz[i], son[x]=siz[i]>siz[son[x]]?i:son[x];}
void dfs2(int x, int tp){top[x]=tp; dfn[x]=++ct; if (son[x]) dfs2(son[x], tp); for (auto i: e[x]) if (i^son[x]) dfs2(i, i);}
int LCA(int x, int y){for (; top[x]^top[y]; x=fa[top[x]]) if (dep[top[x]]<dep[top[y]]) swap(x, y); return dep[x]<dep[y]?x:y;}
void sol0(int p){
    sort(d[p].begin(), d[p].end(), [=](int x, int y){return dfn[x]<dfn[y];});
    vector<int> vec(d[p]); for (int i(0); i+1<d[p].size(); ++i) vec.push_back(LCA(d[p][i], d[p][i+1]));
    sort(vec.begin(), vec.end(), [=](int x, int y){return dfn[x]<dfn[y];}); auto it(unique(vec.begin(), vec.end()));
    for (auto i(vec.begin()); i!=it; ++i){ump[p][*i]=++ct; if (dep[*i] == p) col[ct]=*i, sz[ct]=1;}
    for (auto i(vec.begin()); next(i)!=it; ++i) g[ump[p][LCA(*i, *next(i))]].push_back(ump[p][*next(i)]);
    for (auto i(vec.begin()); i!=it; ++i) if (dep[*i]^p) yyx.push_back({p-dep[*i], ump[p][*i]}); rt2[p] = ump[p][vec[0]];
}
void modify(int p, int q){
    int las(0); for (auto i: ps[p]) qry.push_back({-1, las, i, 0}), las = i;
    // if (p == 1) cerr << ps[p].size() << '\n';
    for (auto i: ps[p]){
        auto it(ps[q].insert(i).first); qry.push_back({1, it==ps[q].begin()?0:*prev(it), i, 0});
        // if (col[p] == 1) cerr << qry.size() << '\n';
        if (next(it) != ps[q].end()){
            qry.push_back({-1, it==ps[q].begin()?0:*prev(it), *next(it), 0}); qry.push_back({1, i, *next(it), 0});
        }
    }
    ps[p].clear();
}

namespace BIT{
#define lbw(x) ((x) & -(x))
    int c[MAXN];
    void add(int x, int k){for (; x<=n; x+=lbw(x)) c[x] += k;}
    int qry(int x){int res(0); for (; x; x-=lbw(x)) res += c[x]; return res;}
    int qry(int l, int r){return qry(r)-qry(l-1);}
}
void cdq(int l, int r){
    if (l == r) return; int mid((l+r)>>1); cdq(l, mid); cdq(mid+1, r);
    sort(qry.begin()+l, qry.begin()+mid+1, [](Node2 a, Node2 b){
        if (a.v && !b.v) return true; if (!a.v && b.v) return false; return a.x < b.x;
    });
    sort(qry.begin()+mid+1, qry.begin()+r+1, [](Node2 a, Node2 b){
        if (a.v && !b.v) return false; if (!a.v && b.v) return true; return a.x < b.x;
    }); int p(l);
    for (int i(mid+1); i<=r && !qry[i].v; ++i){
        while (p <= mid && qry[p].v && qry[p].x<qry[i].x) BIT::add(qry[p].y, qry[p].v), ++p;
        ans[qry[i].id] += BIT::qry(qry[i].x, qry[i].y);
    }
    for (--p; p>=l; --p) BIT::add(qry[p].y, -qry[p].v);
}

bool ed;

signed main(){
    // cerr << (&st-&ed)/1024.0/1024.0 << '\n';
    n = urd(); q = urd(); for (int i(1); i<=n; ++i){e[fa[i]=urd()].push_back(i); if (!fa[i]) rt=i;} dfs1(rt); dfs2(rt, rt);
    for (int i(1); i<=n; ++i) d[dep[i]].push_back(i); for (int i(1); i<=n && d[i].size(); ++i) sol0(i);
    for (int i(1); i<=q; ++i) cin >> que[i].l >> que[i].r >> que[i].x, que[i].id = i;
    sort(que+1, que+q+1, [](Que a, Que b){return a.x < b.x;});
    sort(yyx.begin(), yyx.end(), [](Node a, Node b){return a.v < b.v;});
    for (int i(1); i<=n; ++i) ps[i].insert(i), qry.push_back({1, 0, i, 0});
    for (int i(1), p(0); i<=q; ++i){
        for (; p<yyx.size() && que[i].x>=yyx[p].v; ++p){
            int id(yyx[p].id); sort(g[id].begin(), g[id].end(), [=](int x, int y){return sz[x] > sz[y];}); col[id]=col[g[id][0]];
            // cerr << id << '\n';
            for (int i(1); i<g[id].size(); ++i) modify(col[g[id][i]], col[id]);
        }
        if (que[i].x ^ que[i-1].x){
            int las(0); for (auto j: ps[col[rt2[que[i].x]]]) qry.push_back({-1, las, j, 0}), las = j;
        }
        qry.push_back({0, que[i].l, que[i].r, que[i].id});
    }
    // for (auto i: qry){
    //     cerr << i.v << ' ' << i.x << ' ' << i.y << ' ' << i.id << '\n';
    // }
    cdq(0, qry.size()-1); for (int i(1); i<=q; ++i) cout << ans[i] << '\n';

    return 0;
}