feat: add solutions for weekly contest 484 (#4962)

Author: yanglbme

solution/3800-3899/3803.Count Residue Prefixes/README.md

@@ -92,7 +92,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3803.Co
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：哈希表
+
+我们用一个哈希表 $\textit{st}$ 来记录当前前缀中出现过的不同字符的集合。遍历字符串 $s$ 的每个字符 $c$，将其加入集合 $\textit{st}$ 中，然后判断当前前缀的长度对 $3$ 取模的结果是否等于集合 $\textit{st}$ 的大小。如果相等，则说明当前前缀是一个残差前缀，答案加 $1$。
+
+遍历结束后，返回答案即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 

solution/3800-3899/3803.Count Residue Prefixes/README_EN.md

@@ -81,7 +81,13 @@ A <strong>prefix</strong> of a string is a <strong>non-empty substring</strong>
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table
+
+We use a hash table $\textit{st}$ to record the set of distinct characters that have appeared in the current prefix. We iterate through each character $c$ in the string $s$, add it to the set $\textit{st}$, and then check if the length of the current prefix modulo $3$ equals the size of the set $\textit{st}$. If they are equal, it means the current prefix is a residue prefix, and we increment the answer by $1$.
+
+After the iteration, we return the answer.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

solution/3800-3899/3804.Number of Centered Subarrays/README.md

@@ -69,7 +69,11 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3804.Nu
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：哈希表 + 枚举
+
+我们枚举所有子数组的起始下标 $i$，然后从下标 $i$ 开始枚举子数组的结束下标 $j$，计算子数组 $nums[i \ldots j]$ 的元素之和 $s$，并将子数组中的所有元素加入哈希表 $\textit{st}$ 中。每次枚举结束后，判断 $s$ 是否在哈希表 $\textit{st}$ 中出现过，如果出现过，则说明子数组 $nums[i \ldots j]$ 是一个中心子数组，答案加 $1$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 

solution/3800-3899/3804.Number of Centered Subarrays/README_EN.md

@@ -67,7 +67,11 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3804.Nu
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table + Enumeration
+
+We enumerate all starting indices $i$ of subarrays, then starting from index $i$, we enumerate the ending index $j$ of the subarray, calculate the sum $s$ of elements in the subarray $nums[i \ldots j]$, and add all elements in the subarray to the hash table $\textit{st}$. After each enumeration, we check if $s$ appears in the hash table $\textit{st}$. If it does, it means the subarray $nums[i \ldots j]$ is a centered subarray, and we increment the answer by $1$.
+
+The time complexity is $O(n^2)$ and the space complexity is $O(n)$, where $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 

solution/3800-3899/3805.Count Caesar Cipher Pairs/README.md

@@ -86,7 +86,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3805.Co
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：字符串转换 + 计数
+
+我们可以将每个字符串转换为一个统一的形式，具体做法是将字符串的第一个字符转换为 `'z'`，然后将字符串中的其他字符按照相同的偏移量进行转换。这样，所有相似的字符串都会被转换为相同的形式。我们使用一个哈希表 $\textit{cnt}$ 来记录每个转换后的字符串出现的次数。
+
+最后，我们遍历哈希表，计算每个字符串出现次数 $v$ 的组合数 $\frac{v(v-1)}{2}$，将其累加到答案中。
+
+时间复杂度 $O(n \times m)$，空间复杂度 $O(n \times m)$。其中 $n$ 是字符串数组的长度，而 $m$ 是字符串的长度。
 
 <!-- tabs:start -->
 

solution/3800-3899/3805.Count Caesar Cipher Pairs/README_EN.md

@@ -84,7 +84,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3805.Co
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: String Transformation + Counting
+
+We can transform each string into a unified form. Specifically, we convert the first character of the string to `'z'`, and then transform the other characters in the string with the same offset. This way, all similar strings will be transformed into the same form. We use a hash table $\textit{cnt}$ to record the number of occurrences of each transformed string.
+
+Finally, we iterate through the hash table, calculate the combination number $\frac{v(v-1)}{2}$ for each string's occurrence count $v$, and add it to the answer.
+
+The time complexity is $O(n \times m)$ and the space complexity is $O(n \times m)$, where $n$ is the length of the string array and $m$ is the length of the strings.
 
 <!-- tabs:start -->
 

solution/3800-3899/3805.Count Caesar Cipher Pairs/Solution.java

@@ -6,7 +6,7 @@ public long countPairs(String[] words) {
             char[] t = s.toCharArray();
             int k = 'z' - t[0];
             for (int i = 1; i < t.length; i++) {
-                t[i] = (char)('a' + (t[i] - 'a' + k) % 26);
+                t[i] = (char) ('a' + (t[i] - 'a' + k) % 26);
             }
             t[0] = 'z';
             cnt.merge(new String(t), 1, Integer::sum);

solution/3800-3899/3806.Maximum Bitwise AND After Increment Operations/README.md

@@ -92,32 +92,172 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3806.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：试填法 + 位运算
+
+我们从最高位开始枚举每一位，尝试将该位加入最终的按位与结果中。对于当前尝试的按位与结果 $\textit{target}$，我们计算将数组中的每个元素增加到至少 $\textit{target}$ 所需的最小操作数。
+
+具体做法是找出 $\textit{target}$ 从高到低第一个位为 $1$，而当前元素对应位为 $0$ 的位置 $j - 1$，那么我们只需要将当前元素增加到 $\textit{target}$ 在低 $j$ 位的值即可，所需的操作数为 $(\textit{target} \& 2^{j} - 1) - (\textit{nums}[i] \& 2^{j} - 1)$。我们将所有元素所需的操作数存入数组 $\textit{cost}$ 中，并对其进行排序，取前 $m$ 个元素的操作数之和，如果不超过 $k$，则说明可以将按位与结果的该位加入最终结果中。
+
+时间复杂度 $O(n \times \log n \times \log M)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $\textit{nums}$ 的长度，而 $M$ 是数组 $\textit{nums}$ 中的最大值。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maximumAND(self, nums: List[int], k: int, m: int) -> int:
+        mx = (max(nums) + k).bit_length()
+        ans = 0
+        cost = [0] * len(nums)
+        for bit in range(mx - 1, -1, -1):
+            target = ans | (1 << bit)
+            for i, x in enumerate(nums):
+                j = (target & ~x).bit_length()
+                mask = (1 << j) - 1
+                cost[i] = (target & mask) - (x & mask)
+            cost.sort()
+            if sum(cost[:m]) <= k:
+                ans = target
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int maximumAND(int[] nums, int k, int m) {
+        int max = 0;
+        for (int x : nums) {
+            max = Math.max(max, x);
+        }
+        max += k;
+
+        int mx = 32 - Integer.numberOfLeadingZeros(max);
+        int n = nums.length;
+
+        int ans = 0;
+        int[] cost = new int[n];
+
+        for (int bit = mx - 1; bit >= 0; bit--) {
+            int target = ans | (1 << bit);
+            for (int i = 0; i < n; i++) {
+                int x = nums[i];
+                int diff = target & ~x;
+                int j = diff == 0 ? 0 : 32 - Integer.numberOfLeadingZeros(diff);
+                int mask = (1 << j) - 1;
+                cost[i] = (target & mask) - (x & mask);
+            }
+            Arrays.sort(cost);
+            long sum = 0;
+            for (int i = 0; i < m; i++) {
+                sum += cost[i];
+            }
+            if (sum <= k) {
+                ans = target;
+            }
+        }
+
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int maximumAND(const vector<int>& nums, int k, int m) {
+        int max_val = ranges::max(nums) + k;
+        int mx = max_val > 0 ? 32 - __builtin_clz(max_val) : 0;
+
+        int ans = 0;
+        vector<int> cost(nums.size());
+
+        for (int bit = mx - 1; bit >= 0; bit--) {
+            int target = ans | (1 << bit);
+            for (size_t i = 0; i < nums.size(); i++) {
+                int x = nums[i];
+                int diff = target & ~x;
+                int j = diff == 0 ? 0 : 32 - __builtin_clz(diff);
+                long long mask = (1L << j) - 1;
+                cost[i] = (target & mask) - (x & mask);
+            }
+
+            ranges::sort(cost);
+            long long sum = accumulate(cost.begin(), cost.begin() + m, 0LL);
+            if (sum <= k) {
+                ans = target;
+            }
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maximumAND(nums []int, k int, m int) int {
+	mx := bits.Len(uint(slices.Max(nums) + k))
+
+	ans := 0
+	cost := make([]int, len(nums))
+
+	for bit := mx - 1; bit >= 0; bit-- {
+		target := ans | (1 << bit)
+		for i, x := range nums {
+			j := bits.Len(uint(target & ^x))
+			mask := (1 << j) - 1
+			cost[i] = (target & mask) - (x & mask)
+		}
+		sort.Ints(cost)
+		sum := 0
+		for i := 0; i < m; i++ {
+			sum += cost[i]
+		}
+		if sum <= k {
+			ans = target
+		}
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function maximumAND(nums: number[], k: number, m: number): number {
+    const mx = 32 - Math.clz32(Math.max(...nums) + k);
+
+    let ans = 0;
+    const n = nums.length;
+    const cost = new Array(n);
+
+    for (let bit = mx - 1; bit >= 0; bit--) {
+        let target = ans | (1 << bit);
+        for (let i = 0; i < n; i++) {
+            const x = nums[i];
+            const diff = target & ~x;
+            const j = diff === 0 ? 0 : 32 - Math.clz32(diff);
+            const mask = (1 << j) - 1;
+            cost[i] = (target & mask) - (x & mask);
+        }
+        cost.sort((a, b) => a - b);
+        let sum = 0;
+        for (let i = 0; i < m; i++) {
+            sum += cost[i];
+        }
+        if (sum <= k) {
+            ans = target;
+        }
+    }
+
+    return ans;
+}
 ```
 
 <!-- tabs:end -->