LeetCode1361验证二叉树

方法一：连通性判定

我们将验证二叉树的过程分为两步：第一步找到二叉树的根节点，第二步从根节点开始对二叉树进行遍历，判断其是否为一颗有效的二叉树。

找根节点

在第一步中，为了找到根节点，我们需要用数组 indeg 存放所有节点的入度，这是因为只有入度为 0 的点才能是根节点。我们遍历数组 leftChild 和 rightChild，如果数组中的某个元素 x 不为 -1，那么就表示有一条边指向节点 x，节点 x 的入度 indeg[x] 增加 1。在遍历完数组 leftChild 和 rightChild 后，我们在数组 indeg 中找到一个满足 index[root] == 0 的节点 root，即为二叉树的根节点。

如果有多个满足 index[root] == 0 的节点呢？在这种情况下，这 n 个节点一定不是一颗有效的二叉树。我们把这个问题放在第二步来考虑，而在第一步中，我们先不处理这个问题。

bfs

在第二步中，我们从根节点开始进行深度优先搜索或广度优先搜索，判定这 n 个节点的连通性，这是因为当这个 n 个节点是一颗有效的二叉树时，所有的节点会恰好被遍历一次。如果某一个节点被遍历了超过一次（有不止一个父节点）或零次（不连通），那么这 n 个节点都不是一颗有效的二叉树。我们可以使用哈希集合（HashSet）seen 来存放所有被遍历过的节点，如果在搜索时遍历到了 seen 中出现的节点，那么说明该节点被遍历了超过一次。如果在搜索完成后，seen 中的节点个数少于 n，那么说明有些节点没有被遍历过。

回到第一步中遗留的那个问题，如果有多个满足 index[root] == 0 的节点 r1, r2, …，那么我们可以任意选择一个节点，例如 r1，作为根节点。在搜索时，由于节点 r2, … 的入度为 0，因此不可能被遍历到。这样在搜索结束后，seen 中的节点个数一定少于 n。

class Solution {
public:
    bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
        vector<int> indeg(n);
        for (int i = 0; i < n; ++i) {
            if (leftChild[i] != -1) {
                ++indeg[leftChild[i]];
            }
            if (rightChild[i] != -1) {
                ++indeg[rightChild[i]];
            }
        }

        int root = -1;
        for (int i = 0; i < n; ++i) {
            if (!indeg[i]) {
                root = i;
                break;
            }
        }
        if (root == -1) {
            return false;
        }

        unordered_set<int> seen;
        queue<int> q;
        seen.insert(root);
        q.push(root);

        while (!q.empty()) {
            int u = q.front();
            q.pop();
            if (leftChild[u] != -1) {
                if (seen.count(leftChild[u])) {
                    return false;
                }
                seen.insert(leftChild[u]);
                q.push(leftChild[u]);
            }
            if (rightChild[u] != -1) {
                if (seen.count(rightChild[u])) {
                    return false;
                }
                seen.insert(rightChild[u]);
                q.push(rightChild[u]);
            }
        }

        return seen.size() == n;
    }
};

方法一：连通性判定的另一种写法(dfs)

先通过统计各个节点的入度数，排除不满足上述入度数判断的情况

再从root开始扫一遍（下面我用的是dfs）之后判断是否所有的节点都被访问过。

class Solution {
    int[] leftChild, rightChild;
    boolean[] visited;
    public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        // 统计每个结点的父亲数：1. 若父亲数大于1则为false  2.若父亲数等于0的不是1个则为false
        int[] indegreeCnt = new int[n];
        for (int i = 0; i < n; i++) {
            if((leftChild[i] != -1 && ++indegreeCnt[leftChild[i]] > 1)
             || (rightChild[i] != -1 && ++indegreeCnt[rightChild[i]] > 1)) {
                return false;
            }
        }
        int root = -1;
        for (int i = 0; i < n; i++){
            if (indegreeCnt[i] == 0) {
                if (root != -1) {
                    return false;
                }
                root = i;
            }
        }

        // 上面的判断可以解决单个连通域的树判断、及部分多连通域情况
        // 例如下面的情况无法判断，需要再判断连通域的个数。从root一遍dfs之后，若存在结点未被访问说明多个连通域。
        // 1 <--- 0 <--->  2， 4 --->3
        this.leftChild = leftChild;
        this.rightChild = rightChild;
        visited = new boolean[n];
        dfs(root);
        for (boolean v: visited) {
            if (!v) {
                return false;
            }
        }
        return true;     
    }

    private void dfs(int v) { 
        if (v == -1) {
            return;
        }       
        visited[v] = true;
        dfs(leftChild[v]);
        dfs(rightChild[v]);
    }
}

方法二：并查集第一种写法

不需要先统计入度数和找root了，对孩子节点和父亲节点进行合并之前先判断一下：
该孩子节点是否已经有父亲了（不能有多个父亲）;
该孩子节点与父亲节点是否已经在一个连通域中（不能有环）。

class Solution {
    
    public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        UnionFind uf = new UnionFind(n);
        
        for (int i = 0; i < n; i++) {
            // 若i节点的孩子节点之前已经有父亲了，则false
            // 若i节点和孩子节点已经在同一个连通域里了，说明形成了环，则fasle
            if (leftChild[i] != -1) {
                if (uf.find(leftChild[i]) != leftChild[i] || uf.connected(i, leftChild[i])) {
                    return false;  
                }           
                //单连通，
                uf.union(leftChild[i],i);
            }

            if (rightChild[i] != -1) {
                if (uf.find(rightChild[i]) != rightChild[i] || uf.connected(i, rightChild[i])) {
                    return false;  
                } 
                //单连通
                uf.union(rightChild[i],i);
            }
        }
        // 最后判断一下连通域的数量
        return uf.size == 1;
    }
}


class UnionFind {
    int roots[];
    int size;

    public UnionFind(int n) {
        roots = new int[n];
        size = n;
        for (int i = 0; i < n; i++) {
            roots[i] = i;
        }
    }

    public int find(int i) {
        return i == roots[i]? i: (roots[i] = find(roots[i]));
    }

    public boolean connected(int p, int q) {
        return find(p) == find(q); 
    }

    public void union(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if(pRoot != qRoot) {
            roots[pRoot] = qRoot;
            size--;
        }    
    }

}

方法二：并查集第二种写法(推荐)

public class Solution {

    int[] p;

    int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        p = new int[n];
        for (int i = 0; i < n; i++) p[i] = i;

        for (int i = 0; i < n; i++) {
            // i->leftChild[i]
            int Left = leftChild[i];
            if (Left != -1) {
                int pa = find(i), pb = find(Left);
                if (pa == pb) return false; // 两个结点祖先相同
                else {
                    if (pb == Left)
                        p[pb] = pa;
                    else // 箭头指向的结点已经有别的结点指向了，如示例2：结点3
                        return false;
                }
            }

            int Right = rightChild[i];
            if (Right != -1) {
                int pa = find(i), pb = find(Right);
                if (pa == pb) return false;
                else {
                    if (pb == Right)
                        p[pb] = pa;
                    else
                        return false;
                }
            }
        }

        // 统计连通块个数
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (p[i] == i) ans++;
        }

        return ans == 1;
    }
}