1135 Is It A Red-Black Tree 甲级 xp_xht123

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

解题思路：首先先读题，红黑树有五个属性，关键的判断是有三点

第一点，从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点

        通过第一点的描述我们可以发现，任意一个节点到每个叶节点的黑色节点数目，其实可以表示为根节点到每一层的黑色节点数目相同，可以再建树的时候多加一个参数，进行对于左子树和右子树中总的黑色节点个数的计算

第二点，每个红色节点的两个子节点都是黑色

        通过读题可以发现，红色节点的value值是负的，黑色节点的value值是正的，所以到负数节点时需要进行判断叶节点是否是黑色的

第三点，根节点是黑色的 

以下是建树操作：

#include<iostream>
#include<algorithm>
#include<unordered_map>

using namespace std;
const int N = 40;
int t;
bool res = true;
struct Node
{
    int val = -1;
    Node*right = NULL;
    Node*left = NULL;
}v[N];
int per[N] , in[N];
unordered_map<int,int>mp;

Node* build(int il , int ir , int pl , int pr , int &sum)
{
    if(il > ir) return NULL;
    Node *root = new Node;
    root -> val = per[pl];
    int k = mp[abs(root -> val)];
    
    if(k < il || k > ir) 
    {
        res = false;
        return NULL;
    }
    
    int lsum = 0;//左子树的黑节点总数
    int rsum = 0;//右子树的黑节点总数
    int le = 0;
    int re = 0;
    if(il < k) root -> left = build(il , k - 1 , pl + 1 , k + pl - il , lsum);
    if(ir > k) root -> right = build(k + 1 , ir , pl - il + k + 1 , pr , rsum);
    
    if(lsum != rsum) res = false;//从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点
    
    sum = lsum;
    if(root && root -> val < 0)
    {//每个红色节点的两个子节点都是黑色
        
        if(root -> left) le = root -> left -> val;
        if(root -> right) re = root -> right -> val;
        if(le < 0 || re < 0) res = false;
    }
    else if(root && root -> val > 0) sum++;
    return root;
}

int main()
{
    cin>>t;
    while(t --)
    {
        int n;
        cin >> n;
        for(int i = 0;i < n;i ++)
        {
            cin >> per[i];
            in[i] = abs(per[i]);
        }
        
        mp.clear();
        
        sort(in , in + n);
        
        for(int i = 0;i < n;i ++) mp[in[i]] = i;
        
        int sum = 0;
        Node *root = build(0 , n - 1 , 0 , n - 1 , sum);
        
        if(root -> val < 0 && root) res = false;
        if(res) puts("Yes");
        else puts("No");
        res = true;
    }
    return 0;
}