浙大PAT 4-09. 笛卡尔树 （解题思路）

4-09. 笛卡尔树

时间限制

400 ms

内存限制

32000 kB

代码长度限制

8000 B

判题程序

Standard

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

输入格式说明：

输入首先给出正整数N（<=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	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	NO
3	7 8 27 5 1 9 40 -1 -1 10 20 0 3 12 22 -1 4 15 21 6 -1 5 35 -1 -1 13 23 -1 -1	NO
4	6 8 27 5 1 9 40 -1 -1 10 20 0 3 12 21 -1 4 11 22 –1 -1 5 35 -1 -1	NO
5	9 11 5 3 -1 15 3 4 7 5 2 6 0 6 8 -1 -1 9 6 -1 8 10 1 2 1 2 4 -1 -1 20 7 -1 -1 12 9 -1 -1	NO
6	1 1 1 -1 -1	YES

---

//二叉排序树的中序遍历一定是一个从小到大排序的数组，判断是否是二叉树的时候分了2步， 先得到中序的数组然后来进行判断。方法有点笨。
//二叉搜索树如果直接用递归判断左右是否满足大小关系，则可能会出错，正确的方法是中序遍历判断是否是一个有序数组。

[cpp]  view plain  copy

 

1. #include <iostream>  
2. #include <deque>  
3. using namespace std;  
4.   
5. typedef struct  
6. {  
7.     int K1;  
8.     int K2;  
9.     int lChild;  
10.     int rChild;  
11. }BNode;  
12.   
13. deque<BNode> de;  
14.   
15. deque<int> tde;  
16.   
17. bool a[1005] = {false};  
18.   
19. int sum = 0;  
20.   
21. void PreTraval(BNode root)  
22. {  
23.     if(root.lChild != -1)  
24.         PreTraval(de[root.lChild]);  
25.     tde.push_back(root.K1);  
26.     if(root.rChild != -1)  
27.         PreTraval(de[root.rChild]);  
28. }  
29.   
30. bool IsSDD(BNode root)  
31. {  
32.     if(root.lChild == -1 && root.rChild == -1)  
33.         return true;  
34.     else if(root.lChild == -1 && root.rChild != -1)  
35.     {  
36.         if(de[root.rChild].K2 > root.K2)  
37.             return IsSDD(de[root.rChild]);  
38.         else  
39.             return false;  
40.     }  
41.     else if(root.lChild != -1 && root.rChild == -1)  
42.     {  
43.         if(de[root.lChild].K2 > root.K2)  
44.             return IsSDD(de[root.lChild]);  
45.         else  
46.             return false;  
47.     }  
48.     else  
49.     {  
50.         if(root.K2 < de[root.lChild].K2 && root.K2 < de[root.rChild].K2)  
51.             return IsSDD(de[root.lChild]) && IsSDD(de[root.rChild]);  
52.         else  
53.             return false;  
54.     }  
55. }  
56.   
57. bool IsBST()  
58. {  
59.     for(int i = 1; i < tde.size(); ++i)  
60.     {  
61.         if(tde[i] <= tde[i-1])  
62.             return false;  
63.     }  
64.     return true;  
65. }  
66.   
67.   
68. int main()  
69. {  
70.     int n;  
71.     cin>>n;  
72.     while(n--)  
73.     {  
74.         BNode tn;  
75.         scanf("%d%d%d%d", &tn.K1, &tn.K2, &tn.lChild, &tn.rChild);  
76.     //  cin>>tn.K1>>tn.K2>>tn.lChild>>tn.rChild;  
77.         if(tn.lChild >= 0)  
78.             a[tn.lChild] = true;  
79.         if(tn.rChild >= 0)  
80.             a[tn.rChild] = true;  
81.         de.push_back(tn);  
82.     }  
83.     int rootIndex = 0;  
84.     for(int i = 0; i < de.size(); ++i)  
85.         if(!a[i])  
86.         {  
87.             rootIndex = i;  
88.             break;  
89.         }  
90.     PreTraval(de[rootIndex]);  
91.   
92.   
93.     if(IsBST() && IsSDD(de[rootIndex]))  
94.         cout<<"YES"<<endl;  
95.     else  
96.         cout<<"NO"<<endl;  
97.     return 0;  
98. }