feat: add solutions to lcci problems: No.10.02,10.05 (doocs#2692)

Author: yanglbme

lcci/08.03.Magic Index/README.md

@@ -37,7 +37,7 @@
 1. 如果 $i > j$，返回 $-1$。
 2. 否则，我们取中间位置 $mid = (i + j) / 2$，然后递归调用 $dfs(i, mid-1)$，如果返回值不为 $-1$，说明在左半部分找到了魔术索引，直接返回。否则，如果 $nums[mid] = mid$，说明找到了魔术索引，直接返回。否则，递归调用 $dfs(mid+1, j)$ 并返回。
 
-时间复杂度 $O(\log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组的长度。
+时间复杂度最坏情况下为 $O(n)$，空间复杂度最坏情况下为 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 

lcci/08.03.Magic Index/README_EN.md

@@ -43,7 +43,7 @@ The implementation of the function $dfs(i, j)$ is as follows:
 1. If $i > j$, return $-1$.
 2. Otherwise, we take the middle position $mid = (i + j) / 2$, then recursively call $dfs(i, mid-1)$. If the return value is not $-1$, it means that the magic index is found in the left half, return it directly. Otherwise, if $nums[mid] = mid$, it means that the magic index is found, return it directly. Otherwise, recursively call $dfs(mid+1, j)$ and return.
 
-The time complexity is $O(\log n)$, and the space complexity is $O(\log n)$. Where $n$ is the length of the array.
+In the worst case, the time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 

lcci/10.02.Group Anagrams/README.md

@@ -28,31 +28,47 @@
 
 ## 解法
 
-### 方法一
+### 方法一：哈希表
+
+1. 遍历字符串，对每个字符串按照**字符字典序**排序，得到一个新的字符串。
+2. 以新字符串为 `key`，`[str]` 为 `value`，存入哈希表当中（`HashMap<String, List<String>>`）。
+3. 后续遍历得到相同 `key` 时，将其加入到对应的 `value` 当中即可。
+
+以 `strs = ["eat", "tea", "tan", "ate", "nat", "bat"]` 为例，遍历结束时，哈希表的状况：
+
+| key     | value                   |
+| ------- | ----------------------- |
+| `"aet"` | `["eat", "tea", "ate"]` |
+| `"ant"` | `["tan", "nat"] `       |
+| `"abt"` | `["bat"] `              |
+
+最后返回哈希表的 `value` 列表即可。
+
+时间复杂度 $O(n\times k\times \log k)$。其中 $n$ 和 $k$ 分别是字符串数组的长度和字符串的最大长度。
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
-        chars = defaultdict(list)
+        d = defaultdict(list)
         for s in strs:
-            k = ''.join(sorted(list(s)))
-            chars[k].append(s)
-        return list(chars.values())
+            k = ''.join(sorted(s))
+            d[k].append(s)
+        return list(d.values())
 ```
 
 ```java
 class Solution {
     public List<List<String>> groupAnagrams(String[] strs) {
-        Map<String, List<String>> chars = new HashMap<>();
+        Map<String, List<String>> d = new HashMap<>();
         for (String s : strs) {
             char[] t = s.toCharArray();
             Arrays.sort(t);
-            String k = new String(t);
-            chars.computeIfAbsent(k, key -> new ArrayList<>()).add(s);
+            String k = String.valueOf(t);
+            d.computeIfAbsent(k, key -> new ArrayList<>()).add(s);
         }
-        return new ArrayList<>(chars.values());
+        return new ArrayList<>(d.values());
     }
 }
 ```
@@ -61,68 +77,132 @@ class Solution {
 class Solution {
 public:
     vector<vector<string>> groupAnagrams(vector<string>& strs) {
-        unordered_map<string, vector<string>> chars;
-        for (auto s : strs) {
+        unordered_map<string, vector<string>> d;
+        for (auto& s : strs) {
             string k = s;
             sort(k.begin(), k.end());
-            chars[k].emplace_back(s);
+            d[k].emplace_back(s);
         }
-        vector<vector<string>> res;
-        for (auto it = chars.begin(); it != chars.end(); ++it) {
-            res.emplace_back(it->second);
-        }
-        return res;
+        vector<vector<string>> ans;
+        for (auto& [_, v] : d) ans.emplace_back(v);
+        return ans;
     }
 };
 ```
 
 ```go
-func groupAnagrams(strs []string) [][]string {
-	chars := map[string][]string{}
+func groupAnagrams(strs []string) (ans [][]string) {
+	d := map[string][]string{}
 	for _, s := range strs {
-		key := []byte(s)
-		sort.Slice(key, func(i, j int) bool {
-			return key[i] < key[j]
-		})
-		chars[string(key)] = append(chars[string(key)], s)
+		t := []byte(s)
+		sort.Slice(t, func(i, j int) bool { return t[i] < t[j] })
+		k := string(t)
+		d[k] = append(d[k], s)
 	}
-	var res [][]string
-	for _, v := range chars {
-		res = append(res, v)
+	for _, v := range d {
+		ans = append(ans, v)
 	}
-	return res
+	return
 }
 ```
 
 ```ts
 function groupAnagrams(strs: string[]): string[][] {
-    const map = new Map<string, string[]>();
+    const d: Map<string, string[]> = new Map();
     for (const s of strs) {
-        const k = s.split('').sort().join();
-        map.set(k, (map.get(k) || []).concat([s]));
+        const k = s.split('').sort().join('');
+        if (!d.has(k)) {
+            d.set(k, []);
+        }
+        d.get(k)!.push(s);
+    }
+    return Array.from(d.values());
+}
+```
+
+<!-- tabs:end -->
+
+### 方法二：计数
+
+我们也可以将方法一中的排序部分改为计数，也就是说，将每个字符串 $s$ 中的字符以及出现的次数作为 `key`，将字符串 $s$ 作为 `value` 存入哈希表当中。
+
+时间复杂度 $O(n\times (k + C))$。其中 $n$ 和 $k$ 分别是字符串数组的长度和字符串的最大长度，而 $C$ 是字符集的大小，本题中 $C = 26$。
+
+<!-- tabs:start -->
+
+```python
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        d = defaultdict(list)
+        for s in strs:
+            cnt = [0] * 26
+            for c in s:
+                cnt[ord(c) - ord('a')] += 1
+            d[tuple(cnt)].append(s)
+        return list(d.values())
+```
+
+```java
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> d = new HashMap<>();
+        for (String s : strs) {
+            int[] cnt = new int[26];
+            for (int i = 0; i < s.length(); ++i) {
+                ++cnt[s.charAt(i) - 'a'];
+            }
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < 26; ++i) {
+                if (cnt[i] > 0) {
+                    sb.append((char) ('a' + i)).append(cnt[i]);
+                }
+            }
+            String k = sb.toString();
+            d.computeIfAbsent(k, key -> new ArrayList<>()).add(s);
+        }
+        return new ArrayList<>(d.values());
     }
-    return [...map.values()];
 }
 ```
 
-```rust
-use std::collections::HashMap;
-
-impl Solution {
-    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
-        let mut map = HashMap::new();
-        for s in strs {
-            let key = {
-                let mut cs = s.chars().collect::<Vec<char>>();
-                cs.sort();
-                cs.iter().collect::<String>()
-            };
-            map.entry(key)
-                .or_insert(vec![])
-                .push(s);
+```cpp
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> d;
+        for (auto& s : strs) {
+            int cnt[26] = {0};
+            for (auto& c : s) ++cnt[c - 'a'];
+            string k;
+            for (int i = 0; i < 26; ++i) {
+                if (cnt[i]) {
+                    k += 'a' + i;
+                    k += to_string(cnt[i]);
+                }
+            }
+            d[k].emplace_back(s);
         }
-        map.into_values().collect()
+        vector<vector<string>> ans;
+        for (auto& [_, v] : d) ans.emplace_back(v);
+        return ans;
     }
+};
+```
+
+```go
+func groupAnagrams(strs []string) (ans [][]string) {
+	d := map[[26]int][]string{}
+	for _, s := range strs {
+		cnt := [26]int{}
+		for _, c := range s {
+			cnt[c-'a']++
+		}
+		d[cnt] = append(d[cnt], s)
+	}
+	for _, v := range d {
+		ans = append(ans, v)
+	}
+	return
 }
 ```