PTA-数据结构 5-31 笛卡尔树 (25分)

笛卡尔树是一种特殊的二叉树，其结点包含两个关键字K1和K2。首先笛卡尔树是关于K1的二叉搜索树，即结点左子树的所有K1值都比该结点的K1值小，右子树则大。其次所有结点的K2关键字满足优先队列（不妨设为最小堆）的顺序要求，即该结点的K2值比其子树中所有结点的K2值小。给定一棵二叉树，请判断该树是否笛卡尔树。

输入格式:

输入首先给出正整数N（$\le$1000），为树中结点的个数。随后N行，每行给出一个结点的信息，包括：结点的K1值、K2值、左孩子结点编号、右孩子结点编号。设结点从0~(N-1)顺序编号。若某结点不存在孩子结点，则该位置给出$-1$。

输出格式:

输出YES如果该树是一棵笛卡尔树；否则输出NO。

输入样例1:

6
8 27 5 1
9 40 -1 -1
10 20 0 3
12 21 -1 4
15 22 -1 -1
5 35 -1 -1

输出样例1:

YES

输入样例2:

6
8 27 5 1
9 40 -1 -1
10 20 0 3
12 11 -1 4
15 22 -1 -1
50 35 -1 -1

输出样例2:

NO

思路分析：我第一次想法是直接进行BFS判断，因为BFS是按层遍历的嘛，，先判断当前结点是否满足BST结构，再判断当前结点是否满足最小堆。这种做法是错误的！！！正确的做法：判断是否满足BST应该根据中序遍历，看序列是否上升。判断最小堆可以根据BFS。

按照第一种方法，有一个case不过。为什么第一种做法是错误的呢？可以举个反例：

如上图，黑色是key1，红色是key2。结点定义为（key1, key2）按照第一种做法， 在判断左边（80，110）这个结点时，满足最小堆，也满足BST。但这棵树的中序序列是80、120、100、150。并不是升序的，所以是错误的。

为什么第一种做法是错的？因为在进行BSF层序遍历时，总是判断当前三个结点的情况是否满足BST结构，例如根结点出队时，判断的是根、根的左孩子、根的右孩子这三个结点。再进行到（80，120）这个结点时，判断的是（80，120）和左孩子NULL，和右孩子（120，130）这三个结点，显然这三个结点满足BST结构，但不一定满足整棵树的BST结构。所以这种策略是错误的，错误的原因是每次只能判断当前三个结点的BST结构。。

而用BFS遍历判断是否满足最小堆的策略是正确的，虽然每次出队也是判断当前的三个结点（根、根的左孩子、根的右孩子），但因为根据递推关系，根key2 < 根左key2 && 根key2 < 根右key2。在判断（80， 120）这个结点时，如果也有根key2 < 根左key2 && 根key2 < 根右key2这个关系，则（80， 120）这个结点的key2一定比上面所有层结点的key2值都大，所以用BFS判断最小堆这个策略是正确的。

AC代码：

#include <cstdio>
#include <queue>
#include <vector>

#define MAX 1000 + 10

using namespace std;

typedef struct {
    int key1;
    int key2;
    int left;
    int right;
} Node;

Node node[MAX];
int isRoot[MAX];
vector<int> vec;

bool bfs( int root ) {
    queue<Node> q;
    q.push( node[root] );

    bool flag = true;

    while( !q.empty() ) {
        if( !flag ) break;
        Node curNode = q.front();
        q.pop();

        int left = curNode.left;
        int right = curNode.right;

        /*
        // 先判断是否满足BST
        if( left != -1 && curNode.key1 <= node[left].key1 ) {
            flag = false;
        }
        if( right != -1 && curNode.key1 >= node[right].key1 ) {
            flag = false;
        }
        */

        // 再判断是否满足最小堆
        if( left != -1 && curNode.key2 >= node[left].key2 ) {
            flag = false;
        }
        if( right != -1 && curNode.key2 >= node[right].key2 ) {
            flag = false;
        }

        if( left != -1 ) q.push( node[left] );
        if( right != -1 ) q.push( node[right] );
    }

    /*
    if( flag ) printf( "YES\n" );
    else printf( "NO\n" );
    */

    return flag;
}

void dfsIn( int root ) {
    if( node[root].left != -1 ) dfsIn( node[root].left );
    vec.push_back( node[root].key1 );
    if( node[root].right != -1 ) dfsIn( node[root].right );
}

int main() {
    int n;
    scanf( "%d", &n );


    for( int i = 0; i < n; i++ ) {
        scanf( "%d%d%d%d", &node[i].key1, &node[i].key2,
                           &node[i].left, &node[i].right );
        if( node[i].left != -1 ) {
            isRoot[node[i].left] = 1;
        }
        if( node[i].right != -1 ) {
            isRoot[node[i].right] = 1;
        }
    }

    int root = -1;
    for( int i = 0; i < n; i++ ) {
        if( isRoot[i] == 0 ) {
            root = i;
            break;
        }
    }

    // 判断空树
    if( root == -1 ) {
        printf( "YES\n" );
        return 0;
    }

    bool flag = bfs( root );
    dfsIn( root );

    bool temp = true;
    for( int i = 0; i < n - 1; i++ ) {
        if( vec[i] > vec[i + 1] ) {
            temp = false;
            break;
        }
    }

    if( flag && temp ) printf( "YES" );
    else printf( "NO" );

    return 0;
}