feat: add solutions for lc No.3900 (#5153)

Author: yanglbme

solution/3900-3999/3900.Longest Balanced Substring After One Swap/README.md

@@ -72,32 +72,219 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3900-3999/3900.Lo
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：前缀和 + 哈希表
+
+设前缀和 $\textit{pre}$ 表示当前前缀中字符 `1` 的个数减去字符 `0` 的个数。那么对于一个子串，如果其中 `0` 和 `1` 的数量相等，则它对应的前缀和变化量为 $0$。
+
+因此，如果在位置 $i$ 处的前缀和为 $x$，并且之前某个位置的前缀和也为 $x$，那么这两个位置之间的子串就是一个平衡子串，我们可以直接更新答案。
+
+现在题目允许我们至多交换一次任意两个字符。一次交换只能让某个子串中 `1` 和 `0` 的数量差减少 $2$，因此除了前缀和变化量为 $0$ 的情况外，我们还需要考虑：
+
+- 前缀和变化量为 $2$，说明子串中 `1` 比 `0` 多 2 个；此时如果字符串外部还存在至少一个 `0`，那么我们可以通过一次交换把它变成平衡子串。
+- 前缀和变化量为 $-2$，说明子串中 `0` 比 `1` 多 2 个；此时如果字符串外部还存在至少一个 `1`，同样可以通过一次交换把它变成平衡子串。
+
+为此，我们先统计整个字符串中 `0` 和 `1` 的总数，分别记为 $\textit{cnt0}$ 和 $\textit{cnt1}$。接着用哈希表记录每个前缀和值出现的所有位置。
+
+遍历字符串到位置 $i$ 时，设当前前缀和为 $\textit{pre}$：
+
+- 用最早出现的 $\textit{pre}$ 来更新“不交换时”的最长平衡子串长度。
+- 如果存在前缀和 $\textit{pre} - 2$，那么可以尝试构造一个 `1` 比 `0` 多 2 个的子串。设其长度为 $L$，则其中 `0` 的个数为 $(L - 2) / 2$。只有当这个数量严格小于 $\textit{cnt0}$ 时，说明字符串外部还剩至少一个 `0` 可以交换进来。
+- 如果存在前缀和 $\textit{pre} + 2$，同理可以尝试构造一个 `0` 比 `1` 多 2 个的子串，此时需要保证其中 `1` 的个数严格小于 $\textit{cnt1}$。
+
+由于同一个前缀和值越早出现，对应子串越长，所以我们优先使用最早出现的位置；如果它无法满足“外部仍有可交换字符”的条件，再尝试次早出现的位置。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def longestBalanced(self, s: str) -> int:
+        cnt0 = s.count("0")
+        cnt1 = len(s) - cnt0
+        pos = {0: [-1]}
+        ans = pre = 0
+        for i, c in enumerate(s):
+            pre += 1 if c == "1" else -1
+            pos.setdefault(pre, []).append(i)
+
+            ans = max(ans, i - pos[pre][0])
+            if pre - 2 in pos:
+                p = pos[pre - 2]
+                if (i - p[0] - 2) // 2 < cnt0:
+                    ans = max(ans, i - p[0])
+                elif len(p) > 1:
+                    ans = max(ans, i - p[1])
+
+            if pre + 2 in pos:
+                p = pos[pre + 2]
+                if (i - p[0] - 2) // 2 < cnt1:
+                    ans = max(ans, i - p[0])
+                elif len(p) > 1:
+                    ans = max(ans, i - p[1])
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int longestBalanced(String s) {
+        int cnt0 = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) == '0') {
+                ++cnt0;
+            }
+        }
+        int cnt1 = s.length() - cnt0;
+        Map<Integer, List<Integer>> pos = new HashMap<>();
+        pos.put(0, new ArrayList<>(List.of(-1)));
+        int ans = 0;
+        int pre = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            pre += s.charAt(i) == '1' ? 1 : -1;
+            pos.computeIfAbsent(pre, k -> new ArrayList<>()).add(i);
+
+            ans = Math.max(ans, i - pos.get(pre).get(0));
+            if (pos.containsKey(pre - 2)) {
+                List<Integer> p = pos.get(pre - 2);
+                if ((i - p.get(0) - 2) / 2 < cnt0) {
+                    ans = Math.max(ans, i - p.get(0));
+                } else if (p.size() > 1) {
+                    ans = Math.max(ans, i - p.get(1));
+                }
+            }
+
+            if (pos.containsKey(pre + 2)) {
+                List<Integer> p = pos.get(pre + 2);
+                if ((i - p.get(0) - 2) / 2 < cnt1) {
+                    ans = Math.max(ans, i - p.get(0));
+                } else if (p.size() > 1) {
+                    ans = Math.max(ans, i - p.get(1));
+                }
+            }
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int longestBalanced(string s) {
+        int cnt0 = count(s.begin(), s.end(), '0');
+        int cnt1 = s.size() - cnt0;
+        unordered_map<int, vector<int>> pos;
+        pos[0] = {-1};
+        int ans = 0, pre = 0;
+        for (int i = 0; i < s.size(); ++i) {
+            pre += s[i] == '1' ? 1 : -1;
+            pos[pre].push_back(i);
+
+            ans = max(ans, i - pos[pre][0]);
+            if (pos.contains(pre - 2)) {
+                auto& p = pos[pre - 2];
+                if ((i - p[0] - 2) / 2 < cnt0) {
+                    ans = max(ans, i - p[0]);
+                } else if (p.size() > 1) {
+                    ans = max(ans, i - p[1]);
+                }
+            }
+
+            if (pos.contains(pre + 2)) {
+                auto& p = pos[pre + 2];
+                if ((i - p[0] - 2) / 2 < cnt1) {
+                    ans = max(ans, i - p[0]);
+                } else if (p.size() > 1) {
+                    ans = max(ans, i - p[1]);
+                }
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func longestBalanced(s string) int {
+	cnt0 := strings.Count(s, "0")
+	cnt1 := len(s) - cnt0
+	pos := map[int][]int{0: {-1}}
+	ans, pre := 0, 0
+	for i, c := range s {
+		if c == '1' {
+			pre++
+		} else {
+			pre--
+		}
+		pos[pre] = append(pos[pre], i)
+
+		ans = max(ans, i-pos[pre][0])
+		if p, ok := pos[pre-2]; ok {
+			if (i-p[0]-2)/2 < cnt0 {
+				ans = max(ans, i-p[0])
+			} else if len(p) > 1 {
+				ans = max(ans, i-p[1])
+			}
+		}
+
+		if p, ok := pos[pre+2]; ok {
+			if (i-p[0]-2)/2 < cnt1 {
+				ans = max(ans, i-p[0])
+			} else if len(p) > 1 {
+				ans = max(ans, i-p[1])
+			}
+		}
+	}
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function longestBalanced(s: string): number {
+    const cnt0 = [...s].filter(c => c === '0').length;
+    const cnt1 = s.length - cnt0;
+    const pos = new Map<number, number[]>();
+    pos.set(0, [-1]);
+    let ans = 0;
+    let pre = 0;
+    for (let i = 0; i < s.length; ++i) {
+        pre += s[i] === '1' ? 1 : -1;
+        if (!pos.has(pre)) {
+            pos.set(pre, []);
+        }
+        pos.get(pre)!.push(i);
+
+        ans = Math.max(ans, i - pos.get(pre)![0]);
+        if (pos.has(pre - 2)) {
+            const p = pos.get(pre - 2)!;
+            if ((i - p[0] - 2) >> 1 < cnt0) {
+                ans = Math.max(ans, i - p[0]);
+            } else if (p.length > 1) {
+                ans = Math.max(ans, i - p[1]);
+            }
+        }
+
+        if (pos.has(pre + 2)) {
+            const p = pos.get(pre + 2)!;
+            if ((i - p[0] - 2) >> 1 < cnt1) {
+                ans = Math.max(ans, i - p[0]);
+            } else if (p.length > 1) {
+                ans = Math.max(ans, i - p[1]);
+            }
+        }
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->