feat: update solutions to lc problem: No.1361

No.1361.Validate Binary Tree Nodes

Author: yanglbme

solution/1300-1399/1361.Validate Binary Tree Nodes/README.md

@@ -62,73 +62,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-并查集。
+**方法一：并查集**
 
-模板 1——朴素并查集：
+我们可以遍历每个节点 $i$ 以及对应的左右孩子 $l$, $r$，用 $vis$ 数组记录节点是否有父节点：
 
-```python
-# 初始化，p存储每个点的父节点
-p = list(range(n))
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
-
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-```
+-   若孩子节点已存在父节点，说明有多个父亲，不满足条件，直接返回 `false`。
+-   若孩子节点与父节点已经处于同一个连通分量，说明会形成环，不满足条件，直接返回 `false`。
+-   否则，进行合并，并且将 $vis$ 数组对应位置置为 `true`，同时将连通分量个数减去 $1$。
 
-模板 2——维护 size 的并查集：
+遍历结束，判断并查集中连通分量个数是否为 $1$，若是返回 `true`，否则返回 `false`。
 
-```python
-# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
-p = list(range(n))
-size = [1] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
-
-# 合并a和b所在的两个集合
-if find(a) != find(b):
-    size[find(b)] += size[find(a)]
-    p[find(a)] = find(b)
-```
-
-模板 3——维护到祖宗节点距离的并查集：
-
-```python
-# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
-p = list(range(n))
-d = [0] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        t = find(p[x])
-        d[x] += d[p[x]]
-        p[x] = t
-    return p[x]
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-d[find(a)] = distance
-```
-
-对于本题，遍历每个节点 i 以及对应的左右孩子 l, r，用 vis 数组记录节点是否有父节点：
-
--   若孩子节点已存在父节点，说明有多个父亲，不满足条件，直接返回 false。
--   若孩子节点与父节点已经处于同一个连通分量，说明会形成环，不满足条件，直接返回 false。
--   否则，进行合并，并将节点 i 分别与 l, r 进行合并。
-
-遍历结束，判断连通分量个数是否为 1，若是返回 true，否则返回 false。
+时间复杂度 $O(n \times \alpha(n))$，空间复杂度 $O(n)$。其中 $n$ 为节点个数，而 $\alpha(n)$ 为阿克曼函数的反函数，即反阿克曼函数，其值小于 $5$。
 
 <!-- tabs:start -->
 
@@ -138,29 +82,24 @@ d[find(a)] = distance
 
 ```python
 class Solution:
-    def validateBinaryTreeNodes(self, n: int, leftChild: List[int], rightChild: List[int]) -> bool:
-        p = list(range(n))
-        vis = [False] * n
-
-        def find(x):
+    def validateBinaryTreeNodes(
+        self, n: int, leftChild: List[int], rightChild: List[int]
+    ) -> bool:
+        def find(x: int) -> int:
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
 
-        for i in range(n):
-            l, r = leftChild[i], rightChild[i]
-            if l != -1:
-                if vis[l] or find(i) == find(l):
-                    return False
-                p[find(i)] = find(l)
-                vis[l] = True
-                n -= 1
-            if r != -1:
-                if vis[r] or find(i) == find(r):
-                    return False
-                p[find(i)] = find(r)
-                vis[r] = True
-                n -= 1
+        p = list(range(n))
+        vis = [False] * n
+        for i, (a, b) in enumerate(zip(leftChild, rightChild)):
+            for j in (a, b):
+                if j != -1:
+                    if vis[j] or find(i) == find(j):
+                        return False
+                    p[find(i)] = find(j)
+                    vis[j] = True
+                    n -= 1
         return n == 1
 ```
 
@@ -174,27 +113,20 @@ class Solution {
 
     public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
         p = new int[n];
-        boolean[] vis = new boolean[n];
         for (int i = 0; i < n; ++i) {
             p[i] = i;
         }
-        for (int i = 0, t = n; i < t; ++i) {
-            int l = leftChild[i], r = rightChild[i];
-            if (l != -1) {
-                if (vis[l] || find(i) == find(l)) {
-                    return false;
-                }
-                vis[l] = true;
-                p[find(i)] = find(l);
-                --n;
-            }
-            if (r != -1) {
-                if (vis[r] || find(i) == find(r)) {
-                    return false;
+        boolean[] vis = new boolean[n];
+        for (int i = 0, m =  n; i < m; ++i) {
+            for (int j : new int[] {leftChild[i], rightChild[i]}) {
+                if (j != -1) {
+                    if (vis[j] || find(i) == find(j)) {
+                        return false;
+                    }
+                    p[find(i)] = find(j);
+                    vis[j] = true;
+                    --n;
                 }
-                vis[r] = true;
-                p[find(i)] = find(r);
-                --n;
             }
         }
         return n == 1;
@@ -214,76 +146,61 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<int> p;
-
     bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
-        p.resize(n);
-        for (int i = 0; i < n; ++i) p[i] = i;
-        vector<bool> vis(n, false);
-        for (int i = 0, t = n; i < t; ++i) {
-            int l = leftChild[i], r = rightChild[i];
-            if (l != -1) {
-                if (vis[l] || find(i) == find(l)) return false;
-                vis[l] = true;
-                p[find(i)] = find(l);
-                --n;
-            }
-            if (r != -1) {
-                if (vis[r] || find(i) == find(r)) return false;
-                vis[r] = true;
-                p[find(i)] = find(r);
-                --n;
+        int p[n];
+        iota(p, p + n, 0);
+        bool vis[n];
+        memset(vis, 0, sizeof(vis));
+        function<int(int)> find = [&](int x) {
+            return p[x] == x ? x : p[x] = find(p[x]);
+        };
+        for (int i = 0, m = n; i < m; ++i) {
+            for (int j : {leftChild[i], rightChild[i]}) {
+                if (j != -1) {
+                    if (vis[j] || find(i) == find(j)) {
+                        return false;
+                    }
+                    p[find(i)] = find(j);
+                    vis[j] = true;
+                    --n;
+                }
             }
         }
         return n == 1;
     }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
 };
 ```
 
 ### **Go**
 
 ```go
-var p []int
-
 func validateBinaryTreeNodes(n int, leftChild []int, rightChild []int) bool {
-	p = make([]int, n)
-	for i := 0; i < n; i++ {
+	p := make([]int, n)
+	for i := range p {
 		p[i] = i
 	}
-	vis := make([]bool, n)
-	for i, t := 0, n; i < t; i++ {
-		l, r := leftChild[i], rightChild[i]
-		if l != -1 {
-			if vis[l] || find(i) == find(l) {
-				return false
-			}
-			vis[l] = true
-			p[find(i)] = find(l)
-			n--
+	var find func(int) int
+	find = func(x int) int {
+		if p[x] != x {
+			p[x] = find(p[x])
 		}
-		if r != -1 {
-			if vis[r] || find(i) == find(r) {
-				return false
+		return p[x]
+	}
+	vis := make([]bool, n)
+	for i, a := range leftChild {
+		for _, j := range []int{a, rightChild[i]} {
+			if j != -1 {
+				if vis[j] || find(i) == find(j) {
+					return false
+				}
+				p[find(i)] = find(j)
+				vis[j] = true
+				n--
 			}
-			vis[r] = true
-			p[find(i)] = find(r)
-			n--
 		}
 	}
 	return n == 1
 }
-
-func find(x int) int {
-	if p[x] != x {
-		p[x] = find(p[x])
-	}
-	return p[x]
-}
 ```
 
 ### **...**