PTA 7-31 笛卡尔树（BST+Heap）

本题考点：

• 二叉搜索树和堆性质的应用

笛卡尔树是一种特殊的二叉树，其结点包含两个关键字K1和K2。首先笛卡尔树是关于K1的二叉搜索树，即结点左子树的所有K1值都比该结点的K1值小，右子树则大。其次所有结点的K2关键字满足优先队列（不妨设为最小堆）的顺序要求，即该结点的K2值比其子树中所有结点的K2值小。给定一棵二叉树，请判断该树是否笛卡尔树。
输入格式
输入首先给出正整数N（≤1000），为树中结点的个数。随后N行，每行给出一个结点的信息，包括：结点的K1值、K2值、左孩子结点编号、右孩子结点编号。设结点从0~(N-1)顺序编号。若某结点不存在孩子结点，则该位置给出−1。
输出格式
输出YES如果该树是一棵笛卡尔树；否则输出NO。

采用静态树保存树的信息，同时记录读取树的根结点信息。

二叉搜索树的判定：

• 一颗二叉搜索树的中序遍历应该是一个不减序列，所以可以采用中序遍历的方式来进行

堆的判定

• 最小值堆的判定可以采用递归的方式来进行，当前结点比它的两个子树的值要更小

完整代码如下：

#include <iostream>
#include <vector>
using namespace std;

const int maxn = 1010;

struct Node
{
    int k1, k2, left, right;
    Node(){}; // 如果要要用 trees，需要定义无参的构造方法
    Node(int _k1, int _k2, int _left, int _right) : k1(_k1), k2(_k2), left(_left), right(_right){};
} trees[maxn];

int root;
bool isRoot[maxn];
vector<int> orders;

bool JudgeHeap(int root); // 判断是否是最小值堆

void InOrder(int root)
{
    if(root == -1)
        return;
    InOrder(trees[root].left);
    orders.push_back(trees[root].k1);
    InOrder(trees[root].right);
}

int main()
{
    fill(isRoot, isRoot + maxn, true);
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    { // 结点从 0～n-1
        scanf("%d%d%d%d", &trees[i].k1, &trees[i].k2, &trees[i].left, &trees[i].right);
        if (trees[i].left >= 0)
            isRoot[trees[i].left] = false;
        if (trees[i].right >= 0)
            isRoot[trees[i].right] = false;
    }
    for (int i = 0; i < n; i++)
    { // 寻找根结点
        if (isRoot[i])
        {
            root = i;
            break;
        }
    }
    InOrder(root);

    bool isTree = true;
    for (int i = 0; i < n-1; i++)
    {
        if(orders[i+1] < orders[i]) {
            isTree = false;
            break;
        }
    }
    
    if (isTree && JudgeHeap(root))
        printf("YES");
    else
        printf("NO");
    return 0;
}

bool JudgeHeap(int root)
{
    int nowLeft = trees[root].left, nowRight = trees[root].right;
    int nowK2 = trees[root].k2; // 当前结点的 k2 值
    if (nowLeft == -1 && nowRight == -1)
        return true;
    if (nowLeft >= 0 && trees[nowLeft].k2 > nowK2 && nowRight == -1)
        return JudgeHeap(nowLeft);
    if (nowRight >= 0 && trees[nowRight].k2 > nowK2 && nowLeft == -1)
        return JudgeHeap(nowRight);
    if (nowLeft >= 0 && nowRight >= 0 && trees[nowLeft].k2 > nowK2 && trees[nowRight].k2 > nowK2)
        return JudgeHeap(nowLeft) && JudgeHeap(nowRight);
    return false;
}