#include <bits/stdc++.h>
#define lowbit(x) (x & (-x))
using namespace std;

const int N = 100010, M = 1000010;
int n, m, rt, fa[N], res[N]; vector < int > tr[N];
struct Opt {int id, l, r, x, val;} op[M + N * 20]; int opn;
inline bool cmp_l(Opt u, Opt v)
{
	if(u.l != v.l) return u.l < v.l;
	else if(u.r != v.r) return u.r < v.r;
	else if(u.x != v.x) return u.x < v.x;
	else return u.id < v.id;
}

int dfn[N], dfid, seq[N * 2][21], sn, dep[N], lft[N];
vector < int > d_con[N];
inline void init(int now, int prt)
{
	dfn[now] = ++dfid, seq[++sn][0] = now;
	dep[now] = dep[prt] + 1; d_con[dep[now]].push_back(now);
	for(int to : tr[now])
	{
		init(to, now);
		seq[++sn][0] = now;
	}
}
inline void init_LCA()
{
	for(int i = 1; (1 << i) <= sn; ++i)
	{
		for(int j = 1; j + (1 << i) - 1 <= sn; ++j)
		{
			if(dep[seq[j][i - 1]] <= dep[seq[j + (1 << (i - 1))][i - 1]])
				seq[j][i] = seq[j][i - 1];
			else seq[j][i] = seq[j + (1 << (i - 1))][i - 1];
		}
	}
	for(int i = sn; i >= 1; --i) lft[seq[i][0]] = i;
}
inline int LCA(int x, int y)
{
	if(lft[x] > lft[y]) swap(x, y);
	int k = __lg(lft[y] - lft[x] + 1);
	if(dep[seq[lft[x]][k]] <= dep[seq[lft[y] - (1 << k) + 1][k]])
		return seq[lft[x]][k];
	else return seq[lft[y] - (1 << k) + 1][k];
}

namespace Get_opt
{
	vector < int > virtr[N];
	set < int > con[N];
	int ps[N * 2], psn, lst_l[N], lst_d[N], siz[N];
	struct Table
	{
		int state[N]; queue < int > q; bool vis[N];
		inline void refresh(int p) {if(!vis[p]) {vis[p] = true, q.push(p);}}
		inline void modify(int p, int num)
		{refresh(p); state[p] = num;}
		inline int query(int p) {return state[p];}
		inline void clear() {while(!q.empty()) state[q.front()] = vis[q.front()] = 0, q.pop();}
	}; Table tb;
	inline bool cmp(int x, int y) {return dfn[x] < dfn[y];}
	inline void get(int x, int y, int d)
	{
		if(lst_l[y] != -1)
		{
			op[++opn] = {0, lst_l[y] + 1, y, d, -1};
			op[++opn] = {0, y + 1, y, d, 1};
		}
		op[++opn] = {0, x + 1, y, d, 1};
		op[++opn] = {0, y + 1, y, d, -1};
		lst_l[y] = x, lst_d[y] = d;
	}
	inline void tree_comb(int now, int D)
	{
		con[now].clear();
		int son = 0; siz[now] = (virtr[now].size() == 0);
		for(int to : virtr[now])
		{
			tree_comb(to, D); siz[now] += siz[to];
			if(!son || siz[to] > siz[son]) son = to;
		}
		if(!son)
		{
			get(0, now, 1);
			con[now].insert(now);
		}
		else
		{
			vector < int > chk;
			con[now].swap(con[son]);
			for(int to : virtr[now])
			{
				if(to == son) continue;
				for(int x : con[to])
				{
					tb.modify(x, to); chk.push_back(x);
					con[now].insert(x);
				}
			}
			for(int x : chk)
			{
				auto p = con[now].find(x);
				if(p != con[now].begin())
				{
					int pr = *prev(p);
					if(tb.query(pr) != tb.query(x))
						get(pr, x, D - dep[now]);
				}
				if(next(p) != con[now].end())
				{
					int nx = *next(p);
					if(tb.query(nx) == 0)
						get(x, nx, D - dep[now]);
				}
			}
			tb.clear();
		}
	}
	inline void build_tree(int D)
	{
		psn = 0;
		for(int x : d_con[D]) ps[++psn] = x;
		sort(ps + 1, ps + psn + 1, cmp);
		for(int i = 1, s_psn = psn; i < s_psn; ++i)
			ps[++psn] = LCA(ps[i], ps[i + 1]);
		sort(ps + 1, ps + psn + 1, cmp);
		psn = unique(ps + 1, ps + psn + 1) - ps - 1;
		for(int i = 1; i <= psn; ++i)
		{
			virtr[ps[i]].clear();
			lst_l[ps[i]] = lst_d[ps[i]] = -1;
		}
		stack < int > sta;
		for(int i = 1; i <= psn; ++i)
		{
			while(!sta.empty() && LCA(sta.top(), ps[i]) != sta.top()) sta.pop();
			if(!sta.empty()) virtr[sta.top()].push_back(ps[i]);
			sta.push(ps[i]);
		}
//		cerr << "build tree : " << D << '\n';
//		for(int i = 1; i <= psn; ++i)
//		{
//			cerr << ps[i] << " : ";
//			for(int x : virtr[ps[i]])
//				cerr << x << " ";
//			cerr << '\n';
//		}
	}
	inline void work(int D)
	{
		build_tree(D);
		tree_comb(ps[1], D);
		for(int x : d_con[D])
		{
			if(lst_l[x] != -1)
			{
				op[++opn] = {0, lst_l[x] + 1, x, D, -1};
				op[++opn] = {0, x + 1, x, D, 1};
			}
		}
	}
}

namespace Cdq
{
	struct BIT
	{
		int c[N];
		inline void add(int p, int num)
		{for(int i = p; i <= n; i += lowbit(i)) c[i] += num;}
		inline int query(int p)
		{
			int res = 0;
			for(int i = p; i; i -= lowbit(i)) res += c[i];
			return res;
		}
	}; BIT bit;
	
	inline void divide(int l, int r)
	{
		if(l == r) return ;
		int mid = (l + r) >> 1;
		divide(l, mid), divide(mid + 1, r);
//		cerr << "divide " << l << " " << r << " " << mid << " +++++++++++++++++++++++++\n";
//		for(int i = l; i <= r; ++i) cerr << "cdqop " << op[i].id << " " << op[i].l << " " << op[i].r << " " << op[i].x << " " << op[i].val << '\n';
//		for(int i = 1; i <= 3; ++i) cerr << bit.query(i) << " "; cerr << '\n';
		int pl = l, pr = mid + 1;
		vector < Opt > sve;
		while(pl <= mid || pr <= r)
		{
			if(pr > r || (pl <= mid && op[pl].r <= op[pr].r && op[pl].x <= op[pr].x))
			{
				if(op[pl].id == 0) bit.add(op[pl].x, op[pl].val);
				sve.push_back(op[pl]); ++pl;
			}
			else
			{
				if(op[pr].id != 0) op[pr].val += bit.query(op[pr].x);
				sve.push_back(op[pr]); ++pr;
			}
		}
		for(int i = l; i <= mid; ++i) if(op[i].id == 0) bit.add(op[i].x, -op[i].val);
		for(int i = l; i <= r; ++i) op[i] = sve[i - l];
	}
	inline void work()
	{
		sort(op + 1, op + opn + 1, cmp_l);
		divide(1, opn);
	}
}

int main()
{
//	freopen("text.in", "r", stdin);
//	freopen("prog.out", "w", stdout);
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for(int i = 1; i <= n; ++i)
	{
		cin >> fa[i];
		if(!fa[i]) rt = i;
		else tr[fa[i]].push_back(i);
	}
	for(int i = 1; i <= m; ++i)
		op[++opn].id = i, cin >> op[i].l >> op[i].r >> op[i].x;
	init(rt, 0), init_LCA();
	for(int i = 1; d_con[i].size(); ++i) Get_opt::work(i);
//	for(int i = 1; i <= opn; ++i) cerr << "op " << op[i].id << " " << op[i].l << " " << op[i].r << " " << op[i].x << " " << op[i].val << '\n';
	Cdq::work();
	for(int i = 1; i <= opn; ++i) if(op[i].id) res[op[i].id] = op[i].val;
	for(int i = 1; i <= m; ++i) cout << res[i] << '\n';
	return 0;
}
/*
3 1
0 1 1
2 3 1
*/