feat: add solutions to lc problem: No.1897 (#3858)

yanglbme · web-flow · commit db4a6f3cc5a9 · 2024-12-14T08:41:22.000+08:00
No.1897.Redistribute Characters to Make All Strings Equal
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/README.md b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/README.md
@@ -60,7 +60,13 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：计数
+
+根据题目描述，只要每个字符的出现次数能被字符串数组的长度整除，就可以通过移动字符使所有字符串相等。
+
+因此，我们用哈希表或者一个长度为 $26$ 的整数数组 $\textit{cnt}$ 统计每个字符出现的次数，最后判断是否每个字符的出现次数能被字符串数组的长度整除即可。
+
+时间复杂度 $O(L)$，空间复杂度 $O(|\Sigma|)$。其中 $L$ 为数组 $\textit{words}$ 中所有字符串的长度之和，而 $\Sigma$ 为字符集，这里为小写字母集合，所以 $|\Sigma|=26$。
 
 <!-- tabs:start -->
 
@@ -69,28 +75,28 @@ tags:
 ```python
 class Solution:
     def makeEqual(self, words: List[str]) -> bool:
-        counter = Counter()
-        for word in words:
-            for c in word:
-                counter[c] += 1
+        cnt = Counter()
+        for w in words:
+            for c in w:
+                cnt[c] += 1
         n = len(words)
-        return all(count % n == 0 for count in counter.values())
+        return all(v % n == 0 for v in cnt.values())
 ```
 
 #### Java
 
 ```java
 class Solution {
     public boolean makeEqual(String[] words) {
-        int[] counter = new int[26];
-        for (String word : words) {
-            for (char c : word.toCharArray()) {
-                ++counter[c - 'a'];
+        int[] cnt = new int[26];
+        for (var w : words) {
+            for (char c : w.toCharArray()) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.length;
-        for (int i = 0; i < 26; ++i) {
-            if (counter[i] % n != 0) {
+        for (int v : cnt) {
+            if (v % n != 0) {
                 return false;
             }
         }
@@ -105,15 +111,17 @@ class Solution {
 class Solution {
 public:
     bool makeEqual(vector<string>& words) {
-        vector<int> counter(26, 0);
-        for (string word : words) {
-            for (char c : word) {
-                ++counter[c - 'a'];
+        int cnt[26]{};
+        for (const auto& w : words) {
+            for (const auto& c : w) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.size();
-        for (int count : counter) {
-            if (count % n != 0) return false;
+        for (int i = 0; i < 26; ++i) {
+            if (cnt[i] % n != 0) {
+                return false;
+            }
         }
         return true;
     }
@@ -124,15 +132,15 @@ public:
 
 ```go
 func makeEqual(words []string) bool {
-	counter := [26]int{}
-	for _, word := range words {
-		for _, c := range word {
-			counter[c-'a']++
+	cnt := [26]int{}
+	for _, w := range words {
+		for _, c := range w {
+			cnt[c-'a']++
 		}
 	}
 	n := len(words)
-	for _, count := range counter {
-		if count%n != 0 {
+	for _, v := range cnt {
+		if v%n != 0 {
 			return false
 		}
 	}
@@ -144,20 +152,33 @@ func makeEqual(words []string) bool {
 
 ```ts
 function makeEqual(words: string[]): boolean {
-    let n = words.length;
-    let letters = new Array(26).fill(0);
-    for (let word of words) {
-        for (let i = 0; i < word.length; ++i) {
-            ++letters[word.charCodeAt(i) - 97];
+    const cnt: Record<string, number> = {};
+    for (const w of words) {
+        for (const c of w) {
+            cnt[c] = (cnt[c] || 0) + 1;
         }
     }
+    const n = words.length;
+    return Object.values(cnt).every(v => v % n === 0);
+}
+```
+
+#### Rust
 
-    for (let i = 0; i < letters.length; ++i) {
-        if (letters[i] % n != 0) {
-            return false;
+```rust
+impl Solution {
+    pub fn make_equal(words: Vec<String>) -> bool {
+        let mut cnt = std::collections::HashMap::new();
+
+        for word in words.iter() {
+            for c in word.chars() {
+                *cnt.entry(c).or_insert(0) += 1;
+            }
         }
+
+        let n = words.len();
+        cnt.values().all(|&v| v % n == 0)
     }
-    return true;
 }
 ```
 
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/README_EN.md b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/README_EN.md
@@ -60,7 +60,13 @@ All the strings are now equal to &quot;abc&quot;, so return <code>true</code>.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Counting
+
+According to the problem description, as long as the occurrence count of each character can be divided by the length of the string array, it is possible to redistribute the characters to make all strings equal.
+
+Therefore, we use a hash table or an integer array of length $26$ $\textit{cnt}$ to count the occurrences of each character. Finally, we check if the occurrence count of each character can be divided by the length of the string array.
+
+The time complexity is $O(L)$, and the space complexity is $O(|\Sigma|)$. Here, $L$ is the total length of all strings in the array $\textit{words}$, and $\Sigma$ is the character set, which is the set of lowercase letters, so $|\Sigma|=26$.
 
 <!-- tabs:start -->
 
@@ -69,28 +75,28 @@ All the strings are now equal to &quot;abc&quot;, so return <code>true</code>.
 ```python
 class Solution:
     def makeEqual(self, words: List[str]) -> bool:
-        counter = Counter()
-        for word in words:
-            for c in word:
-                counter[c] += 1
+        cnt = Counter()
+        for w in words:
+            for c in w:
+                cnt[c] += 1
         n = len(words)
-        return all(count % n == 0 for count in counter.values())
+        return all(v % n == 0 for v in cnt.values())
 ```
 
 #### Java
 
 ```java
 class Solution {
     public boolean makeEqual(String[] words) {
-        int[] counter = new int[26];
-        for (String word : words) {
-            for (char c : word.toCharArray()) {
-                ++counter[c - 'a'];
+        int[] cnt = new int[26];
+        for (var w : words) {
+            for (char c : w.toCharArray()) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.length;
-        for (int i = 0; i < 26; ++i) {
-            if (counter[i] % n != 0) {
+        for (int v : cnt) {
+            if (v % n != 0) {
                 return false;
             }
         }
@@ -105,15 +111,17 @@ class Solution {
 class Solution {
 public:
     bool makeEqual(vector<string>& words) {
-        vector<int> counter(26, 0);
-        for (string word : words) {
-            for (char c : word) {
-                ++counter[c - 'a'];
+        int cnt[26]{};
+        for (const auto& w : words) {
+            for (const auto& c : w) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.size();
-        for (int count : counter) {
-            if (count % n != 0) return false;
+        for (int i = 0; i < 26; ++i) {
+            if (cnt[i] % n != 0) {
+                return false;
+            }
         }
         return true;
     }
@@ -124,15 +132,15 @@ public:
 
 ```go
 func makeEqual(words []string) bool {
-	counter := [26]int{}
-	for _, word := range words {
-		for _, c := range word {
-			counter[c-'a']++
+	cnt := [26]int{}
+	for _, w := range words {
+		for _, c := range w {
+			cnt[c-'a']++
 		}
 	}
 	n := len(words)
-	for _, count := range counter {
-		if count%n != 0 {
+	for _, v := range cnt {
+		if v%n != 0 {
 			return false
 		}
 	}
@@ -144,20 +152,33 @@ func makeEqual(words []string) bool {
 
 ```ts
 function makeEqual(words: string[]): boolean {
-    let n = words.length;
-    let letters = new Array(26).fill(0);
-    for (let word of words) {
-        for (let i = 0; i < word.length; ++i) {
-            ++letters[word.charCodeAt(i) - 97];
+    const cnt: Record<string, number> = {};
+    for (const w of words) {
+        for (const c of w) {
+            cnt[c] = (cnt[c] || 0) + 1;
         }
     }
+    const n = words.length;
+    return Object.values(cnt).every(v => v % n === 0);
+}
+```
+
+#### Rust
 
-    for (let i = 0; i < letters.length; ++i) {
-        if (letters[i] % n != 0) {
-            return false;
+```rust
+impl Solution {
+    pub fn make_equal(words: Vec<String>) -> bool {
+        let mut cnt = std::collections::HashMap::new();
+
+        for word in words.iter() {
+            for c in word.chars() {
+                *cnt.entry(c).or_insert(0) += 1;
+            }
         }
+
+        let n = words.len();
+        cnt.values().all(|&v| v % n == 0)
     }
-    return true;
 }
 ```
 
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.cpp b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.cpp
@@ -1,16 +1,18 @@
 class Solution {
 public:
     bool makeEqual(vector<string>& words) {
-        vector<int> counter(26, 0);
-        for (string word : words) {
-            for (char c : word) {
-                ++counter[c - 'a'];
+        int cnt[26]{};
+        for (const auto& w : words) {
+            for (const auto& c : w) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.size();
-        for (int count : counter) {
-            if (count % n != 0) return false;
+        for (int i = 0; i < 26; ++i) {
+            if (cnt[i] % n != 0) {
+                return false;
+            }
         }
         return true;
     }
-};
+};
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.go b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.go
@@ -1,15 +1,15 @@
 func makeEqual(words []string) bool {
-	counter := [26]int{}
-	for _, word := range words {
-		for _, c := range word {
-			counter[c-'a']++
+	cnt := [26]int{}
+	for _, w := range words {
+		for _, c := range w {
+			cnt[c-'a']++
 		}
 	}
 	n := len(words)
-	for _, count := range counter {
-		if count%n != 0 {
+	for _, v := range cnt {
+		if v%n != 0 {
 			return false
 		}
 	}
 	return true
-}
+}
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.java b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.java
@@ -1,17 +1,17 @@
 class Solution {
     public boolean makeEqual(String[] words) {
-        int[] counter = new int[26];
-        for (String word : words) {
-            for (char c : word.toCharArray()) {
-                ++counter[c - 'a'];
+        int[] cnt = new int[26];
+        for (var w : words) {
+            for (char c : w.toCharArray()) {
+                ++cnt[c - 'a'];
             }
         }
         int n = words.length;
-        for (int i = 0; i < 26; ++i) {
-            if (counter[i] % n != 0) {
+        for (int v : cnt) {
+            if (v % n != 0) {
                 return false;
             }
         }
         return true;
     }
-}
+}
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.py b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.py
@@ -1,8 +1,8 @@
 class Solution:
     def makeEqual(self, words: List[str]) -> bool:
-        counter = Counter()
-        for word in words:
-            for c in word:
-                counter[c] += 1
+        cnt = Counter()
+        for w in words:
+            for c in w:
+                cnt[c] += 1
         n = len(words)
-        return all(count % n == 0 for count in counter.values())
+        return all(v % n == 0 for v in cnt.values())
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.rs b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.rs
@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn make_equal(words: Vec<String>) -> bool {
+        let mut cnt = std::collections::HashMap::new();
+
+        for word in words.iter() {
+            for c in word.chars() {
+                *cnt.entry(c).or_insert(0) += 1;
+            }
+        }
+
+        let n = words.len();
+        cnt.values().all(|&v| v % n == 0)
+    }
+}
diff --git a/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.ts b/solution/1800-1899/1897.Redistribute Characters to Make All Strings Equal/Solution.ts

Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,15 @@`
`1`	`1`	`func makeEqual(words []string) bool {`
`2`		`- counter := [26]int{}`
`3`		`- for _, word := range words {`
`4`		`- for _, c := range word {`
`5`		`- counter[c-'a']++`
	`2`	`+ cnt := [26]int{}`
	`3`	`+ for _, w := range words {`
	`4`	`+ for _, c := range w {`
	`5`	`+ cnt[c-'a']++`
`6`	`6`	`}`
`7`	`7`	`}`
`8`	`8`	`n := len(words)`
`9`		`- for _, count := range counter {`
`10`		`- if count%n != 0 {`
	`9`	`+ for _, v := range cnt {`
	`10`	`+ if v%n != 0 {`
`11`	`11`	`return false`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`return true`
`15`		`-}`
	`15`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	`class Solution {`
`2`	`2`	`public boolean makeEqual(String[] words) {`
`3`		`- int[] counter = new int[26];`
`4`		`- for (String word : words) {`
`5`		`- for (char c : word.toCharArray()) {`
`6`		`- ++counter[c - 'a'];`
	`3`	`+ int[] cnt = new int[26];`
	`4`	`+ for (var w : words) {`
	`5`	`+ for (char c : w.toCharArray()) {`
	`6`	`+ ++cnt[c - 'a'];`
`7`	`7`	`}`
`8`	`8`	`}`
`9`	`9`	`int n = words.length;`
`10`		`- for (int i = 0; i < 26; ++i) {`
`11`		`- if (counter[i] % n != 0) {`
	`10`	`+ for (int v : cnt) {`
	`11`	`+ if (v % n != 0) {`
`12`	`12`	`return false;`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`return true;`
`16`	`16`	`}`
`17`		`-}`
	`17`	`+}`