feat: add solutions to lc problem: No.2950

solution/2900-2999/2950.Number of Divisible Substrings/README.md

@@ -149,6 +149,16 @@
 
 时间复杂度 $O(n^2)$，空间复杂度 $O(C)$。其中 $n$ 是字符串 $word$ 的长度，而 $C$ 是字符集的大小，本题中 $C=26$。
 
+**方法二：哈希表 + 前缀和 + 枚举**
+
+与方法一类似，我们先用一个哈希表或数组 $mp$ 记录每个字母对应的数字。
+
+如果一个整数子数组的数字之和能被它的长度整除，那么这个子数组的平均值一定是一个整数。而由于子数组中每个元素的数字都在 $[1, 9]$ 范围内，因此子数组的平均值只能是 $1, 2, \cdots, 9$ 中的一个。
+
+我们可以枚举子数组的平均值 $i$，如果一个子数组的元素和能被 $i$ 整除，假设子数组为 $a_1, a_2, \cdots, a_k$，那么 $a_1 + a_2 + \cdots + a_k = i \times k$，即 $(a_1 - i) + (a_2 - i) + \cdots + (a_k - i) = 0$。如果我们把 $a_k - i$ 视为一个新的元素 $b_k$，那么原来的子数组就变成了 $b_1, b_2, \cdots, b_k$，其中 $b_1 + b_2 + \cdots + b_k = 0$。我们只需要求出新的数组中，有多少个子数组的元素和为 $0$ 即可，这可以用“哈希表”结合“前缀和”来实现。
+
+时间复杂度 $O(10 \times n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串 $word$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -173,6 +183,26 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def countDivisibleSubstrings(self, word: str) -> int:
+        d = ["ab", "cde", "fgh", "ijk", "lmn", "opq", "rst", "uvw", "xyz"]
+        mp = {}
+        for i, s in enumerate(d, 1):
+            for c in s:
+                mp[c] = i
+        ans = 0
+        for i in range(1, 10):
+            cnt = defaultdict(int)
+            cnt[0] = 1
+            s = 0
+            for c in word:
+                s += mp[c] - i
+                ans += cnt[s]
+                cnt[s] += 1
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -201,6 +231,33 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int countDivisibleSubstrings(String word) {
+        String[] d = {"ab", "cde", "fgh", "ijk", "lmn", "opq", "rst", "uvw", "xyz"};
+        int[] mp = new int[26];
+        for (int i = 0; i < d.length; ++i) {
+            for (char c : d[i].toCharArray()) {
+                mp[c - 'a'] = i + 1;
+            }
+        }
+        int ans = 0;
+        char[] cs = word.toCharArray();
+        for (int i = 1; i < 10; ++i) {
+            Map<Integer, Integer> cnt = new HashMap<>();
+            cnt.put(0, 1);
+            int s = 0;
+            for (char c : cs) {
+                s += mp[c - 'a'] - i;
+                ans += cnt.getOrDefault(s, 0);
+                cnt.merge(s, 1, Integer::sum);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -228,6 +285,31 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int countDivisibleSubstrings(string word) {
+        string d[9] = {"ab", "cde", "fgh", "ijk", "lmn", "opq", "rst", "uvw", "xyz"};
+        int mp[26]{};
+        for (int i = 0; i < 9; ++i) {
+            for (char& c : d[i]) {
+                mp[c - 'a'] = i + 1;
+            }
+        }
+        int ans = 0;
+        for (int i = 1; i < 10; ++i) {
+            unordered_map<int, int> cnt{{0, 1}};
+            int s = 0;
+            for (char& c : word) {
+                s += mp[c - 'a'] - i;
+                ans += cnt[s]++;
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -253,6 +335,28 @@ func countDivisibleSubstrings(word string) (ans int) {
 }
 ```
 
+```go
+func countDivisibleSubstrings(word string) (ans int) {
+	d := []string{"ab", "cde", "fgh", "ijk", "lmn", "opq", "rst", "uvw", "xyz"}
+	mp := [26]int{}
+	for i, s := range d {
+		for _, c := range s {
+			mp[c-'a'] = i + 1
+		}
+	}
+	for i := 0; i < 10; i++ {
+		cnt := map[int]int{0: 1}
+		s := 0
+		for _, c := range word {
+			s += mp[c-'a'] - i
+			ans += cnt[s]
+			cnt[s]++
+		}
+	}
+	return
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -279,6 +383,31 @@ function countDivisibleSubstrings(word: string): number {
 }
 ```
 
+```ts
+function countDivisibleSubstrings(word: string): number {
+    const d = ['ab', 'cde', 'fgh', 'ijk', 'lmn', 'opq', 'rst', 'uvw', 'xyz'];
+    const mp: number[] = Array(26).fill(0);
+
+    d.forEach((s, i) => {
+        for (const c of s) {
+            mp[c.charCodeAt(0) - 'a'.charCodeAt(0)] = i + 1;
+        }
+    });
+
+    let ans = 0;
+    for (let i = 0; i < 10; i++) {
+        const cnt: { [key: number]: number } = { 0: 1 };
+        let s = 0;
+        for (const c of word) {
+            s += mp[c.charCodeAt(0) - 'a'.charCodeAt(0)] - i;
+            ans += cnt[s] || 0;
+            cnt[s] = (cnt[s] || 0) + 1;
+        }
+    }
+    return ans;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -310,6 +439,34 @@ impl Solution {
 }
 ```
 
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_divisible_substrings(word: String) -> i32 {
+        let d = vec!["ab", "cde", "fgh", "ijk", "lmn", "opq", "rst", "uvw", "xyz"];
+        let mut mp: Vec<usize> = vec![0; 26];
+        for (i, s) in d.iter().enumerate() {
+            for c in s.chars() {
+                mp[(c as usize) - ('a' as usize)] = i + 1;
+            }
+        }
+        let mut ans = 0;
+        for i in 0..10 {
+            let mut cnt: HashMap<i32, i32> = HashMap::new();
+            cnt.insert(0, 1);
+            let mut s = 0;
+            for c in word.chars() {
+                s += (mp[(c as usize) - ('a' as usize)] - i) as i32;
+                ans += cnt.get(&s).cloned().unwrap_or(0);
+                *cnt.entry(s).or_insert(0) += 1;
+            }
+        }
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```