#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;
}