feat: add solutions to lc problem: No.0318 (doocs#1932)

No.0318.Maximum Product of Word Lengths

Author: yanglbme

solution/0300-0399/0318.Maximum Product of Word Lengths/README.md

@@ -46,6 +46,16 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：位运算**
+
+题目需要我们找到两个没有公共字母的字符串，使得它们的长度乘积最大。我们可以将每个字符串用一个二进制数 $mask[i]$ 表示，这个二进制数的每一位表示字符串中是否含有某个字母。如果两个字符串没有公共字母，那么这两个字符串对应的二进制数的按位与的结果为 $0$，即 $mask[i] \& mask[j] = 0$。
+
+我们遍历每个字符串，对于当前遍历到的字符串 $words[i]$，我们先算出对应的二进制数 $mask[i]$，然后再遍历 $j \in [0, i)$ 的所有字符串 $words[j]$，检查 $mask[i] \& mask[j] = 0$ 是否成立，如果成立就更新答案为 $\max(ans, |words[i]| \times |words[j]|)$。
+
+遍历结束后，返回答案即可。
+
+时间复杂度 $O(n^2 + L)$，空间复杂度 $O(n)$。其中 $n$ 是字符串数组 $words$ 的长度，而 $L$ 是字符串数组所有字符串的长度之和。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -55,16 +65,31 @@
 ```python
 class Solution:
     def maxProduct(self, words: List[str]) -> int:
-        n = len(words)
-        mask = [0] * n
-        for i, word in enumerate(words):
-            for ch in word:
-                mask[i] |= 1 << (ord(ch) - ord('a'))
+        mask = [0] * len(words)
+        ans = 0
+        for i, s in enumerate(words):
+            for c in s:
+                mask[i] |= 1 << (ord(c) - ord("a"))
+            for j, t in enumerate(words[:i]):
+                if (mask[i] & mask[j]) == 0:
+                    ans = max(ans, len(s) * len(t))
+        return ans
+```
+
+```python
+class Solution:
+    def maxProduct(self, words: List[str]) -> int:
+        mask = defaultdict(int)
         ans = 0
-        for i in range(n - 1):
-            for j in range(i + 1, n):
-                if mask[i] & mask[j] == 0:
-                    ans = max(ans, len(words[i]) * len(words[j]))
+        for s in words:
+            a = len(s)
+            x = 0
+            for c in s:
+                x |= 1 << (ord(c) - ord("a"))
+            for y, b in mask.items():
+                if (x & y) == 0:
+                    ans = max(ans, a * b)
+            mask[x] = max(mask[x], a)
         return ans
 ```
 
@@ -76,19 +101,41 @@ class Solution:
 class Solution {
     public int maxProduct(String[] words) {
         int n = words.length;
-        int[] masks = new int[n];
+        int[] mask = new int[n];
+        int ans = 0;
         for (int i = 0; i < n; ++i) {
             for (char c : words[i].toCharArray()) {
-                masks[i] |= (1 << (c - 'a'));
+                mask[i] |= 1 << (c - 'a');
+            }
+            for (int j = 0; j < i; ++j) {
+                if ((mask[i] & mask[j]) == 0) {
+                    ans = Math.max(ans, words[i].length() * words[j].length());
+                }
             }
         }
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    public int maxProduct(String[] words) {
+        Map<Integer, Integer> mask = new HashMap<>();
         int ans = 0;
-        for (int i = 0; i < n - 1; ++i) {
-            for (int j = i + 1; j < n; ++j) {
-                if ((masks[i] & masks[j]) == 0) {
-                    ans = Math.max(ans, words[i].length() * words[j].length());
+        for (var s : words) {
+            int a = s.length();
+            int x = 0;
+            for (char c : s.toCharArray()) {
+                x |= 1 << (c - 'a');
+            }
+            for (var e : mask.entrySet()) {
+                int y = e.getKey(), b = e.getValue();
+                if ((x & y) == 0) {
+                    ans = Math.max(ans, a * b);
                 }
             }
+            mask.merge(x, a, Math::max);
         }
         return ans;
     }
@@ -102,15 +149,43 @@ class Solution {
 public:
     int maxProduct(vector<string>& words) {
         int n = words.size();
-        vector<int> mask(n);
-        for (int i = 0; i < n; ++i)
-            for (char ch : words[i])
-                mask[i] |= 1 << (ch - 'a');
+        int mask[n];
+        memset(mask, 0, sizeof(mask));
         int ans = 0;
-        for (int i = 0; i < n - 1; ++i)
-            for (int j = i + 1; j < n; ++j)
-                if (!(mask[i] & mask[j]))
+        for (int i = 0; i < n; ++i) {
+            for (char& c : words[i]) {
+                mask[i] |= 1 << (c - 'a');
+            }
+            for (int j = 0; j < i; ++j) {
+                if ((mask[i] & mask[j]) == 0) {
                     ans = max(ans, (int) (words[i].size() * words[j].size()));
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int maxProduct(vector<string>& words) {
+        unordered_map<int, int> mask;
+        int ans = 0;
+        for (auto& s : words) {
+            int a = s.size();
+            int x = 0;
+            for (char& c : s) {
+                x |= 1 << (c - 'a');
+            }
+            for (auto& [y, b] : mask) {
+                if ((x & y) == 0) {
+                    ans = max(ans, a * b);
+                }
+            }
+            mask[x] = max(mask[x], a);
+        }
         return ans;
     }
 };
@@ -119,23 +194,82 @@ public:
 ### **Go**
 
 ```go
-func maxProduct(words []string) int {
+func maxProduct(words []string) (ans int) {
 	n := len(words)
 	mask := make([]int, n)
-	for i, word := range words {
-		for _, c := range word {
-			mask[i] |= (1 << (c - 'a'))
+	for i, s := range words {
+		for _, c := range s {
+			mask[i] |= 1 << (c - 'a')
 		}
-	}
-	ans := 0
-	for i := 0; i < n-1; i++ {
-		for j := i + 1; j < n; j++ {
+		for j, t := range words[:i] {
 			if mask[i]&mask[j] == 0 {
-				ans = max(ans, len(words[i])*len(words[j]))
+				ans = max(ans, len(s)*len(t))
+			}
+		}
+	}
+	return
+}
+```
+
+```go
+func maxProduct(words []string) (ans int) {
+	mask := map[int]int{}
+	for _, s := range words {
+		a := len(s)
+		x := 0
+		for _, c := range s {
+			x |= 1 << (c - 'a')
+		}
+		for y, b := range mask {
+			if x&y == 0 {
+				ans = max(ans, a*b)
 			}
 		}
+		mask[x] = max(mask[x], a)
 	}
-	return ans
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxProduct(words: string[]): number {
+    const n = words.length;
+    const mask: number[] = Array(n).fill(0);
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        for (const c of words[i]) {
+            mask[i] |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
+        }
+        for (let j = 0; j < i; ++j) {
+            if ((mask[i] & mask[j]) === 0) {
+                ans = Math.max(ans, words[i].length * words[j].length);
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function maxProduct(words: string[]): number {
+    const mask: Map<number, number> = new Map();
+    let ans = 0;
+    for (const s of words) {
+        const a = s.length;
+        let x = 0;
+        for (const c of s) {
+            x |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
+        }
+        for (const [y, b] of mask.entries()) {
+            if ((x & y) === 0) {
+                ans = Math.max(ans, a * b);
+            }
+        }
+        mask.set(x, Math.max(mask.get(x) || 0, a));
+    }
+    return ans;
 }
 ```