思路：

抄一波yousiki的…

显然，暴力求解的复杂度是无法承受的。

考虑这样的一种暴力，我们把 z 到根上的点全部打标记，对于 l 到 r 之间的点，向上搜索到第一个有标记的点求出它的深度统计答案。观察到，深度其实就是上面有几个已标记了的点（包括自身）。所以，我们不妨把 z 到根的路径上的点全部 +1，对于 l 到 r 之间的点询问他们到根路径上的点权和。仔细观察上面的暴力不难发现，实际上这个操作具有叠加性，且可逆。也就是说我们可以对于 l 到 r 之间的点 i，将 i 到根的路径上的点全部 +1, 转而询问 z 到根的路径上的点（包括自身）的权值和就是这个询问的答案。把询问差分下，也就是用 [1, r] − [1, l − 1] 来计算答案，那么现在我们就有一个明显的解法。从 0 到 n − 1 依次插入点 i，即将 i 到根的路径上的点全部+1。离线询问答案即可。我们现在需要一个数据结构来维护路径加和路径求和，显然树链剖分或LCT 均可以完成这个任务。树链剖分的复杂度为 O((n + q)· log n · log n)，LCT的复杂度为 O((n + q)· log n)，均可以完成任务。至此，题目已经被我们完美解决。

//By SiriusRen

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

#define int long long

#define N 100050

int n,q,v[N],first[N],next[N],tot,all,cnt;

int fa[N],deep[N],son[N],size[N],top[N],p[N];

void add(int x,int y){v[tot]=y,next[tot]=first[x],first[x]=tot++;}

struct Node{int ask,pos,id,ans;}node[N];

struct Tree{int lazy,sum;}tr[N*8];

bool cmp(Node a,Node b){return a.pos<b.pos;}

bool Cmp(Node a,Node b){return a.id<b.id;}

void dfs(int x){

    size[x]=1;

    for(int i=first[x];~i;i=next[i]){

        deep[v[i]]=deep[x]+1;dfs(v[i]);

        size[x]+=size[v[i]];

        if(size[son[x]]<size[v[i]])son[x]=v[i];

    }

}

void dfs2(int x,int tp){

    top[x]=tp,p[x]=++cnt;

    if(son[x])dfs2(son[x],tp);

    for(int i=first[x];~i;i=next[i])if(v[i]!=son[x])

        dfs2(v[i],v[i]);

}

void push_down(int pos,int num){

    int lson=pos<<1,rson=pos<<1|1;

    tr[lson].lazy+=tr[pos].lazy;

    tr[rson].lazy+=tr[pos].lazy;

    tr[lson].sum+=(num-num/2)*tr[pos].lazy;

    tr[rson].sum+=(num/2)*tr[pos].lazy;

    tr[pos].lazy=0;

}

void insert(int l,int r,int pos,int L,int R){

    if(l>=L&&r<=R){tr[pos].sum+=(r-l+1),tr[pos].lazy++;return;}

    if(tr[pos].lazy)push_down(pos,r-l+1);

    int mid=(l+r)>>1,lson=pos<<1,rson=pos<<1|1;

    if(mid<L)insert(mid+1,r,rson,L,R);

    else if(mid>=R)insert(l,mid,lson,L,R);

    else insert(l,mid,lson,L,R),insert(mid+1,r,rson,L,R);

    tr[pos].sum=tr[lson].sum+tr[rson].sum;

}

void ins(int x){

    while(x){

        insert(1,n,1,p[top[x]],p[x]);

        x=fa[top[x]];

    }

}

int query(int l,int r,int pos,int L,int R){

    if(l>=L&&r<=R)return tr[pos].sum;

    int mid=(l+r)>>1,lson=pos<<1,rson=pos<<1|1;

    if(tr[pos].lazy)push_down(pos,r-l+1);

    if(mid<L)return query(mid+1,r,rson,L,R);

    else if(mid>=R)return query(l,mid,lson,L,R);

    else return query(l,mid,lson,L,R)+query(mid+1,r,rson,L,R);

}

int qry(int x){

    int ans=0;

    while(x){

        ans+=query(1,n,1,p[top[x]],p[x]);

        x=fa[top[x]];

    }return ans;

}

signed main(){

    memset(first,-1,sizeof(first));

    scanf("%lld%lld",&n,&q);

    for(int i=2;i<=n;i++)scanf("%lld",&fa[i]),add(++fa[i],i);

    for(int i=1;i<=q;i++){

        int l,r,z;

        scanf("%lld%lld%lld",&l,&r,&z);

        node[++all].ask=z+1,node[all].pos=l,node[all].id=all;

        node[++all].ask=z+1,node[all].pos=r+1,node[all].id=all;

    }

    sort(node+1,node+1+all,cmp);

    dfs(1),dfs2(1,1);

    int temp=1;

    while(node[temp].pos==0)temp++;

    for(int i=1;i<=n;i++){

        ins(i);

        while(node[temp].pos==i)

            node[temp].ans=qry(node[temp].ask),temp++;

    }

    sort(node+1,node+1+all,Cmp);

    for(int i=1;i<=all;i+=2)printf("%lld\n",(node[i+1].ans-node[i].ans)%201314);

}