+ problem 395

Author: fruit-in

Problemset/0395-Longest Substring with At Least K Repeating Characters/README.md

@@ -0,0 +1,61 @@
+# 395. Longest Substring with At Least K Repeating Characters
+Given a string `s` and an integer `k`, return *the length of the longest substring of* `s` *such that the frequency of each character in this substring is greater than or equal to* `k`.
+
+if no such substring exists, return 0.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> s = "aaabb", k = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest substring is "aaa", as 'a' is repeated 3 times.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> s = "ababbc", k = 2
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.
+</pre>
+
+#### Constraints:
+* <code>1 <= s.length <= 10<sup>4</sup></code>
+* `s` consists of only lowercase English letters.
+* <code>1 <= k <= 10<sup>5</sup></code>
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+impl Solution {
+    pub fn longest_substring(s: String, k: i32) -> i32 {
+        Self::dfs(s.as_bytes(), 0, s.len() - 1, k as usize)
+    }
+
+    fn dfs(s: &[u8], l: usize, r: usize, k: usize) -> i32 {
+        if l > r || r - l + 1 < k {
+            return 0;
+        }
+
+        let mut indices = vec![vec![]; 26];
+        let mut ret = (r - l + 1) as i32;
+
+        for i in l..=r {
+            indices[(s[i] - b'a') as usize].push(i);
+        }
+
+        for i in 0..26 {
+            if !indices[i].is_empty() && indices[i].len() < k {
+                ret = 0;
+                ret = ret.max(Self::dfs(s, l, indices[i][0].saturating_sub(1), k));
+                for j in 1..indices[i].len() {
+                    ret = ret.max(Self::dfs(s, indices[i][j - 1] + 1, indices[i][j] - 1, k));
+                }
+                ret = ret.max(Self::dfs(s, *indices[i].last().unwrap() + 1, r, k));
+                break;
+            }
+        }
+
+        ret
+    }
+}
+```

Problemset/0395-Longest Substring with At Least K Repeating Characters/README_CN.md

@@ -0,0 +1,61 @@
+# 395. 至少有 K 个重复字符的最长子串
+给你一个字符串 `s` 和一个整数 `k` ，请你找出 `s` 中的最长子串， 要求该子串中的每一字符出现次数都不少于 `k` 。返回这一子串的长度。
+
+如果不存在这样的子字符串，则返回 0。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> s = "aaabb", k = 3
+<strong>输出:</strong> 3
+<strong>解释:</strong> 最长子串为 "aaa" ，其中 'a' 重复了 3 次。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> s = "ababbc", k = 2
+<strong>输出:</strong> 5
+<strong>解释:</strong> 最长子串为 "ababb" ，其中 'a' 重复了 2 次， 'b' 重复了 3 次。
+</pre>
+
+#### 提示:
+* <code>1 <= s.length <= 10<sup>4</sup></code>
+* `s` 仅由小写英文字母组成
+* <code>1 <= k <= 10<sup>5</sup></code>
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+impl Solution {
+    pub fn longest_substring(s: String, k: i32) -> i32 {
+        Self::dfs(s.as_bytes(), 0, s.len() - 1, k as usize)
+    }
+
+    fn dfs(s: &[u8], l: usize, r: usize, k: usize) -> i32 {
+        if l > r || r - l + 1 < k {
+            return 0;
+        }
+
+        let mut indices = vec![vec![]; 26];
+        let mut ret = (r - l + 1) as i32;
+
+        for i in l..=r {
+            indices[(s[i] - b'a') as usize].push(i);
+        }
+
+        for i in 0..26 {
+            if !indices[i].is_empty() && indices[i].len() < k {
+                ret = 0;
+                ret = ret.max(Self::dfs(s, l, indices[i][0].saturating_sub(1), k));
+                for j in 1..indices[i].len() {
+                    ret = ret.max(Self::dfs(s, indices[i][j - 1] + 1, indices[i][j] - 1, k));
+                }
+                ret = ret.max(Self::dfs(s, *indices[i].last().unwrap() + 1, r, k));
+                break;
+            }
+        }
+
+        ret
+    }
+}
+```

Problemset/0395-Longest Substring with At Least K Repeating Characters/Solution.rs

@@ -0,0 +1,32 @@
+impl Solution {
+    pub fn longest_substring(s: String, k: i32) -> i32 {
+        Self::dfs(s.as_bytes(), 0, s.len() - 1, k as usize)
+    }
+
+    fn dfs(s: &[u8], l: usize, r: usize, k: usize) -> i32 {
+        if l > r || r - l + 1 < k {
+            return 0;
+        }
+
+        let mut indices = vec![vec![]; 26];
+        let mut ret = (r - l + 1) as i32;
+
+        for i in l..=r {
+            indices[(s[i] - b'a') as usize].push(i);
+        }
+
+        for i in 0..26 {
+            if !indices[i].is_empty() && indices[i].len() < k {
+                ret = 0;
+                ret = ret.max(Self::dfs(s, l, indices[i][0].saturating_sub(1), k));
+                for j in 1..indices[i].len() {
+                    ret = ret.max(Self::dfs(s, indices[i][j - 1] + 1, indices[i][j] - 1, k));
+                }
+                ret = ret.max(Self::dfs(s, *indices[i].last().unwrap() + 1, r, k));
+                break;
+            }
+        }
+
+        ret
+    }
+}

README.md

@@ -219,6 +219,7 @@
 [390][390l]  |[Elimination Game][390]                                                               |![rs]
 [392][392l]  |[Is Subsequence][392]                                                                 |![rs]
 [393][393l]  |[UTF-8 Validation][393]                                                               |![rs]
+[395][395l]  |[Longest Substring with At Least K Repeating Characters][395]                         |![rs]
 [396][396l]  |[Rotate Function][396]                                                                |![rs]
 [397][397l]  |[Integer Replacement][397]                                                            |![rs]
 [398][398l]  |[Random Pick Index][398]                                                              |![py]
@@ -1468,6 +1469,7 @@
 [390]:Problemset/0390-Elimination%20Game/README.md#390-elimination-game
 [392]:Problemset/0392-Is%20Subsequence/README.md#392-is-subsequence
 [393]:Problemset/0393-UTF-8%20Validation/README.md#393-utf-8-validation
+[395]:Problemset/0395-Longest%20Substring%20with%20At%20Least%20K%20Repeating%20Characters/README.md#395-longest-substring-with-at-least-k-repeating-characters
 [396]:Problemset/0396-Rotate%20Function/README.md#396-rotate-function
 [397]:Problemset/0397-Integer%20Replacement/README.md#397-integer-replacement
 [398]:Problemset/0398-Random%20Pick%20Index/README.md#398-random-pick-index
@@ -2716,6 +2718,7 @@
 [390l]:https://leetcode.com/problems/elimination-game/
 [392l]:https://leetcode.com/problems/is-subsequence/
 [393l]:https://leetcode.com/problems/utf-8-validation/
+[395l]:https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/
 [396l]:https://leetcode.com/problems/rotate-function/
 [397l]:https://leetcode.com/problems/integer-replacement/
 [398l]:https://leetcode.com/problems/random-pick-index/

README_CN.md

@@ -219,6 +219,7 @@
 [390][390l]  |[消除游戏][390]                                           |![rs]
 [392][392l]  |[判断子序列][392]                                         |![rs]
 [393][393l]  |[UTF-8 编码验证][393]                                     |![rs]
+[395][395l]  |[至少有 K 个重复字符的最长子串][395]                      |![rs]
 [396][396l]  |[旋转函数][396]                                           |![rs]
 [397][397l]  |[整数替换][397]                                           |![rs]
 [398][398l]  |[随机数索引][398]                                         |![py]
@@ -1468,6 +1469,7 @@
 [390]:Problemset/0390-Elimination%20Game/README_CN.md#390-消除游戏
 [392]:Problemset/0392-Is%20Subsequence/README_CN.md#392-判断子序列
 [393]:Problemset/0393-UTF-8%20Validation/README_CN.md#393-utf-8-编码验证
+[395]:Problemset/0395-Longest%20Substring%20with%20At%20Least%20K%20Repeating%20Characters/README_CN.md#395-至少有-k-个重复字符的最长子串
 [396]:Problemset/0396-Rotate%20Function/README_CN.md#396-旋转函数
 [397]:Problemset/0397-Integer%20Replacement/README_CN.md#397-整数替换
 [398]:Problemset/0398-Random%20Pick%20Index/README_CN.md#398-随机数索引
@@ -2716,6 +2718,7 @@
 [390l]:https://leetcode.cn/problems/elimination-game/
 [392l]:https://leetcode.cn/problems/is-subsequence/
 [393l]:https://leetcode.cn/problems/utf-8-validation/
+[395l]:https://leetcode.cn/problems/longest-substring-with-at-least-k-repeating-characters/
 [396l]:https://leetcode.cn/problems/rotate-function/
 [397l]:https://leetcode.cn/problems/integer-replacement/
 [398l]:https://leetcode.cn/problems/random-pick-index/