feat: add solutions to lc problem: No.1711

No.1711.Count Good Meals

Author: yanglbme

solution/1700-1799/1711.Count Good Meals/README.md

@@ -43,19 +43,25 @@
 
 ## 解法
 
-**方法一：哈希表**
+**方法一：哈希表 + 枚举二的幂**
 
-用最暴力的方法枚举每对元素肯定会超时，可以用哈希表优化对**之前元素出现次数**的查询。
+根据题意，我们需要统计数组中两个数的和为 $2$ 的幂的组合数。直接暴力枚举所有的组合数，时间复杂度为 $O(n^2)$ ，肯定会超时。
 
-**方法二：枚举二的幂**
+我们可以遍历数组，用哈希表 $cnt$ 维护数组中每个元素 $d$ 出现的次数。
 
-用哈希表 `cnt` 记录数组中每个元素出现的次数。
+对于每个元素，我们从小到大枚举二的幂次方 $s$ 作为两数之和，将哈希表中 $s - d$ 出现的次数累加到答案中。然后将当前元素 $d$ 出现的次数加一。
 
-枚举二的幂次方作为两数之和 `s`，然后枚举其中一个数 `a`，判断 `s-a` 是否出现在哈希表 `cnt` 中。若出现，判断 `a` 与 `b` 是否相等，是则答案累加 `cnt[a] * (cnt[a]-1)`，否则答案累加 `cnt[a] * cnt[b]`。
+遍历结束后，返回答案即可。
 
-由于每个 `a`，`b` 会重复枚举，因此最后答案需要除以 `2`。注意取模操作。
+时间复杂度 $O(n\times \log M)$，其中 $n$ 是数组 `deliciousness` 的长度，而 $M$ 是元素的上限，对于本题，上限 $M=2^{20}$。
 
-时间复杂度 $O(n\log C)$，其中 $n$ 是数组 `deliciousness` 的长度，而 $C$ 是元素的上限，对于本题，上限 $C=2^{20}$。
+我们也可以先用哈希表 $cnt$ 统计数组中每个元素出现的次数。
+
+然后从小到大枚举二的幂次方 $s$ 作为两数之和，对于每个 $s$，遍历哈希表每个键值对 $(a, m)$，如果 $s - a$ 也在哈希表中，且 $s - a \neq a$，则答案加上 $m \times cnt[s - a]$；如果 $s - a = a$，则答案加上 $m \times (m - 1)$。
+
+最后，将答案除以 $2$ 之后，模 $10^9 + 7$，返回即可。
+
+时间复杂度与上面的方法相同。
 
 <!-- 这里可写通用的实现逻辑 -->
 
@@ -68,33 +74,30 @@
 ```python
 class Solution:
     def countPairs(self, deliciousness: List[int]) -> int:
-        mod = 1000000007
-        limit = max(deliciousness) * 2
-        pairs = 0
-        freq = defaultdict(int)
+        mod = 10**9 + 7
+        mx = max(deliciousness) << 1
+        cnt = Counter()
+        ans = 0
         for d in deliciousness:
-            target = 1
-            while target <= limit:
-                pairs = (pairs + freq[target - d]) % mod
-                target = target << 1
-            freq[d] += 1
-        return pairs
+            s = 1
+            while s <= mx:
+                ans = (ans + cnt[s - d]) % mod
+                s <<= 1
+            cnt[d] += 1
+        return ans
 ```
 
 ```python
 class Solution:
     def countPairs(self, deliciousness: List[int]) -> int:
+        mod = 10**9 + 7
         cnt = Counter(deliciousness)
         ans = 0
-        mod = 10**9 + 7
         for i in range(22):
             s = 1 << i
             for a, m in cnt.items():
                 if (b := s - a) in cnt:
-                    if a == b:
-                        ans += m * (m - 1)
-                    else:
-                        ans += m * cnt[b]
+                    ans += m * (m - 1) if a == b else m * cnt[b]
         return (ans >> 1) % mod
 ```
 
@@ -104,21 +107,19 @@ class Solution:
 
 ```java
 class Solution {
-
-    private static final int MOD = 1000000007;
+    private static final int MOD = (int) 1e9 + 7;
 
     public int countPairs(int[] deliciousness) {
-        int limit = Arrays.stream(deliciousness).max().getAsInt() * 2;
-        int pairs = 0;
-        Map<Integer, Integer> freq = new HashMap<>();
+        int mx = Arrays.stream(deliciousness).max().getAsInt() << 1;
+        int ans = 0;
+        Map<Integer, Integer> cnt = new HashMap<>();
         for (int d : deliciousness) {
-            for (int sum = 1; sum <= limit; sum <<= 1) {
-                int count = freq.getOrDefault(sum - d, 0);
-                pairs = (pairs + count) % MOD;
+            for (int s = 1; s <= mx; s <<= 1) {
+                ans = (ans + cnt.getOrDefault(s - d, 0)) % MOD;
             }
-            freq.merge(d, 1, Integer::sum);
+            cnt.merge(d, 1, Integer::sum);
         }
-        return pairs;
+        return ans;
     }
 }
 ```
@@ -129,8 +130,8 @@ class Solution {
 
     public int countPairs(int[] deliciousness) {
         Map<Integer, Integer> cnt = new HashMap<>();
-        for (int v : deliciousness) {
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
+        for (int d : deliciousness) {
+            cnt.put(d, cnt.getOrDefault(d, 0) + 1);
         }
         long ans = 0;
         for (int i = 0; i < 22; ++i) {
@@ -141,11 +142,7 @@ class Solution {
                 if (!cnt.containsKey(b)) {
                     continue;
                 }
-                if (a == b) {
-                    ans += (long) m * (m - 1);
-                } else {
-                    ans += (long) m * cnt.get(b);
-                }
+                ans += 1L * m * (a == b ? m - 1 : cnt.get(b));
             }
         }
         ans >>= 1;
@@ -154,87 +151,104 @@ class Solution {
 }
 ```
 
-### **Go**
-
-```go
-const mod int = 1e9 + 7
-
-func countPairs(deliciousness []int) int {
-	limit := 0
-	for _, d := range deliciousness {
-		limit = max(limit, d)
-	}
-	limit *= 2
-	pairs := 0
-	freq := make(map[int]int)
-	for _, d := range deliciousness {
-		for sum := 1; sum <= limit; sum <<= 1 {
-			pairs = (pairs + freq[sum-d]) % mod
-		}
-		freq[d]++
-	}
-	return pairs
-}
+### **C++**
 
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-```
+```cpp
+class Solution {
+public:
+    const int mod = 1e9 + 7;
 
-```go
-func countPairs(deliciousness []int) int {
-	cnt := map[int]int{}
-	for _, v := range deliciousness {
-		cnt[v]++
-	}
-	ans := 0
-	mod := int(1e9) + 7
-	for i := 0; i < 22; i++ {
-		s := 1 << i
-		for a, m := range cnt {
-			b := s - a
-			if n, ok := cnt[b]; ok {
-				if a == b {
-					ans += m * (m - 1)
-				} else {
-					ans += m * n
-				}
-			}
-		}
-	}
-	ans >>= 1
-	return ans % mod
-}
+    int countPairs(vector<int>& deliciousness) {
+        int mx = *max_element(deliciousness.begin(), deliciousness.end()) << 1;
+        unordered_map<int, int> cnt;
+        int ans = 0;
+        for (auto& d : deliciousness) {
+            for (int s = 1; s <= mx; s <<= 1) {
+                ans = (ans + cnt[s - d]) % mod;
+            }
+            ++cnt[d];
+        }
+        return ans;
+    }
+};
 ```
 
-### **C++**
-
 ```cpp
 class Solution {
 public:
+    const int mod = 1e9 + 7;
+
     int countPairs(vector<int>& deliciousness) {
         unordered_map<int, int> cnt;
-        for (int v : deliciousness) ++cnt[v];
+        for (int& d : deliciousness) ++cnt[d];
         long long ans = 0;
         for (int i = 0; i < 22; ++i) {
             int s = 1 << i;
             for (auto& [a, m] : cnt) {
                 int b = s - a;
                 if (!cnt.count(b)) continue;
-                if (a == b) ans += 1ll * m * (m - 1);
-                else ans += 1ll * m * cnt[b];
+                ans += 1ll * m * (a == b ? (m - 1) : cnt[b]);
             }
         }
         ans >>= 1;
-        int mod = 1e9 + 7;
-        return (int) (ans % mod);
+        return ans % mod;
     }
 };
 ```
 
+### **Go**
+
+```go
+func countPairs(deliciousness []int) (ans int) {
+	mx := 0
+	for _, d := range deliciousness {
+		mx = max(mx, d)
+	}
+	mx <<= 1
+	const mod int = 1e9 + 7
+	cnt := map[int]int{}
+	for _, d := range deliciousness {
+		for s := 1; s <= mx; s <<= 1 {
+			ans = (ans + cnt[s-d]) % mod
+		}
+		cnt[d]++
+	}
+	return
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+```go
+func countPairs(deliciousness []int) (ans int) {
+    cnt := map[int]int{}
+    for _, d := range deliciousness {
+        cnt[d]++
+    }
+    const mod int = 1e9 + 7
+    for i := 0; i < 22; i++ {
+        s := 1 << i
+        for a, m := range cnt {
+            b := s - a
+            if n, ok := cnt[b]; ok {
+                if a == b {
+                    ans += m * (m - 1)
+                } else {
+                    ans += m * n
+                }
+            }
+        }
+    }
+    ans >>= 1
+    return ans % mod
+}
+```
+
 ### **...**
 
 ```