feat: add solutions to lc problem: No.1562

No.1562.Find Latest Group of Size M

Author: yanglbme

solution/1500-1599/1562.Find Latest Group of Size M/README.md

@@ -69,22 +69,298 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：并查集**
+
+正向遍历 $arr$，利用并查集动态维护每组 $1$ 的长度。
+
+时间复杂度 $O(nlogn)$。
+
+类似题目：[2334. 元素值大于变化阈值的子数组](/solution/2300-2399/2334.Subarray%20With%20Elements%20Greater%20Than%20Varying%20Threshold/README.md)
+
+**方法二：动态维护区间端点的长度**
+
+我们其实并不需要去通过查找并查集来获取每个区间长度，我们只需要在每个区间端点处记录每个区间长度，由于合并的时候**只会访问区间端点**，所以合并区间的时候修改端点区间长度即可。
+
+时间复杂度 $O(n)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def findLatestStep(self, arr: List[int], m: int) -> int:
+        def find(x):
+            if p[x] != x:
+                p[x] = find(p[x])
+            return p[x]
+
+        def union(a, b):
+            pa, pb = find(a), find(b)
+            if pa == pb:
+                return
+            p[pa] = pb
+            size[pb] += size[pa]
+
+        n = len(arr)
+        if m == n:
+            return n
+        vis = [False] * n
+        p = list(range(n))
+        size = [1] * n
+        ans = -1
+        for i, v in enumerate(arr):
+            v -= 1
+            if v and vis[v - 1]:
+                if size[find(v - 1)] == m:
+                    ans = i
+                union(v, v - 1)
+            if v < n - 1 and vis[v + 1]:
+                if size[find(v + 1)] == m:
+                    ans = i
+                union(v, v + 1)
+            vis[v] = True
+        return ans
+```
 
+```python
+class Solution:
+    def findLatestStep(self, arr: List[int], m: int) -> int:
+        n = len(arr)
+        if m == n:
+            return n
+        cnt = [0] * (n + 2)
+        ans = -1
+        for i, v in enumerate(arr):
+            v -= 1
+            l, r = cnt[v - 1], cnt[v + 1]
+            if l == m or r == m:
+                ans = i
+            cnt[v - l] = cnt[v + r] = l + r + 1
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] p;
+    private int[] size;
+
+    public int findLatestStep(int[] arr, int m) {
+        int n = arr.length;
+        if (m == n) {
+            return n;
+        }
+        boolean[] vis = new boolean[n];
+        p = new int[n];
+        size = new int[n];
+        for (int i = 0; i < n; ++i) {
+            p[i] = i;
+            size[i] = 1;
+        }
+        int ans = -1;
+        for (int i = 0; i < n; ++i) {
+            int v = arr[i] - 1;
+            if (v > 0 && vis[v - 1]) {
+                if (size[find(v - 1)] == m) {
+                    ans = i;
+                }
+                union(v, v - 1);
+            }
+            if (v < n - 1 && vis[v + 1]) {
+                if (size[find(v + 1)] == m) {
+                    ans = i;
+                }
+                union(v, v + 1);
+            }
+            vis[v] = true;
+        }
+        return ans;
+    }
+
+    private int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+    private void union(int a, int b) {
+        int pa = find(a), pb = find(b);
+        if (pa == pb) {
+            return;
+        }
+        p[pa] = pb;
+        size[pb] += size[pa];
+    }
+}
+```
+
+```java
+class Solution {
+    public int findLatestStep(int[] arr, int m) {
+        int n = arr.length;
+        if (m == n) {
+            return n;
+        }
+        int[] cnt = new int[n + 2];
+        int ans = -1;
+        for (int i = 0; i < n; ++i) {
+            int v = arr[i];
+            int l = cnt[v - 1], r = cnt[v + 1];
+            if (l == m || r == m) {
+                ans = i;
+            }
+            cnt[v - l] = l + r + 1;
+            cnt[v + r] = l + r + 1;
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> p;
+    vector<int> size;
+
+    int findLatestStep(vector<int>& arr, int m) {
+        int n = arr.size();
+        if (m == n) return n;
+        p.resize(n);
+        size.assign(n, 1);
+        for (int i = 0; i < n; ++i) p[i] = i;
+        int ans = -1;
+        vector<int> vis(n);
+        for (int i = 0; i < n; ++i)
+        {
+            int v = arr[i] - 1;
+            if (v && vis[v - 1])
+            {
+                if (size[find(v - 1)] == m) ans = i;
+                unite(v, v - 1);
+            }
+            if (v < n - 1 && vis[v + 1])
+            {
+                if (size[find(v + 1)] == m) ans = i;
+                unite(v, v + 1);
+            }
+            vis[v] = true;
+        }
+        return ans;
+    }
+
+    int find(int x) {
+        if (p[x] != x) p[x] = find(p[x]);
+        return p[x];
+    }
+
+    void unite(int a, int b) {
+        int pa = find(a), pb = find(b);
+        if (pa == pb) return;
+        p[pa] = pb;
+        size[pb] += size[pa];
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int findLatestStep(vector<int>& arr, int m) {
+        int n = arr.size();
+        if (m == n) return n;
+        vector<int> cnt(n + 2);
+        int ans = -1;
+        for (int i = 0; i < n; ++i)
+        {
+            int v = arr[i];
+            int l = cnt[v - 1], r = cnt[v + 1];
+            if (l == m || r == m) ans = i;
+            cnt[v - l] = cnt[v + r] = l + r + 1;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func findLatestStep(arr []int, m int) int {
+	n := len(arr)
+	if m == n {
+		return n
+	}
+	p := make([]int, n)
+	size := make([]int, n)
+	vis := make([]bool, n)
+	for i := range p {
+		p[i] = i
+		size[i] = 1
+	}
+	var find func(int) int
+	find = func(x int) int {
+		if p[x] != x {
+			p[x] = find(p[x])
+		}
+		return p[x]
+	}
+	union := func(a, b int) {
+		pa, pb := find(a), find(b)
+		if pa == pb {
+			return
+		}
+		p[pa] = pb
+		size[pb] += size[pa]
+	}
+
+	ans := -1
+	for i, v := range arr {
+		v--
+		if v > 0 && vis[v-1] {
+			if size[find(v-1)] == m {
+				ans = i
+			}
+			union(v, v-1)
+		}
+		if v < n-1 && vis[v+1] {
+			if size[find(v+1)] == m {
+				ans = i
+			}
+			union(v, v+1)
+		}
+		vis[v] = true
+	}
+	return ans
+}
+```
 
+```go
+func findLatestStep(arr []int, m int) int {
+	n := len(arr)
+	if m == n {
+		return n
+	}
+	cnt := make([]int, n+2)
+	ans := -1
+	for i, v := range arr {
+		l, r := cnt[v-1], cnt[v+1]
+		if l == m || r == m {
+			ans = i
+		}
+		cnt[v-l], cnt[v+r] = l+r+1, l+r+1
+	}
+	return ans
+}
 ```
 
 ### **...**