PAT甲级 1135. Is It A Red-Black Tree (30) 建树+深搜

There is a kind of balanced binary search tree named red-black tree in the data structure. It has the following 5 properties:

(1) Every node is either red or black.
(2) The root is black.
(3) Every leaf (NULL) is black.
(4) If a node is red, then both its children are black.
(5) For each node, all simple paths from the node to descendant leaves contain the same number of black nodes.

For example, the tree in Figure 1 is a red-black tree, while the ones in Figure 2 and 3 are not.

Figure 1	Figure 2	Figure 3

For each given binary search tree, you are supposed to tell if it is a legal red-black tree.

Input Specification:

Each input file contains several test cases. The first line gives a positive integer K (<=30) which is the total number of cases. For each case, the first line gives a positive integer N (<=30), the total number of nodes in the binary tree. The second line gives the preorder traversal sequence of the tree. While all the keys in a tree are positive integers, we use negative signs to represent red nodes. All the numbers in a line are separated by a space. The sample input cases correspond to the trees shown in Figure 1, 2 and 3.

Output Specification:

For each test case, print in a line "Yes" if the given tree is a red-black tree, or "No" if not.

Sample Input:

3
9
7 -2 1 5 -4 -11 8 14 -15
9
11 -2 1 -7 5 -4 8 14 -15
8
10 -7 5 -6 8 15 -11 17

Sample Output:

Yes
No
No

题目大意：

题目中RB树的性质有五点：

1、每个节点是红色或黑色

2、根节点是黑色的（用正数表示，红色用负数表示）

3、每个叶子节点是黑色的（叶子节点指的是空节点（NULL），题目中的图上没有标明叶子节点）

4、红色节点的两个孩子节点都是黑色的（如果红色节点只有一个孩子节点，就不满足性质5了，自己可以想象一下）

5、每个节点（自己做根节点）到自己这颗树下的所有叶子节点经过的黑色结点数相同（这里从一整颗树的根搜就好，可以自己想象一下）

主要的几个判断不是红黑树的点：

1、根节点是红色节点的不是红黑树（不满足性质2）

2、红色节点的父节点是红色节点的不是红黑树（不满足性质4）

3、黑色结点的父节点的孩子节点只有一个的不是红黑树（不满足性质5）

4、从根节点到每个叶子节点经过的黑色节点数不同的不是红黑树（不满足性质5）

具体的方法，代码上有注释

#include <map>
#include <cstring>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <iostream>
#include <algorithm>
using namespace std;


const int MAXN = 1e2+ 10;
const int MAXM = 1e4 + 10;
const int INF = 0x7f7f7f7f;
int n, a[MAXN];
struct NODE{
    int data;
    int l, r;
}node[MAXN];
void Build_BST(int root, int pos){///建树
    if( abs(node[pos].data) < abs(node[root].data) ){///左子树
        if(node[root].l==-1) node[root].l=pos;
        else Build_BST(node[root].l, pos);
    }else{///右子树
        if(node[root].r==-1) node[root].r=pos;
        else Build_BST(node[root].r, pos);
    }
}

/*  叶子节点是最下面一层没有在图上显示出来的一层节点  */
int const_cnt, fist, flag;
void Dfs_5(int root, int cnt, int last){      ///cnt>0时当前节点才有父节点
    if(node[root].data>=0){        ///黑色结点
        if(cnt){                              ///黑色结点的父节点不能只有一个孩子节点
            if((node[last].l!=-1&&node[last].r==-1) || (node[last].r!=-1&&node[last].l==-1)) flag=false;
        }
        cnt++;
    }
    else{                          ///红色节点
        if(cnt){
            if(node[last].data<0) flag=false; ///红结点父节点不能是红结点
        }
    }
    if(node[root].l==-1 && node[root].r==-1){
        if(fist) const_cnt=cnt, fist=false;   ///第一次计数
        else{                                 ///剩下的次数比较和第一次计数是否相同
            if(cnt!=const_cnt) flag=false;
        }
    }
    if(node[root].l!=-1) Dfs_5(node[root].l, cnt, root);
    if(node[root].r!=-1) Dfs_5(node[root].r, cnt, root);
}
int main(){
    int case_;
    scanf("%d", &case_);
    while(case_--){
        for(int i=0; i<=MAXN; i++) node[i].l=node[i].r=-1;///初始化
        
        scanf("%d", &n);
        for(int i=0; i<n; i++){
            scanf("%d", &node[i].data);
            if(i!=0) Build_BST(0, i);
        }
        if(node[0].data<0) {printf("No\n");continue; }///根节点必须为黑色
        /*这下面的根节点肯定是黑色结点*/
        fist=flag=true;
        Dfs_5(0, 0, -1);

        if(flag) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}