#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <iostream>
#include <vector>
#include <queue>
#include <set>

using namespace std;

#define int long long
#define PII pair<int,int>
#define x first
#define y second
#define For(i, l, r) for(int i = l; i <= r; i ++)
#define Rep(i, l, r) for(int i = l; i >= r; i --)

bool START;

void in(int &x)
{
	char c = getchar();
	while(c > '9' || c < '0') c = getchar();
	for(x = 0; c >= '0' && c <= '9'; c = getchar())
		x = x * 10 + c - '0';
}

const int N = 2e5 + 50;

int n, m;
int a[N];
struct node {int l, r, op, id;};
vector<node> vec[N], Q[N];
int Ans[N];
vector<int> G[N];
int id[N], sz[N], son[N];
set<int> S[N];

void init(int x, int y, int z)
{
	// printf("(%lld, %lld, %lld)\n", x, y, z);
	if(x <= z && z <= y) return;
	if(z > y)
	{
		vec[y].push_back({1, x, 1});
		vec[z].push_back({1, x, -1});
	}
	else
	{
		vec[y].push_back({z, x - 1, 1});
	}
}

void Dfs(int u, int pa)
{
	sz[u] = 1;
	for(int v: G[u]) if(v != pa)
	{
		Dfs(v, u); sz[u] += sz[v];
		if(sz[v] > sz[son[u]]) son[u] = v;
	}
	if(!son[u]) return ;
	S[u] = S[son[u]]; S[son[u]].clear();
	S[u].insert(a[u]);
	int z = a[u];
	for(int v : G[u]) if(v != pa && v != son[u])
	{
		for(int x : S[v])
		{
			auto it = S[u].lower_bound(x);
			if(it != S[u].end())
			{
				int y = *it; init(x, y, z);
			}
			if(it != S[u].begin())
			{
				it --; int y = *it;
				init(y, x, z);
			}
		}
		for(int x : S[v]) S[u].insert(x);
	}
}

#define ls (u << 1)
#define rs (u << 1 | 1)

int sum[N << 2], tag1[N << 2], tag2[N << 2], cnt[N << 2], mn[N << 2];

void up(int u)
{
	mn[u] = min(mn[ls], mn[rs]);
	sum[u] = sum[ls] + sum[rs];
	cnt[u] = 0;
	if(mn[u] == mn[ls]) cnt[u] += cnt[ls]; 
	if(mn[u] == mn[rs]) cnt[u] += cnt[rs];
}

void build(int u, int l, int r)
{
	cnt[u] = r - l + 1;
	if(l == r) return ;
	int mid = l + r >> 1; build(ls, l, mid); build(rs, mid + 1, r);
}

void Add(int u, int v)
{
	mn[u] += v; tag1[u] += v;
}

void Add_2(int u, int v)
{
	sum[u] += cnt[u] * v; tag2[u] += v;
}

void down(int u)
{
	if(tag1[u])
	{
		Add(ls, tag1[u]); Add(rs, tag1[u]); tag1[u] = 0;
	}
	if(tag2[u])
	{
		if(mn[ls] == mn[u]) Add_2(ls, tag2[u]);
		if(mn[rs] == mn[u]) Add_2(rs, tag2[u]); tag2[u] = 0;
	}
}

void upd1(int u, int l, int r, int x, int y, int v)
{
	if(x <= l && r <= y) {Add(u, v); return ;}
	down(u); int mid =  l + r>>1;
	if(x <= mid) upd1(ls, l, mid, x, y, v);
	if(y > mid) upd1(rs, mid + 1, r, x, y, v); up(u);
}

void upd2(int u, int l, int r, int x, int y, int v)
{
	if(mn[u] > 0) return ;
	if(x <= l && r <= y) {Add_2(u, v); return ;}
	int mid = l + r >> 1; down(u);
	if(x <= mid) upd2(ls, l, mid, x, y, v);
	if(y > mid) upd2(rs, mid + 1, r, x, y, v);
	up(u);
}

int query(int u, int l, int r, int x, int y)
{
	if(x <= l && r <= y) return sum[u];
	int mid = l + r >> 1, s = 0; down(u);
	if(x <= mid) s += query(ls, l, mid, x, y);
	if(y > mid) s += query(rs, mid + 1, r, x, y);
	return s;
}

#undef ls 
#undef rs

int b[N];
bool ENDPOS = 0;
signed main()
{
	in(n); in(m);
	For(i, 1, n) in(a[i]); //a is a permutaiton, very good!
	For(i, 2, n)
	{
		int pa; in(pa); G[pa].push_back(i);
	}
	For(i, 1, n) id[a[i]] = i, S[i].insert(a[i]);
	Dfs(1, 0);
	build(1, 1, n);
	For(i, 1, m)
	{
		int l, r; in(l); in(r);
		Q[r].push_back({l, r, 1, i});
	}
	build(1, 1, n);
	For(i, 1, n)
	{
		for(node E : vec[i])
		{
			upd1(1, 1, n, E.l, E.r, E.op);
		}
		upd2(1, 1, n, 1, i, 1);
		for(node E : Q[i])
		{
			Ans[E.id] = query(1, 1, n, E.l, E.r);
		}
	}
	For(i, 1, m) printf("%lld\n", Ans[i]);
	cerr << (&ENDPOS - &START) * 1.0 / 1024 / 1024 << endl; return 0;
}
/*
5 5
2 1 5 4 3
1
1
3
3
1 1
1 4
2 3
1 5
3 5
*/