#include<bits/stdc++.h>

using u32=unsigned int;
using i64=long long;
using u64=unsigned long long;

// #define ONLINE_JUDGE
#define INPUT_DATA_TYPE int
#define OUTPUT_DATA_TYPE int
inline __attribute((always_inline)) INPUT_DATA_TYPE read(){register INPUT_DATA_TYPE x=0;register char f=0,c=getchar();while(c<'0'||'9'<c)f=(c=='-'),c=getchar();while('0'<=c&&c<='9')x=(x<<3)+(x<<1)+(c&15),c=getchar();return f?-x:x;}void print(OUTPUT_DATA_TYPE x){if(x<0)x=-x,putchar('-');if(x>9)print(x/10);putchar(x%10^48);return;}

int par[100010],id[100010],dep[100010],siz[100010],hson[100010],lkt[100010],cntid;
std::vector<int> e[100010],curs[100010];

void dfs(int u){
    curs[dep[u]=dep[par[u]]+1].push_back(u),siz[u]=1;
    for(auto v:e[u]){
        dfs(v),siz[u]+=siz[v];
        if(siz[v]>siz[hson[u]]) hson[u]=v;
    }
}

void dfsid(int u,int top){
    id[u]=++cntid,lkt[u]=top;
    if(hson[u]) dfsid(hson[u],top);
    for(auto v:e[u]) if(v!=hson[u]) dfsid(v,v);
    return;
}

int getlca(int u,int v){
    while(lkt[u]!=lkt[v]){
        if(dep[lkt[u]]<dep[lkt[v]]) std::swap(u,v);
        u=par[lkt[u]];
    }
    if(dep[u]<dep[v]) std::swap(u,v);
    return v;
}

const int INF=0x3f3f3f3f;

struct NODE{
    int val;
    int x,ly,ry,d;
};

std::vector<NODE> nods;
int n;

void ins(int Ll,int Lr,int Rl,int Rr,int val,int d){
    nods.push_back({val,Ll,Rl,Rr,d});
    nods.push_back({-val,Lr+1,Rl,Rr,d});
    return;
}

namespace subtree{
    int dd,rt;
    std::vector<int> e[100010];
    int siz[100010],id[100010],sid[100010],rid[100010],in[100010],cntid;
    int hson[100010];//??!

    std::set<int> st;

    void dfs(int u){
        siz[u]=1;
        for(auto v:e[u]){
            dfs(v),siz[u]+=siz[v];
            if(siz[v]>siz[hson[u]]) hson[u]=v;
        }
    }

    void clear(){
        st.clear();
        st.insert(0),st.insert(n+1);
    }

    void solve(int u,char keep){
        id[u]=cntid+1;
        if(in[u]) sid[++cntid]=u;

        for(auto v:e[u]) if(v!=hson[u]) solve(v,0);
        if(hson[u]){
            int i,d=dd-dep[u],lat;
            solve(hson[u],1);
            for(auto v:e[u]) if(v!=hson[u]){
                std::vector<std::pair<int,int>> now;

                now.push_back({0,0});

                auto it=--st.lower_bound(sid[id[v]]);
                if(*it!=0) now.push_back({*(++st.begin()),*it});

                std::sort(sid+id[v],sid+rid[v]+1);

                lat=sid[id[v]];
                for(i=id[v];i<rid[v];++i){
                    int u=sid[i],v=sid[i+1];
                    auto it=st.lower_bound(u);
                    if(it!=st.end()&&*it<v){
                        auto it2=st.lower_bound(v);
                        --it2;
                        now.push_back({lat,u});
                        now.push_back({*it,*it2});

                        lat=v;
                    }
                }

                now.push_back({lat,sid[rid[v]]});
                it=st.lower_bound(sid[rid[v]]);
                if(*it!=n+1) now.push_back({*it,*(++st.rbegin())});

                now.push_back({n+1,n+1});

                ins(1,n,1,n,-1,d);
                // printf("sub d%d dd:%d :\n",d,dd);

                for(i=1;i+1<now.size();++i){
                    int lx=now[i-1].second+1;
                    int rx=now[i].second;
                    int ly=now[i].first;
                    int ry=now[i+1].first-1;
                    
                    if(i==1) lx=ly=1;
                    if(i+2==now.size()) rx=ry=n;

                    ins(lx,rx,ly,ry,1,d);
                    // printf("d:%d dd:%d (%d,%d) (%d,%d)\n",d,dd,lx,rx,ly,ry);
                }

                for(i=id[v];i<=rid[v];++i) st.insert(sid[i]);
            }
        }else st.insert(u);

        if(!keep) clear();
        rid[u]=cntid;
    }

    void solve(std::vector<int> cur){
        int i;
        for(auto u:cur) in[u]=1,dd=dep[u];
        std::vector<int> tree(cur);
        std::sort(tree.begin(),tree.end(),[](int a,int b){return ::id[a]<::id[b];});
        int d=tree.size();
        for(i=1;i<d;++i) tree.push_back(getlca(tree[i-1],tree[i]));
        std::sort(tree.begin(),tree.end(),[](int a,int b){return ::id[a]<::id[b];});
        tree.erase(std::unique(tree.begin(),tree.end()),tree.end());
        for(i=1;i<tree.size();++i) e[getlca(tree[i-1],tree[i])].push_back(tree[i]);

        rt=tree[0];

        // printf("\n\n%d:",rt);
        // printf("\ncurs:");
        // for(auto u:cur) printf("%d ",u);
        // printf("\ntree:");
        // for(auto u:tree) printf("%d ",u);
        // printf("\nedges:\n");
        // for(auto u:tree) for(auto v:e[u]) printf("%d %d\n",u,v);
        

        clear();

        dfs(rt);
        solve(rt,1);
        
        int l=*++st.begin();
        int r=*++st.rbegin();
        ins(1,r,l,n,-1,dd);


        for(auto u:tree){
            e[u].clear();
            hson[u]=in[u]=0;
        }
        cntid=0;
    }
}

struct BIT{
    int tree[100010];
    
    void add(int pos,int x){
        while(pos<=n) tree[pos]+=x,pos+=lowbit(pos);
    }
    int pre(int pos){
        int res=0;
        while(pos) res+=tree[pos],pos-=lowbit(pos);
        return res;
    }
    void clear(int pos){
        while(pos<=n) tree[pos]=0,pos+=lowbit(pos);
    }

    int lowbit(int x){return x&(-x);}
}bit;

int res[1000010];//!!?

void solve(int l,int r){
    if(l==r) return;

    int mid=(l+r)>>1,i,j;
    std::sort(nods.begin()+l,nods.begin()+r+1,[](NODE a,NODE b){
        if(a.x==b.x) return a.val<b.val;
        return a.x<b.x;
    });

    solve(l,mid),solve(mid+1,r);
    std::sort(nods.begin()+l,nods.begin()+mid+1,[](NODE a,NODE b){
        return a.d<b.d;//!!?
    });
    std::sort(nods.begin()+mid+1,nods.begin()+r+1,[](NODE a,NODE b){
        return a.d<b.d;//!!?
    });
    
    // printf("\nsolve %d %d %d:\n",l,mid,r);
    for(i=mid+1,j=l;i<=r;++i){
        while(j<=mid&&nods[j].d<=nods[i].d){
            if(nods[j].val!=INF){
                bit.add(nods[j].ly,nods[j].val);
                bit.add(nods[j].ry+1,-nods[j].val);
                // printf("add   id:%d d:%d x:%d ly:%d ry:%d val:%d\n",j,nods[j].d,nods[j].x,nods[j].ly,nods[j].ry,nods[j].val);
            }
            ++j;
        }
        if(nods[i].val==INF){
            res[nods[i].ry]+=bit.pre(nods[i].ly);
            // printf("qry   id:%d d:%d x:%d y:%d val:%d\n",nods[i].ry,nods[i].d,nods[i].x,nods[i].ly,bit.pre(nods[i].ly));
        }
    }
    for(i=l;i<j;++i) if(nods[i].val!=INF) bit.clear(nods[i].ly),bit.clear(nods[i].ry+1);
}

int main(){
    int i,u,v,rt,d;
    n=read();
    int m=read();

    for(i=1;i<=n;++i){
        if(par[i]=read()) e[par[i]].push_back(i);//,printf("%d %d\n",par[i],i);
        else rt=i;
        ins(1,i,i,n,1,0);
    }

    for(i=0;i<m;++i){
        int l=read();
        int r=read();
        int x=read();
        nods.push_back({INF,l,r,i,x});
    }

    dfs(rt),dfsid(rt,rt);

    // for(u=1;u<=n;++u) for(v=u;v<=n;++v) printf("%d %d %d\n",u,v,getlca(u,v));

    for(d=1;d<=n;++d) if(curs[d].empty()) break; else subtree::solve(curs[d]);

    solve(0,nods.size()-1);
    
    for(i=0;i<m;++i) print(res[i]),putchar('\n');

    return 0;
}