feat: add solutions to lc problem: No.3209

No.3209.Number of Subarrays With AND Value of K

Author: yanglbme

solution/3200-3299/3209.Number of Subarrays With AND Value of K/README.md

@@ -69,32 +69,117 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3209.Nu
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：哈希表 + 枚举
+
+根据题目描述，我们需要求出数组 $\textit{nums}$ 下标 $l$ 到 $r$ 的元素的按位与运算的结果，即 $\textit{nums}[l] \land \textit{nums}[l + 1] \land \cdots \land \textit{nums}[r]$。其中 $\land$ 表示按位与运算。
+
+如果我们每次固定右端点 $r$，那么左端点 $l$ 的范围是 $[0, r]$。由于按位与之和随着 $l$ 的减小而单调递减，并且 $nums[i]$ 的值不超过 $10^9$，因此区间 $[0, r]$ 最多只有 $30$ 种不同的值。因此，我们可以用一个集合来维护所有的 $\textit{nums}[l] \land \textit{nums}[l + 1] \land \cdots \land \textit{nums}[r]$ 的值，以及这些值出现的次数。
+
+当我们从 $r$ 遍历到 $r+1$ 时，以 $r+1$ 为右端点的值，就是集合中每个值与 $nums[r + 1]$ 进行按位与运算得到的值，再加上 $\textit{nums}[r + 1]$ 本身。
+
+因此，我们只需要枚举集合中的每个值，与 $\textit{nums[r]}$ 进行按位与运算，就可以得到以 $r$ 为右端点的所有值及其出现的次数。然后，我们还需要将 $\textit{nums[r]}$ 的出现次数加上去。此时，我们将值为 $k$ 的出现次数累加到答案中。继续遍历 $r$，直到遍历完整个数组。
+
+时间复杂度 $O(n \times \log M)$，空间复杂度 $O(\log M)$。其中 $n$ 和 $M$ 分别是数组 $\textit{nums}$ 的长度和数组 $\textit{nums}$ 中元素的最大值。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        ans = 0
+        pre = Counter()
+        for x in nums:
+            cur = Counter()
+            for y, v in pre.items():
+                cur[x & y] += v
+            cur[x] += 1
+            ans += cur[k]
+            pre = cur
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        long ans = 0;
+        Map<Integer, Integer> pre = new HashMap<>();
+        for (int x : nums) {
+            Map<Integer, Integer> cur = new HashMap<>();
+            for (var e : pre.entrySet()) {
+                int y = e.getKey(), v = e.getValue();
+                cur.merge(x & y, v, Integer::sum);
+            }
+            cur.merge(x, 1, Integer::sum);
+            ans += cur.getOrDefault(k, 0);
+            pre = cur;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        long long ans = 0;
+        unordered_map<int, int> pre;
+        for (int x : nums) {
+            unordered_map<int, int> cur;
+            for (auto& [y, v] : pre) {
+                cur[x & y] += v;
+            }
+            cur[x]++;
+            ans += cur[k];
+            pre = cur;
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func countSubarrays(nums []int, k int) (ans int64) {
+	pre := map[int]int{}
+	for _, x := range nums {
+		cur := map[int]int{}
+		for y, v := range pre {
+			cur[x&y] += v
+		}
+		cur[x]++
+		ans += int64(cur[k])
+		pre = cur
+	}
+	return
+}
+```
 
+#### TypeScript
+
+```ts
+function countSubarrays(nums: number[], k: number): number {
+    let ans = 0;
+    let pre = new Map<number, number>();
+    for (const x of nums) {
+        const cur = new Map<number, number>();
+        for (const [y, v] of pre) {
+            const z = x & y;
+            cur.set(z, (cur.get(z) || 0) + v);
+        }
+        cur.set(x, (cur.get(x) || 0) + 1);
+        ans += cur.get(k) || 0;
+        pre = cur;
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

solution/3200-3299/3209.Number of Subarrays With AND Value of K/README_EN.md

@@ -67,32 +67,117 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3209.Nu
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table + Enumeration
+
+According to the problem description, we need to find the result of the bitwise AND operation of elements from index $l$ to $r$ in the array $\textit{nums}$, that is, $\textit{nums}[l] \land \textit{nums}[l + 1] \land \cdots \land \textit{nums}[r]$, where $\land$ represents the bitwise AND operation.
+
+If we fix the right endpoint $r$, then the range of the left endpoint $l$ is $[0, r]$. Since the sum of bitwise AND decreases monotonically as $l$ decreases, and the value of $nums[i]$ does not exceed $10^9$, the interval $[0, r]$ can have at most $30$ different values. Therefore, we can use a set to maintain all the values of $\textit{nums}[l] \land \textit{nums}[l + 1] \land \cdots \land \textit{nums}[r]$ and the number of times these values occur.
+
+When we traverse from $r$ to $r+1$, the values with $r+1$ as the right endpoint are the values obtained by performing the bitwise AND operation of each value in the set with $nums[r + 1]$, plus $\textit{nums}[r + 1]$ itself.
+
+Therefore, we only need to enumerate each value in the set and perform the bitwise AND operation with $\textit{nums[r]}$ to get all the values and their occurrences with $r$ as the right endpoint. Then, we need to add the occurrence count of $\textit{nums[r]}$. At this point, we add the occurrence count of value $k$ to the answer. Continue traversing $r$ until the entire array is traversed.
+
+The time complexity is $O(n \times \log M)$, and the space complexity is $O(\log M)$. Here, $n$ and $M$ are the length of the array $\textit{nums}$ and the maximum value in the array $\textit{nums}$, respectively.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        ans = 0
+        pre = Counter()
+        for x in nums:
+            cur = Counter()
+            for y, v in pre.items():
+                cur[x & y] += v
+            cur[x] += 1
+            ans += cur[k]
+            pre = cur
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        long ans = 0;
+        Map<Integer, Integer> pre = new HashMap<>();
+        for (int x : nums) {
+            Map<Integer, Integer> cur = new HashMap<>();
+            for (var e : pre.entrySet()) {
+                int y = e.getKey(), v = e.getValue();
+                cur.merge(x & y, v, Integer::sum);
+            }
+            cur.merge(x, 1, Integer::sum);
+            ans += cur.getOrDefault(k, 0);
+            pre = cur;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        long long ans = 0;
+        unordered_map<int, int> pre;
+        for (int x : nums) {
+            unordered_map<int, int> cur;
+            for (auto& [y, v] : pre) {
+                cur[x & y] += v;
+            }
+            cur[x]++;
+            ans += cur[k];
+            pre = cur;
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func countSubarrays(nums []int, k int) (ans int64) {
+	pre := map[int]int{}
+	for _, x := range nums {
+		cur := map[int]int{}
+		for y, v := range pre {
+			cur[x&y] += v
+		}
+		cur[x]++
+		ans += int64(cur[k])
+		pre = cur
+	}
+	return
+}
+```
 
+#### TypeScript
+
+```ts
+function countSubarrays(nums: number[], k: number): number {
+    let ans = 0;
+    let pre = new Map<number, number>();
+    for (const x of nums) {
+        const cur = new Map<number, number>();
+        for (const [y, v] of pre) {
+            const z = x & y;
+            cur.set(z, (cur.get(z) || 0) + v);
+        }
+        cur.set(x, (cur.get(x) || 0) + 1);
+        ans += cur.get(k) || 0;
+        pre = cur;
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

solution/3200-3299/3209.Number of Subarrays With AND Value of K/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        long long ans = 0;
+        unordered_map<int, int> pre;
+        for (int x : nums) {
+            unordered_map<int, int> cur;
+            for (auto& [y, v] : pre) {
+                cur[x & y] += v;
+            }
+            cur[x]++;
+            ans += cur[k];
+            pre = cur;
+        }
+        return ans;
+    }
+};

solution/3200-3299/3209.Number of Subarrays With AND Value of K/Solution.go

@@ -0,0 +1,13 @@
+func countSubarrays(nums []int, k int) (ans int64) {
+	pre := map[int]int{}
+	for _, x := range nums {
+		cur := map[int]int{}
+		for y, v := range pre {
+			cur[x&y] += v
+		}
+		cur[x]++
+		ans += int64(cur[k])
+		pre = cur
+	}
+	return
+}

solution/3200-3299/3209.Number of Subarrays With AND Value of K/Solution.java

@@ -0,0 +1,17 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        long ans = 0;
+        Map<Integer, Integer> pre = new HashMap<>();
+        for (int x : nums) {
+            Map<Integer, Integer> cur = new HashMap<>();
+            for (var e : pre.entrySet()) {
+                int y = e.getKey(), v = e.getValue();
+                cur.merge(x & y, v, Integer::sum);
+            }
+            cur.merge(x, 1, Integer::sum);
+            ans += cur.getOrDefault(k, 0);
+            pre = cur;
+        }
+        return ans;
+    }
+}

solution/3200-3299/3209.Number of Subarrays With AND Value of K/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        ans = 0
+        pre = Counter()
+        for x in nums:
+            cur = Counter()
+            for y, v in pre.items():
+                cur[x & y] += v
+            cur[x] += 1
+            ans += cur[k]
+            pre = cur
+        return ans

solution/3200-3299/3209.Number of Subarrays With AND Value of K/Solution.ts

@@ -0,0 +1,15 @@
+function countSubarrays(nums: number[], k: number): number {
+    let ans = 0;
+    let pre = new Map<number, number>();
+    for (const x of nums) {
+        const cur = new Map<number, number>();
+        for (const [y, v] of pre) {
+            const z = x & y;
+            cur.set(z, (cur.get(z) || 0) + v);
+        }
+        cur.set(x, (cur.get(x) || 0) + 1);
+        ans += cur.get(k) || 0;
+        pre = cur;
+    }
+    return ans;
+}