5-6 笛卡尔树 (25分)

最新推荐文章于 2021-07-13 21:06:54 发布

原创最新推荐文章于 2021-07-13 21:06:54 发布 · 1.9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #acm #BST #二叉搜索树

数据结构同时被 3 个专栏收录

27 篇文章

订阅专栏

PTA_Accept

12 篇文章

订阅专栏

BST

5 篇文章

订阅专栏

本文介绍了一种用于判断给定二叉树是否为笛卡尔树的算法。笛卡尔树需同时满足二叉搜索树和最小堆的性质。通过中序遍历检查K1值的顺序及比较各节点K2值来完成验证。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

5-6 笛卡尔树 (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

思路：

BST的满足键值判断，要依据中序遍历是否有序。。。完了，明天期中要炸，233333

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int pre[1010];
struct BST{
    int left;
    int right;
    int k1;
    int k2;
}q[1010];

int flag;

void Judge(int num)
{
    int left,right;
    if(!flag)
        return;
    if(q[num].left!=-1)
    {
        left=q[num].left;
        if(q[left].k2<q[num].k2)
        {
            flag=0;
            return;
        }
        Judge(left);
    }
    if(q[num].right!=-1)
    {
        right=q[num].right;
        if(q[right].k2<q[num].k2)
        {
            flag=0;
            return;
        }
        Judge(right);
    }
}

int bb[1010],aa[1010];
int num_b;
void inorder(int num)
{
    if(num==-1)
        return;
    inorder(q[num].left);
    aa[num_b]=bb[num_b]=q[num].k1;
    num_b++;
    inorder(q[num].right);
}

int main()
{
    int n,k1,k2,left,right;
    memset(pre,0,sizeof(pre));
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d%d%d%d",&k1,&k2,&left,&right);
        q[i].k1=k1;
        q[i].k2=k2;
        q[i].left=left;
        q[i].right=right;
        if(left!=-1)
            pre[left]++;
        if(right!=-1)
            pre[right]++;
    }
    int root;
    for(int i=0;i<n;i++)
    {
        if(!pre[i])
        {
            root=i;
            break;
        }
    }
    flag=1;
    Judge(root);
    num_b=0;
    inorder(root);
    for(int i=0;i<num_b;i++)
    {
        for(int j=i+1;j<num_b;j++)
        {
            if(aa[j]<aa[j-1])
            {
                int temp=aa[j-1];
                aa[j-1]=aa[j];
                aa[j]=temp;
            }
        }
    }
    for(int i=0;i<num_b;i++)
    {
        if(aa[i]!=bb[i])
        {
            flag=0;
            break;
        }
    }
    if(flag)
        puts("YES");
    else
        puts("NO");

    return 0;
}