/*
Tree ( NodeIndex[value] ) :
	   1[3]
	   /  \
	 2[8]  3[7]
	 /     / 
   4[1]  5[2]
           \
		    6[9]

Input (1 is root) :
6
3 8 7 1 2 9
2 L 1
3 R 1
4 L 2
5 L 3
6 R 5
*/

#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

struct Node
{
	int value , left , right , parent;
	int childs;
	Node() { value=left=right=parent = 0; }
};

Node* a;

void Inorder( int v )
{
	if ( v == 0 ) return;
	
	Inorder(a[v].left);			// L
	cout<<a[v].value<<"("<<a[v].childs<<") ";		// V
	Inorder(a[v].right);		// R
}

int Height( int v )
{
	if ( v == 0 ) return 0;
	
	int lh = Height(a[v].left);
	int rh = Height(a[v].right);
	return max( lh , rh ) + 1;
}

int checkBalance( int v , bool& isBalanced )
{
	if ( v == 0 ) return 0;
	
	int lh = checkBalance(a[v].left , isBalanced);
	int rh = checkBalance(a[v].right , isBalanced);
	isBalanced &= ( abs(lh-rh)<=1 );
	return max( lh , rh ) + 1;
}

int CountChilds( int v )
{
	if ( v == 0 ) return 0;
	
	int lc = CountChilds(a[v].left);
	int rc = CountChilds(a[v].right);
	a[v].childs = lc + rc + 1;
	return a[v].childs;
}

int Find( int v , int k )
{
	int l = a[v].left , r = a[v].right;
	
	int lc = l==0 ? 0 : a[l].childs;
	
	if ( k <= lc )		return Find( l , k );
	if ( k == lc+1 )	return a[v].value;
	if ( k > lc+1 )		return Find( r , k-(lc+1));
}

int main()
{
	int n;
	cin>>n;
	
	a = new Node[n+1];
	
	for (int i=1 ; i<=n ; i++)
		cin>>a[i].value;
	
	for (int i=1 ; i<n ; i++)
	{
		int f , p;		// f = farzand , p = pedar
		char c;
		
		cin>>f>>c>>p;
		
		if (c=='L') a[p].left = f;
		else		a[p].right = f;
		
		a[f].parent = p;
	}
	CountChilds(1);	
	
	cout<<"Inorder : "; Inorder(1); cout<<"\n";
	cout<<"Find : ";
	for (int i=1 ; i<=n ; i++)
		cout<<Find(1 , i)<<" ";
	cout<<"\n";
	
	bool isBalanced = true;
	checkBalance(3 , isBalanced);
	if (isBalanced == true) cout<<"Yes , Balanced!\n";
	else cout<<"NO , it is not!\n";	
	
	return 0;
}