LeetCode 1361 Validate Binary Tree Nodes (并查集)

You have n binary tree nodes numbered from 0 to n - 1 where node i has two children leftChild[i] and rightChild[i], return true if and only if all the given nodes form exactly one valid binary tree.

If node i has no left child then leftChild[i] will equal -1, similarly for the right child.

Note that the nodes have no values and that we only use the node numbers in this problem.

Example 1:

Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1]
Output: true

Example 2:

Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,3,-1,-1]
Output: false

Example 3:

Input: n = 2, leftChild = [1,0], rightChild = [-1,-1]
Output: false

Example 4:

 

Input: n = 6, leftChild = [1,-1,-1,4,-1,-1], rightChild = [2,-1,-1,5,-1,-1]
Output: false

Constraints:

• 1 <= n <= 104
• leftChild.length == rightChild.length == n
• -1 <= leftChild[i], rightChild[i] <= n - 1

题目链接：https://leetcode.com/problems/validate-binary-tree-nodes/

题目大意：给二叉树的左右孩子节点编号，问是否是合法二叉树

题目分析：并查集判连通，点数等于边数加1，每个节点有不超过1个父节点，不超过2个子节点即可

8ms，时间击败49%

class Solution {
    
    class UFSet {
        int n;
        int[] fa;
        UFSet(int n) {
            this.n = n;
            this.fa = new int[n];
            for (int i = 0; i < n; i++) {
                fa[i] = i;
            }
        }
        
        int find(int x) {
            if (x == fa[x]) {
                return x;
            }
            fa[x] = find(fa[x]);
            return fa[x];
        }
        
        void union(int a, int b) {
            int r1 = find(a);
            int r2 = find(b);
            if (r1 != r2) {
                fa[r1] = r2;
            }
        }
    }
    
    public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        UFSet uf = new UFSet(n);
        int[] sonCnt = new int[n];
        int[] faCnt = new int[n];
        int m = 0;
        for (int i = 0; i < n; i++) {
            if (leftChild[i] != -1) {
                m++;
                sonCnt[i]++;
                faCnt[leftChild[i]]++;
                uf.union(leftChild[i], i);
            }
        }
        for (int i = 0; i < n; i++) {
            if (rightChild[i] != -1) {
                m++;
                sonCnt[i]++;
                faCnt[rightChild[i]]++;
                uf.union(rightChild[i], i);
            }
        }
        for (int i = 0; i < n; i++) {
            if (sonCnt[i] > 2 || faCnt[i] > 1) {
                return false;
            }
        }
        if (m != n - 1) {
            return false;
        }
        int rt = uf.find(0);
        for (int i = 1; i < n; i++) {
            if (uf.find(i) != rt) {
                return false;
            }
        }
        return true;
    }
}