#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string>

using namespace std;

/*
问题：实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两颗子树的高度差不超过1.
分析：关于树的大部分问题都是和递归相关。
      所以如果一棵树的左子树的高度和右子树各自平衡，且这两颗子树的高度之差不超过1即可。
	  递归基：
	  isAVLTree(Tree* head)
	  {
	     //如果还树为空，一定是平衡的
		 if(NULL == head)
		 {
		   return true
		 }
	  }

	  这里的关键是需要记录树的高度，最好能做成根据节点就能知道高度

输入： 
输入可能包含多个测试样例，输入以EOF结束。 
对于每个测试案例，输入的第一行一个整数n(1<=n<=1000, ：n代表将要输入的二叉树元素的个数（节点从1开始编号）。接下来一行有n个数字,代表第i个二叉树节点的元素的值。接下来有n行，每行有一个字母Ci。 
Ci=’d’表示第i个节点有两子孩子，紧接着是左孩子编号和右孩子编号。 
Ci=’l’表示第i个节点有一个左孩子，紧接着是左孩子的编号。 
Ci=’r’表示第i个节点有一个右孩子，紧接着是右孩子的编号。 
Ci=’z’表示第i个节点没有子孩子。 
输出： 

样例输入：
6
8 6 5 7 10 9
d 2 5 
d 3 4 
z 
z 
l 6 
z 


9 
8 6 5 7 10 9 11 13 15
d 2 5 
d 3 4 
z 
z 
d 6 7 
l 8
z 
r 9
z

样例输出：
Is AVL Tree!
Not AVL Tree!


关键：
1 构建树的节点，采用的是直接静态创建N个节点，每次创建节点，就是把静态节点数组中某个节点地址分配给它
对于某个节点的子节点，则直接根据子节点下标，取出静态节点数组中对应节点地址

TreeNode g_treeNodeArray[MAXSIZE];
int g_index; //用于标示创建的节点的下标

//创建节点
TreeNode* createNode()
{
	//先使节点标记累加，初始化节点中左右孩子的值为NULL
	++g_index;
	g_treeNodeArray[g_index]._pLeft = g_treeNodeArray[g_index]._pRight = g_treeNodeArray[g_index]._pParent = NULL;
	return &g_treeNodeArray[g_index];
}

2 判断平衡树中需要计算左右子树的高度，注意不是左右孩子节点的高度
int getTreeHeight(TreeNode* pNode)
{
	if(NULL == pNode)
	{
		return 0;
	}
	int leftHeight = getTreeHeight(pNode->_pLeft) + 1;
	int rightHeight = getTreeHeight(pNode->_pRight) + 1;
	int height = leftHeight > rightHeight ? leftHeight : rightHeight;
	return height;
} 

3判断平衡树除了递归基放在前面，判定条件放在中间，而对左右子树判断是否平衡要放在最后，这是因为，如果把判断左右子树
平衡放在中间，那么判定条件在最后面起不到作用
		int leftHeight= getTreeHeight(head->_pLeft);
		int rightHeight = getTreeHeight(head->_pRight);
		int result = abs(leftHeight - rightHeight);
		if(result > 1)
		{
			return false;
		}
		//返回两个子树是否平衡
		else
		{
			return isAVLTree(head->_pLeft) && isAVLTree(head->_pRight);
		}

*/

typedef struct TreeNode
{
	TreeNode():_value(-1),_height(-1),_pLeft(NULL),_pRight(NULL),_pParent(NULL){}
	int _value;
	int _height; //该节点距离树顶部的高度，第一层高度为1，默认初始化树的根节点高度为1
	//树中肯定包含左子树和右子树，还包括当前节点自身的值
	TreeNode* _pLeft;
	TreeNode* _pRight;
	TreeNode* _pParent; // 父节点，根节点的父节点为空，高度
	int _index; //创建的节点的下标
}TreeNode;

//关键就设置一个节点数组
const int MAXSIZE = 1001;
TreeNode g_treeNodeArray[MAXSIZE];
int g_index; //用于标示创建的节点的下标

//创建节点
TreeNode* createNode()
{
	//先使节点标记累加，初始化节点中左右孩子的值为NULL
	++g_index;
	g_treeNodeArray[g_index]._pLeft = g_treeNodeArray[g_index]._pRight = g_treeNodeArray[g_index]._pParent = NULL;
	return &g_treeNodeArray[g_index];
}



//获取当前节点高度，仍然是用递归做
int getHeight(TreeNode* pNode)
{
	//如果当前节点为空,高度为0? ，这个有问题，应该修改为如果当前节点为空，其高度等于其父节点高度
	//参见这种情况：一个父节点只有左孩子，父节点高度为h,左孩子高度则为h+1,如果把父节点的右孩子(实际为空)的高度设置为0，会有可能判断得出为非平衡树
	//此时应该设置空节点高度为其父节点高度，但不对，当前节点都为空了，怎么可能获取到父节点，只能在调用的地方控制，做非空检查，如果为空，就用其父节点计算其高度
	if(NULL == pNode)
	{
		return 0;
	}
	//记忆化搜索
	if(pNode->_height != -1)
	{
		return pNode->_height;
	}
	//如果是遇到根节点，那么根节点对应高度为0
	else if(pNode->_pParent == NULL)
	{
		return 0;
	}
	else
	{
		return getHeight(pNode->_pParent) + 1;
	}
}

//获取树的顶点
TreeNode* getTreeHeadNode(TreeNode* pNode)
{
	//如果当前传入的节点为空，就直接返回该树的顶点为空
	if(NULL == pNode)
	{
		return NULL;
	}

	//根据树的顶点没有父节点，因此如果某个节点的父节点为空，该节点就是树的顶点
	if(NULL == pNode->_pParent)
	{
		return pNode;
	}
	return getTreeHeadNode(pNode->_pParent);
}

//其实是计算左子树高度和右子树高度，而不是左孩子和右孩子高度;这个函数作用是计算以pNode为顶点的树的高度（左右子树中的较大值）
int getTreeHeight(TreeNode* pNode)
{
	if(NULL == pNode)
	{
		return 0;
	}
	int leftHeight = getTreeHeight(pNode->_pLeft) + 1;
	int rightHeight = getTreeHeight(pNode->_pRight) + 1;
	int height = leftHeight > rightHeight ? leftHeight : rightHeight;
	return height;
}

bool isAVLTree(TreeNode* head)
{
	//如果还树为空，一定是平衡的
	if(NULL == head)
	{
		return true;
	}
	//如果左子树和右子树都不空，那么需要判断两者的高度之差是否<=1，并且两颗子树都需要平衡，必须要记录高度
	else
	{
		int leftHeight= getTreeHeight(head->_pLeft);
		int rightHeight = getTreeHeight(head->_pRight);
		int result = abs(leftHeight - rightHeight);
		if(result > 1)
		{
			return false;
		}
		//返回两个子树是否平衡
		else
		{
			return isAVLTree(head->_pLeft) && isAVLTree(head->_pRight);
		}
	}
}

int main(int argc, char* argv[])
{
	int nodeNum;
	int value;
	string childFlag;
	int leftChild;
	int rightChild;
	while(cin >> nodeNum)
	{
		g_index = 0;

		//输入n个树节点对应的值，实际上就是创建节点
		for(int i = 0 ; i < nodeNum ; i++)
		{
			cin >> value;
			TreeNode* pNode = createNode();
			pNode->_value = value;
		}

		//接下来就是对n个节点的孩子节点进行赋值
		for(int i = 1 ; i <= nodeNum ; i++)
		{
			cin >> childFlag;
			if("d" == childFlag)
			{
				cin >> leftChild >> rightChild;
				g_treeNodeArray[i]._pLeft = &g_treeNodeArray[leftChild];
				g_treeNodeArray[i]._pRight = &g_treeNodeArray[rightChild];

				//注意设置父节点的指向,否则无法从任意节点推算根节点
				g_treeNodeArray[leftChild]._pParent = &g_treeNodeArray[i];
				g_treeNodeArray[rightChild]._pParent = &g_treeNodeArray[i];
			}
			else if("l" == childFlag)
			{
				cin >> leftChild;
				g_treeNodeArray[i]._pLeft = &g_treeNodeArray[leftChild];
				g_treeNodeArray[leftChild]._pParent = &g_treeNodeArray[i];
			}
			else if("r" == childFlag)
			{
				cin >> rightChild;
				g_treeNodeArray[i]._pRight = &g_treeNodeArray[rightChild];
				g_treeNodeArray[rightChild]._pParent = &g_treeNodeArray[i];
			}
			//没有孩子节点无需处理
			else if("z" == childFlag)
			{

			}
			else
			{
				cout << "command is error!" << endl;
			}
		}

		//获取树的顶点
		TreeNode* pHead = getTreeHeadNode( &g_treeNodeArray[1] );

		//高度验证正确后，判断平衡树就可以了
		bool isAVL = isAVLTree(pHead);
		if(isAVL)
		{
			cout << "Is AVL Tree!" << endl;
		}
		else
		{
			cout << "Not AVL Tree!" << endl;
		}
	}
	getchar();
	return 0;
}