Sunny Code1036笛卡尔树

                                             笛卡尔树

Case Time Limit: 100 MS (Others) / 200 MS (Java)       Case Memory Limit: 256 MB (Others) / 512 MB (Java)

 

Problem Description

对一棵二叉树来说，如果树上的每个结点有两个值K、V，满足
（1）以K为视角时这棵二叉树满足二叉查找树的性质，即对每个结点，左子树所有结点的K值小于该结点的K值小于右子树所有结点的K值；
（2）以V为视角时这棵二叉树满足堆的性质，即每个结点的V值都大于子树所有结点的V值（或都小于子树所有结点的V值）。
那么就称这棵二叉树是笛卡尔树。
（以上定义引自https://en.wikipedia.org/wiki/Cartesian_tree）

现在给定一棵二叉树，请判断其是否是笛卡尔树。

注意，笛卡尔树只是满足堆的性质，不代表一定是完全二叉树。

Input

每个输入文件一组数据。

第一行为一个正整数N（2<=N<=1024），表示二叉树上的结点数目。假设结点编号为从1到N。

第二行为N个正整数，表示1到N号结点的K值。数据保证每个值唯一，且不超过10000。

第三行为N个正整数，表示1到N号结点的V值。数据保证每个值唯一，且不超过10000。

接下来N行，按编号从1号到N号的顺序给出每个结点的子结点信息。每行两个整数，分别表示当前结点的左结点编号和右结点编号。如果左结点或右结点为空，则记为-1。

Output

如果该二叉树是笛卡尔树，那么输出第一行YES，然后在第二行输出MIN HEAP或者MAX HEAP，分别表示该笛卡尔树的V值满足小顶堆或大顶堆的性质。

如果该二叉树不是笛卡尔树，那么输出第一行NO，然后在第二行输出错误信息，即如果K值不满足二叉查找树的性质，那么输出NOT BST；如果V值不满足堆的性质，那么输出NOT HEAP；如果K值和V值都不满足，那么输出NOT BST AND NOT HEAP。

Sample Input 1

5
6 3 8 1 4
2 5 3 9 8
2 3
4 5
-1 -1
-1 -1
-1 -1

Sample Output 1

YES
MIN HEAP

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
struct Node
{
    int k,v,l,r;
}node[1025];
void judgebst(int root,vector<int> & v)
{
    if(root==-1)
        return;
    judgebst(node[root].l,v);
    v.push_back(node[root].k);
    judgebst(node[root].r,v);
}
void judgeMax(int root,bool &result)
{
    if(root==-1)
        return;
    if(node[root].l!=-1&&node[root].v < node[node[root].l].v)
    {
        result=false;
        return ;
    }
    if(node[root].r!=-1&&node[root].v < node[node[root].r].v)
    {
        result=false;
        return ;
    }
    judgeMax(node[root].l,result);
    judgeMax(node[root].r,result);
}
void judgeMin(int root,bool &result)
{
    if(root==-1)
        return;
    if(node[root].l!=-1&&node[root].v > node[node[root].l].v)
    {
        result=false;
        return ;
    }
    if(node[root].r!=-1&&node[root].v > node[node[root].r].v)
    {
        result=false;
        return ;
    }
    judgeMin(node[root].l,result);
    judgeMin(node[root].r,result);
}
int main()
{
    int n,root,l,r;
    bool vis[1025]={false};
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>node[i].k;
    for(int i=1;i<=n;i++)
        cin>>node[i].v;
    for(int i=1;i<=n;i++)
    {
        cin>>node[i].l>>node[i].r;
        if(node[i].l!=-1)
            vis[node[i].l]=true;
        if(node[i].r!=-1)
            vis[node[i].r]=true;
    }
    for(int i=1;i<=n;i++)
        if(vis[i]==false)
            root=i;
    vector<int> v;
    int f=0;
    judgebst(root,v);
    for(int i=1;i<v.size();i++)
        if(v[i-1] >v[i])
            f=1;
    if(f==0)
    {
        bool result=true;
        judgeMax(root,result);
        if(result)
        {
            cout<<"YES"<<endl;
            cout<<"MAX HEAP"<<endl;
            return 0;
        }
        result=true;
        judgeMin(root,result);
        if(result)
        {
            cout<<"YES"<<endl;
            cout<<"MIN HEAP"<<endl;
            return 0;
        }
        cout<<"NO"<<endl;
        cout<<"NOT HEAP"<<endl;
    }
    else
    {
        cout<<"NO"<<endl;
        bool result=true;
        judgeMax(root,result);
        if(result)
        {
            cout<<"NOT BST"<<endl;
            return 0;
        }
        result=true;
        judgeMin(root,result);
        if(result)
        {
            cout<<"NOT BST"<<endl;
            return 0;
        }
        cout<<"NOT BST AND NOT HEAP"<<endl;
    }
    return 0;
}