feat: add solutions to lc problem: No.1101 (#2049)

No.1101.The Earliest Moment When Everyone Become Friends

Author: yanglbme

solution/1100-1199/1101.The Earliest Moment When Everyone Become Friends/README.md

@@ -89,36 +89,38 @@ class Solution:
 
 ```python
 class UnionFind:
+    __slots__ = ('p', 'size')
+
     def __init__(self, n):
         self.p = list(range(n))
         self.size = [1] * n
 
-    def find(self, x):
+    def find(self, x: int) -> int:
         if self.p[x] != x:
             self.p[x] = self.find(self.p[x])
         return self.p[x]
 
-    def union(self, a, b):
+    def union(self, a: int, b: int) -> bool:
         pa, pb = self.find(a), self.find(b)
-        if pa != pb:
-            if self.size[pa] > self.size[pb]:
-                self.p[pb] = pa
-                self.size[pa] += self.size[pb]
-            else:
-                self.p[pa] = pb
-                self.size[pb] += self.size[pa]
+        if pa == pb:
+            return False
+        if self.size[pa] > self.size[pb]:
+            self.p[pb] = pa
+            self.size[pa] += self.size[pb]
+        else:
+            self.p[pa] = pb
+            self.size[pb] += self.size[pa]
+        return True
 
 
 class Solution:
     def earliestAcq(self, logs: List[List[int]], n: int) -> int:
         uf = UnionFind(n)
         for t, x, y in sorted(logs):
-            if uf.find(x) == uf.find(y):
-                continue
-            uf.union(x, y)
-            n -= 1
-            if n == 1:
-                return t
+            if uf.union(x, y):
+                n -= 1
+                if n == 1:
+                    return t
         return -1
 ```
 
@@ -179,17 +181,19 @@ class UnionFind {
         return p[x];
     }
 
-    public void union(int a, int b) {
+    public boolean union(int a, int b) {
         int pa = find(a), pb = find(b);
-        if (pa != pb) {
-            if (size[pa] > size[pb]) {
-                p[pb] = pa;
-                size[pa] += size[pb];
-            } else {
-                p[pa] = pb;
-                size[pb] += size[pa];
-            }
+        if (pa == pb) {
+            return false;
+        }
+        if (size[pa] > size[pb]) {
+            p[pb] = pa;
+            size[pa] += size[pb];
+        } else {
+            p[pa] = pb;
+            size[pb] += size[pa];
         }
+        return true;
     }
 }
 
@@ -199,11 +203,7 @@ class Solution {
         UnionFind uf = new UnionFind(n);
         for (int[] log : logs) {
             int t = log[0], x = log[1], y = log[2];
-            if (uf.find(x) == uf.find(y)) {
-                continue;
-            }
-            uf.union(x, y);
-            if (--n == 1) {
+            if (uf.union(x, y) && --n == 1) {
                 return t;
             }
         }
@@ -249,17 +249,19 @@ public:
         iota(p.begin(), p.end(), 0);
     }
 
-    void unite(int a, int b) {
+    bool unite(int a, int b) {
         int pa = find(a), pb = find(b);
-        if (pa != pb) {
-            if (size[pa] > size[pb]) {
-                p[pb] = pa;
-                size[pa] += size[pb];
-            } else {
-                p[pa] = pb;
-                size[pb] += size[pa];
-            }
+        if (pa == pb) {
+            return false;
         }
+        if (size[pa] > size[pb]) {
+            p[pb] = pa;
+            size[pa] += size[pb];
+        } else {
+            p[pa] = pb;
+            size[pb] += size[pa];
+        }
+        return true;
     }
 
     int find(int x) {
@@ -280,11 +282,7 @@ public:
         UnionFind uf(n);
         for (auto& log : logs) {
             int t = log[0], x = log[1], y = log[2];
-            if (uf.find(x) == uf.find(y)) {
-                continue;
-            }
-            uf.unite(x, y);
-            if (--n == 1) {
+            if (uf.unite(x, y) && --n == 1) {
                 return t;
             }
         }
@@ -346,37 +344,174 @@ func (uf *unionFind) find(x int) int {
 	return uf.p[x]
 }
 
-func (uf *unionFind) union(a, b int) {
+func (uf *unionFind) union(a, b int) bool {
 	pa, pb := uf.find(a), uf.find(b)
-	if pa != pb {
-		if uf.size[pa] > uf.size[pb] {
-			uf.p[pb] = pa
-			uf.size[pa] += uf.size[pb]
-		} else {
-			uf.p[pa] = pb
-			uf.size[pb] += uf.size[pa]
-		}
+	if pa == pb {
+		return false
+	}
+	if uf.size[pa] > uf.size[pb] {
+		uf.p[pb] = pa
+		uf.size[pa] += uf.size[pb]
+	} else {
+		uf.p[pa] = pb
+		uf.size[pb] += uf.size[pa]
 	}
+	return true
 }
 
 func earliestAcq(logs [][]int, n int) int {
 	sort.Slice(logs, func(i, j int) bool { return logs[i][0] < logs[j][0] })
 	uf := newUnionFind(n)
 	for _, log := range logs {
 		t, x, y := log[0], log[1], log[2]
-		if uf.find(x) == uf.find(y) {
-			continue
-		}
-		uf.union(x, y)
-		n--
-		if n == 1 {
-			return t
+		if uf.union(x, y) {
+			n--
+			if n == 1 {
+				return t
+			}
 		}
 	}
 	return -1
 }
 ```
 
+### **TypeScript**
+
+```ts
+function earliestAcq(logs: number[][], n: number): number {
+    const p: number[] = Array(n)
+        .fill(0)
+        .map((_, i) => i);
+    const find = (x: number): number => {
+        if (p[x] !== x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    };
+    logs.sort((a, b) => a[0] - b[0]);
+    for (const [t, x, y] of logs) {
+        const rx = find(x);
+        const ry = find(y);
+        if (rx !== ry) {
+            p[rx] = ry;
+            if (--n === 1) {
+                return t;
+            }
+        }
+    }
+    return -1;
+}
+```
+
+```ts
+class UnionFind {
+    private p: number[];
+    private size: number[];
+
+    constructor(n: number) {
+        this.p = Array(n)
+            .fill(0)
+            .map((_, i) => i);
+        this.size = Array(n).fill(1);
+    }
+
+    find(x: number): number {
+        if (this.p[x] !== x) {
+            this.p[x] = this.find(this.p[x]);
+        }
+        return this.p[x];
+    }
+
+    union(a: number, b: number): boolean {
+        const pa = this.find(a);
+        const pb = this.find(b);
+        if (pa === pb) {
+            return false;
+        }
+        if (this.size[pa] > this.size[pb]) {
+            this.p[pb] = pa;
+            this.size[pa] += this.size[pb];
+        } else {
+            this.p[pa] = pb;
+            this.size[pb] += this.size[pa];
+        }
+        return true;
+    }
+}
+
+function earliestAcq(logs: number[][], n: number): number {
+    logs.sort((a, b) => a[0] - b[0]);
+    const uf = new UnionFind(n);
+    for (const [t, x, y] of logs) {
+        if (uf.union(x, y) && --n === 1) {
+            return t;
+        }
+    }
+    return -1;
+}
+```
+
+### **Rust**
+
+```rust
+struct UnionFind {
+    p: Vec<usize>,
+    size: Vec<usize>,
+}
+
+impl UnionFind {
+    fn new(n: usize) -> Self {
+        let p: Vec<usize> = (0..n).collect();
+        let size = vec![1; n];
+        UnionFind { p, size }
+    }
+
+    fn find(&mut self, x: usize) -> usize {
+        if self.p[x] != x {
+            self.p[x] = self.find(self.p[x]);
+        }
+        self.p[x]
+    }
+
+    fn union(&mut self, a: usize, b: usize) -> bool {
+        let pa = self.find(a);
+        let pb = self.find(b);
+        if pa == pb {
+            false
+        } else if self.size[pa] > self.size[pb] {
+            self.p[pb] = pa;
+            self.size[pa] += self.size[pb];
+            true
+        } else {
+            self.p[pa] = pb;
+            self.size[pb] += self.size[pa];
+            true
+        }
+    }
+}
+
+impl Solution {
+    pub fn earliest_acq(logs: Vec<Vec<i32>>, n: i32) -> i32 {
+        let mut logs = logs;
+        logs.sort_by(|a, b| a[0].cmp(&b[0]));
+        let mut uf = UnionFind::new(n as usize);
+        let mut n = n;
+        for log in logs {
+            let t = log[0];
+            let x = log[1] as usize;
+            let y = log[2] as usize;
+            if uf.union(x, y) {
+                n -= 1;
+                if n == 1 {
+                    return t;
+                }
+            }
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```