feat: add solutions for lc No.3873

Author: yanglbme

solution/3800-3899/3873.Maximum Points Activated with One Addition/README.md

@@ -101,32 +101,334 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3873.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：并查集
+
+我们可以使用并查集来解决这个问题。
+
+首先，我们将所有点的 $x$ 坐标和 $y$ 坐标进行映射，使得它们在同一个并查集中。具体来说，我们可以将 $y$ 坐标加上一个足够大的常数 $m$（例如 $3 \times 10^9$），以确保 $x$ 和 $y$ 坐标不会发生冲突。
+
+接下来，我们遍历所有点，将具有相同 $x$ 坐标或 $y$ 坐标的点进行合并。这样，具有相同 $x$ 或 $y$ 坐标的点就会被分到同一个集合中。
+
+最后，我们统计每个集合中的点数，并找到最大的两个集合的大小。由于我们可以添加一个新的点来连接这两个集合，因此最终的答案就是这两个集合的大小之和再加上 1。
+
+时间复杂度 $O(n \alpha(n))$，其中 $n$ 是点的数量，而 $\alpha$ 是阿克曼函数的反函数。空间复杂度 $O(n)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class UnionFind:
+    def __init__(self):
+        self.p = {}
+        self.size = {}
+
+    def find(self, x):
+        if x not in self.p:
+            self.p[x] = x
+            self.size[x] = 1
+        if self.p[x] != x:
+            self.p[x] = self.find(self.p[x])
+        return self.p[x]
+
+    def union(self, a, b):
+        pa, pb = self.find(a), self.find(b)
+        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 maxActivated(self, points: List[List[int]]) -> int:
+        uf = UnionFind()
+        m = int(3e9)
+
+        for x, y in points:
+            uf.union(x, y + m)
+
+        cnt = Counter()
+        for x, _ in points:
+            cnt[uf.find(x)] += 1
+
+        mx1 = mx2 = 0
+        for x in cnt.values():
+            if mx1 < x:
+                mx2 = mx1
+                mx1 = x
+            elif mx2 < x:
+                mx2 = x
+        return mx1 + mx2 + 1
 ```
 
 #### Java
 
 ```java
-
+class UnionFind {
+    Map<Long, Long> p = new HashMap<>();
+    Map<Long, Integer> size = new HashMap<>();
+
+    long find(long x) {
+        if (!p.containsKey(x)) {
+            p.put(x, x);
+            size.put(x, 1);
+        }
+        if (p.get(x) != x) {
+            p.put(x, find(p.get(x)));
+        }
+        return p.get(x);
+    }
+
+    boolean union(long a, long b) {
+        long pa = find(a), pb = find(b);
+        if (pa == pb) {
+            return false;
+        }
+
+        int sa = size.get(pa), sb = size.get(pb);
+        if (sa > sb) {
+            p.put(pb, pa);
+            size.put(pa, sa + sb);
+        } else {
+            p.put(pa, pb);
+            size.put(pb, sa + sb);
+        }
+        return true;
+    }
+}
+
+class Solution {
+    public int maxActivated(int[][] points) {
+        UnionFind uf = new UnionFind();
+        long m = (long) 3e9;
+
+        for (int[] p : points) {
+            uf.union(p[0], p[1] + m);
+        }
+
+        Map<Long, Integer> cnt = new HashMap<>();
+        for (int[] p : points) {
+            cnt.merge(uf.find(p[0]), 1, Integer::sum);
+        }
+
+        int mx1 = 0, mx2 = 0;
+        for (int x : cnt.values()) {
+            if (mx1 < x) {
+                mx2 = mx1;
+                mx1 = x;
+            } else if (mx2 < x) {
+                mx2 = x;
+            }
+        }
+
+        return mx1 + mx2 + 1;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class UnionFind {
+public:
+    unordered_map<long long, long long> p;
+    unordered_map<long long, int> sz;
+
+    long long find(long long x) {
+        if (!p.count(x)) {
+            p[x] = x;
+            sz[x] = 1;
+        }
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+    bool unite(long long a, long long b) {
+        long long pa = find(a), pb = find(b);
+        if (pa == pb) return false;
+
+        if (sz[pa] > sz[pb]) {
+            p[pb] = pa;
+            sz[pa] += sz[pb];
+        } else {
+            p[pa] = pb;
+            sz[pb] += sz[pa];
+        }
+        return true;
+    }
+};
+
+class Solution {
+public:
+    int maxActivated(vector<vector<int>>& points) {
+        UnionFind uf;
+        long long m = (long long) 3e9;
+
+        for (auto& p : points) {
+            uf.unite(p[0], p[1] + m);
+        }
+
+        unordered_map<long long, int> cnt;
+        for (auto& p : points) {
+            long long root = uf.find(p[0]);
+            cnt[root]++;
+        }
+
+        int mx1 = 0, mx2 = 0;
+        for (auto& [_, x] : cnt) {
+            if (mx1 < x) {
+                mx2 = mx1;
+                mx1 = x;
+            } else if (mx2 < x) {
+                mx2 = x;
+            }
+        }
+
+        return mx1 + mx2 + 1;
+    }
+};
 ```
 
 #### Go
 
 ```go
+type UnionFind struct {
+	p    map[int64]int64
+	size map[int64]int
+}
+
+func NewUnionFind() *UnionFind {
+	return &UnionFind{
+		p:    map[int64]int64{},
+		size: map[int64]int{},
+	}
+}
+
+func (uf *UnionFind) find(x int64) int64 {
+	if _, ok := uf.p[x]; !ok {
+		uf.p[x] = x
+		uf.size[x] = 1
+	}
+	if uf.p[x] != x {
+		uf.p[x] = uf.find(uf.p[x])
+	}
+	return uf.p[x]
+}
+
+func (uf *UnionFind) union(a, b int64) bool {
+	pa, pb := uf.find(a), uf.find(b)
+	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 maxActivated(points [][]int) int {
+	uf := NewUnionFind()
+	m := int64(3e9)
+
+	for _, p := range points {
+		uf.union(int64(p[0]), int64(p[1])+m)
+	}
+
+	cnt := map[int64]int{}
+	for _, p := range points {
+		root := uf.find(int64(p[0]))
+		cnt[root]++
+	}
+
+	mx1, mx2 := 0, 0
+	for _, x := range cnt {
+		if mx1 < x {
+			mx2 = mx1
+			mx1 = x
+		} else if mx2 < x {
+			mx2 = x
+		}
+	}
+
+	return mx1 + mx2 + 1
+}
+```
 
+#### TypeScript
+
+```ts
+class UnionFind {
+    p: Map<number, number> = new Map();
+    size: Map<number, number> = new Map();
+
+    find(x: number): number {
+        if (!this.p.has(x)) {
+            this.p.set(x, x);
+            this.size.set(x, 1);
+        }
+        if (this.p.get(x)! !== x) {
+            this.p.set(x, this.find(this.p.get(x)!));
+        }
+        return this.p.get(x)!;
+    }
+
+    union(a: number, b: number): boolean {
+        const pa = this.find(a);
+        const pb = this.find(b);
+        if (pa === pb) return false;
+
+        const sa = this.size.get(pa)!;
+        const sb = this.size.get(pb)!;
+
+        if (sa > sb) {
+            this.p.set(pb, pa);
+            this.size.set(pa, sa + sb);
+        } else {
+            this.p.set(pa, pb);
+            this.size.set(pb, sa + sb);
+        }
+        return true;
+    }
+}
+
+function maxActivated(points: number[][]): number {
+    const uf = new UnionFind();
+    const m = 3e9;
+
+    for (const [x, y] of points) {
+        uf.union(x, y + m);
+    }
+
+    const cnt = new Map<number, number>();
+    for (const [x] of points) {
+        const root = uf.find(x);
+        cnt.set(root, (cnt.get(root) ?? 0) + 1);
+    }
+
+    let mx1 = 0,
+        mx2 = 0;
+    for (const x of cnt.values()) {
+        if (mx1 < x) {
+            mx2 = mx1;
+            mx1 = x;
+        } else if (mx2 < x) {
+            mx2 = x;
+        }
+    }
+
+    return mx1 + mx2 + 1;
+}
 ```
 
 <!-- tabs:end -->