#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
const int maxm=12087712;
const int maxn=200005;
class tree{
public:
	inline tree(){
		val=tag=l=r=0;
	}
	inline void clear(){
		val=tag=l=r=0;
	}
	inline int avl(){
		return val+tag;
	}
	int val;
	int tag;
	int l;
	int r;
}m[maxm+100];
inline void cal(int t){
	m[t].val=max(m[m[t].l].avl(),m[m[t].r].avl());
}
int nm[maxm+100],hd,tl;
int a[maxn+5],w[maxn+5],N,root[maxn+5],n;
vector<int> to[maxn+5];

inline int New(){
	int h=hd;
	#if debug
	if(!h){
		printf("memory error\n");
		exit(0);
	}
	#endif
	hd=nm[hd];
	m[h].clear();
	return h;
}
inline int Del(int t){
	nm[tl]=t;
	nm[tl=t]=0;
}
inline void lazydown(int t){
	if(m[t].l)m[m[t].l].tag+=m[t].tag;
	if(m[t].r)m[m[t].r].tag+=m[t].tag;
	m[t].val+=m[t].tag;
	m[t].tag=0;
}
void dbin(int a,int b,int maxa,int maxb,int l,int r){
	lazydown(a);
	lazydown(b);
	if(l==r){
		m[a].val=max(m[a].val+max(maxb,m[b].val),m[b].val+max(maxa,m[a].val));
		Del(b);
		return;
	}
	int mid=(l+r)>>1,ma=max(m[m[a].r].avl(),maxa),mb=max(m[m[b].r].avl(),maxb);
//	printf("(%d,%d):%d %d max:%d %d\n",l,r,m[a].avl(),m[b].avl(),ma,mb);
	if(m[a].r){
		if(m[b].r){
			dbin(m[a].r,m[b].r,maxa,maxb,mid+1,r);
		}
		else{
			m[m[a].r].tag+=maxb;
		}
	}
	else{
		if(m[b].r){
			m[a].r=m[b].r;
			m[m[a].r].tag+=maxa;
		}
	}
	if(m[a].l){
		if(m[b].l){
			dbin(m[a].l,m[b].l,ma,mb,l,mid);
		}
		else{
			m[m[a].l].tag+=mb;
		}
	}
	else{
		if(m[b].l){
			m[a].l=m[b].l;
			m[m[a].l].tag+=ma;
		}
	}
	cal(a);
	Del(b);
}
inline void bin(int a,int b){
	dbin(a,b,0,0,1,N);
}
void dadd(int a,int x,int k,int l,int r){
	lazydown(a);
	if(l==r){
		m[a].val=max(m[a].val,k);
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid){
		if(!m[a].l)m[a].l=New();
		dadd(m[a].l,x,k,l,mid);
	}
	else{
		if(!m[a].r)m[a].r=New();
		dadd(m[a].r,x,k,mid+1,r);
	}
	cal(a);
}
inline void add(int t,int x,int k){
	dadd(t,x,k,1,N);
}
int Dask(int t,int x,int y,int l,int r){
	if(!t)return 0;
	int L=max(x,l),R=min(y,r);
	if(L>R)return 0;
	if(L==l&&R==r){
		return m[t].avl();
	}
	lazydown(t);
	int mid=(l+r)>>1;
	int ans=max(Dask(m[t].l,x,y,l,mid),Dask(m[t].r,x,y,mid+1,r));
	cal(t);
	return ans;
}
inline int ask(int t,int x,int y){
	return Dask(t,x,y,1,N);
}
void dfs(int now,int fa){
//	printf("%d in\n",now);
	int si=to[now].size(),v;
	if(si<=1){
		root[now]=New();
		add(root[now],w[now],1);
		//printf("%d\n",ask(root[now],5,5));
//		printf("%d out\n",now);
		return;
	}
	root[now]=0;
	for(int i=0;i<si;i++){
		v=to[now].at(i);
		if(v!=fa){
			dfs(v,now);
			if(root[now]){
				bin(root[now],root[v]);
			}
			else{
				root[now]=root[v];
			}
			root[v]=0;
		}
	}
	add(root[now],w[now],1+ask(root[now],w[now],N));
//	printf("%d out\n",now);
}



int main(){
	for(int i=1;i<maxm;i++){
		nm[i]=i+1;
	}
	nm[maxm]=0;
	hd=1;
	tl=maxm;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		w[i]=a[i];
	}
	sort(a+1,a+1+n);
	N=unique(a+1,a+1+n)-1-a;
	for(int i=1;i<=n;i++){
		w[i]=lower_bound(a+1,a+1+n,w[i])-a;
	}
	for(int i=2;i<=n;i++){
		int x;
		scanf("%d",&x);
		to[i].push_back(x);
		to[x].push_back(i);
	}
	dfs(1,0);
	printf("%d\n",m[root[1]].avl());
	return 0;
}