#include <iostream>
#include <vector>
#include <map>
#include <utility>
#include <algorithm>
#define llint long long

using namespace std;
typedef pair<int, int> P;

struct BIT{
	int size;
	vector<llint> bit;
	BIT(){size = 0;}
	BIT(int s){
		size = s;
		bit.resize(size+1);
		init();
	}
	void init(){
		for(int i = 1; i <= size; i++) bit[i] = 0;
	}
	llint query(int i){
		llint ret = 0;
		while(i > 0){
			ret += bit[i];
			i -= i&(-i);
		}
		return ret;
	}
	void add(int i, llint x){
		while(i <= size){
			bit[i] += x;
			i += i&(-i);
		}
	}
};

llint n;
llint p[2005], a[2005], ainv[2005];
vector<int> G[2005];
llint depth[2005];
vector<llint> vec[2005];
vector<P> node;
int dest[2005];
bool used[2005], need[2005];
BIT bit[2005];
vector<int> ans;

void rotate(int s)
{
	int v = s, c, t;
	while(v != 1){
		ainv[a[v]] = p[v];
		v = p[v];
	}
	ainv[a[1]] = s;
	
	v = s, c = a[1];
	do{
		t = a[v];
		a[v] = c;
		c = t;
		v = p[v];
	}while(v != 0);
	
	v = s, c = false;
	do{
		t = need[v];
		need[v] = c;
		c = t;
		v = p[v];
	}while(v != 0);
	
	ans.push_back(s);
}

void depdfs(int v, int d)
{
	depth[v] = d;
	for(int i = 0; i < G[v].size(); i++){
		depdfs(G[v][i], d+1);
	}
}

int dfs(int v)
{
	int cnt = 0;
	for(int i = 0; i < G[v].size(); i++){
		if(used[G[v][i]]) continue;
		cnt++;
	}
	if(cnt == 0){
		vec[v].push_back(v);
		return v;
	}
	for(int i = 0; i < G[v].size(); i++){
		if(used[G[v][i]]) continue;
		int res = dfs(G[v][i]);
		if(cnt == 1 && res != -1){
			vec[res].push_back(v);
			return res;
		}
	}
	return -1;
}

int main(void)
{
	cin >> n;
	for(int i = 2; i <= n; i++){
		cin >> p[i];
		p[i]++;
		G[p[i]].push_back(i);
	}
	for(int i = 1; i <= n; i++) cin >> a[i], a[i]++;
	for(int i = 1; i <= n; i++) ainv[a[i]] = i;
	
	depdfs(1, 0);
	for(int i = 1; i <= n; i++) node.push_back(P(depth[i], i));
	sort(node.rbegin(), node.rend());
	
	for(int i = 1; i <= n; i++) bit[i] = BIT(2005);
	
	while(!used[1]){
		dfs(1);
		llint rem = 0;
		for(int i = 1; i <= n; i++){
			if(used[i]) continue;
			if(vec[i].size() == 0) continue;
			reverse(vec[i].begin(), vec[i].end());
			for(int j = 0; j < vec[i].size(); j++){
				int x = vec[i][j];
				need[ainv[x]] = true;
				used[x] = true;
				dest[x] = i;
				rem++;
			}
		}
		llint k = 0;
		while(rem){
			if(need[1]){
				int d = dest[a[1]];
				int cnt = bit[d].query(n+1) - bit[d].query(a[1]);
				int v = vec[d][(int)vec[d].size()-1-cnt];
				bit[d].add(a[1], 1);
				rotate(v);
				rem--;
			}
			else{
				int v = node[k].second;
				if(need[v]) rotate(v);
				k++;
			}
		}
	}
	
	cout << ans.size() << endl;
	for(int i = 0; i < ans.size(); i++) cout << ans[i]-1 << endl;
	
	return 0;
}
