feat: add solutions to lc problems: No.1004,2024 (#2574)

* No.1004.Max Consecutive Ones III
* No.2024.Maximize the Confusion of an Exam

Author: yanglbme

solution/1000-1099/1004.Max Consecutive Ones III/README.md

@@ -42,26 +42,13 @@
 
 ### 方法一：滑动窗口
 
-定义一个滑动窗口，窗口内的 $0$ 的个数不超过 $k$，窗口的右边界不断向右移动，当窗口内的 $0$ 的个数超过 $k$ 时，窗口的左边界向右移动，直到窗口内的 $0$ 的个数不超过 $k$ 为止。
+我们定义一个滑动窗口，窗口内的 $0$ 的个数不超过 $k$，窗口的右边界不断向右移动，当窗口内的 $0$ 的个数超过 $k$ 时，窗口的左边界向右移动，直到窗口内的 $0$ 的个数不超过 $k$ 为止。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。
 
 相似题目：
 
 -   [487. 最大连续 1 的个数 II](https://github.com/doocs/leetcode/blob/main/solution/0400-0499/0487.Max%20Consecutive%20Ones%20II/README.md)
-
-以下是滑动窗口的优化版本。
-
-维护一个单调变长的窗口。这种窗口经常出现在寻求“最大窗口”的问题中：因为求的是“最大”，所以我们没有必要缩短窗口，于是代码就少了缩短窗口的部分；从另一个角度讲，本题里的 K 是资源数，一旦透支，窗口就不能再增长了。
-
--   l 是窗口左端点，负责移动起始位置
--   r 是窗口右端点，负责扩展窗口
--   k 是资源数，每次要替换 0，k 减 1，同时 r 向右移动
--   `r++` 每次都会执行，`l++` 只有资源 `k < 0` 时才触发，因此 `r - l` 的值只会单调递增（或保持不变）
--   移动左端点时，如果当前元素是 0，说明可以释放一个资源，k 加 1
-
-相似题目：
-
 -   [2024. 考试的最大困扰度](https://github.com/doocs/leetcode/blob/main/solution/2000-2099/2024.Maximize%20the%20Confusion%20of%20an%20Exam/README.md)
 
 <!-- tabs:start -->
@@ -148,43 +135,33 @@ func longestOnes(nums []int, k int) int {
 ```ts
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
-    let l = 0;
-    for (const num of nums) {
-        if (num === 0) {
-            k--;
-        }
-        if (k < 0 && nums[l++] === 0) {
-            k++;
+    let [ans, cnt, j] = [0, 0, 0];
+    for (let i = 0; i < n; ++i) {
+        cnt += nums[i] ^ 1;
+        while (cnt > k) {
+            cnt -= nums[j++] ^ 1;
         }
+        ans = Math.max(ans, i - j + 1);
     }
-    return n - l;
-}
-```
-
-```rust
-impl Solution {
-    pub fn longest_ones(nums: Vec<i32>, mut k: i32) -> i32 {
-        let n = nums.len();
-        let mut l = 0;
-        for num in nums.iter() {
-            if num == &0 {
-                k -= 1;
-            }
-            if k < 0 {
-                if nums[l] == 0 {
-                    k += 1;
-                }
-                l += 1;
-            }
-        }
-        (n - l) as i32
-    }
+    return ans;
 }
 ```
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：滑动窗口（优化）
+
+以下是滑动窗口的优化版本。
+
+维护一个单调变长的窗口。这种窗口经常出现在寻求“最大窗口”的问题中：因为求的是“最大”，所以我们没有必要缩短窗口，于是代码就少了缩短窗口的部分；从另一个角度讲，本题里的 K 是资源数，一旦透支，窗口就不能再增长了。
+
+-   l 是窗口左端点，负责移动起始位置
+-   r 是窗口右端点，负责扩展窗口
+-   k 是资源数，每次要替换 0，k 减 1，同时 r 向右移动
+-   `r++` 每次都会执行，`l++` 只有资源 `k < 0` 时才触发，因此 `r - l` 的值只会单调递增（或保持不变）
+-   移动左端点时，如果当前元素是 0，说明可以释放一个资源，k 加 1
+
+时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -257,17 +234,36 @@ func longestOnes(nums []int, k int) int {
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
     let l = 0;
-    let res = k;
-    const count = [0, 0];
-    for (let r = 0; r < n; r++) {
-        count[nums[r]]++;
-        res = Math.max(res, r - l);
-        while (count[0] > k) {
-            count[nums[l]]--;
-            l++;
+    for (const num of nums) {
+        if (num === 0) {
+            k--;
+        }
+        if (k < 0 && nums[l++] === 0) {
+            k++;
+        }
+    }
+    return n - l;
+}
+```
+
+```rust
+impl Solution {
+    pub fn longest_ones(nums: Vec<i32>, mut k: i32) -> i32 {
+        let n = nums.len();
+        let mut l = 0;
+        for num in nums.iter() {
+            if num == &0 {
+                k -= 1;
+            }
+            if k < 0 {
+                if nums[l] == 0 {
+                    k += 1;
+                }
+                l += 1;
+            }
         }
+        (n - l) as i32
     }
-    return Math.max(res, n - l);
 }
 ```
 

solution/1000-1099/1004.Max Consecutive Ones III/README_EN.md

@@ -37,7 +37,16 @@ Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Sliding Window
+
+We define a sliding window, the number of $0$s in the window does not exceed $k$. The right boundary of the window keeps moving to the right. When the number of $0$s in the window exceeds $k$, the left boundary of the window moves to the right until the number of $0$s in the window does not exceed $k$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
+
+Similar problems:
+
+-   [487. Max Consecutive Ones II](https://github.com/doocs/leetcode/blob/main/solution/0400-0499/0487.Max%20Consecutive%20Ones%20II/README_EN.md)
+-   [2024. Maximize the Confusion of an Exam](https://github.com/doocs/leetcode/blob/main/solution/2000-2099/2024.Maximize%20the%20Confusion%20of%20an%20Exam/README_EN.md)
 
 <!-- tabs:start -->
 
@@ -123,43 +132,33 @@ func longestOnes(nums []int, k int) int {
 ```ts
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
-    let l = 0;
-    for (const num of nums) {
-        if (num === 0) {
-            k--;
+    let [ans, cnt, j] = [0, 0, 0];
+    for (let i = 0; i < n; ++i) {
+        cnt += nums[i] ^ 1;
+        while (cnt > k) {
+            cnt -= nums[j++] ^ 1;
         }
-        if (k < 0 && nums[l++] === 0) {
-            k++;
-        }
-    }
-    return n - l;
-}
-```
-
-```rust
-impl Solution {
-    pub fn longest_ones(nums: Vec<i32>, mut k: i32) -> i32 {
-        let n = nums.len();
-        let mut l = 0;
-        for num in nums.iter() {
-            if num == &0 {
-                k -= 1;
-            }
-            if k < 0 {
-                if nums[l] == 0 {
-                    k += 1;
-                }
-                l += 1;
-            }
-        }
-        (n - l) as i32
+        ans = Math.max(ans, i - j + 1);
     }
+    return ans;
 }
 ```
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Sliding Window (Optimized)
+
+Below is the optimized version of the sliding window.
+
+Maintain a monotonically variable-length window. This kind of window often appears in problems seeking the "maximum window": because we are seeking the "maximum", there is no need to shorten the window, so the code lacks the part to shorten the window; from another perspective, the K in this problem is the number of resources, once overdrawn, the window can no longer grow.
+
+-   `l` is the left endpoint of the window, responsible for moving the starting position
+-   `r` is the right endpoint of the window, responsible for expanding the window
+-   `k` is the number of resources, each time a 0 needs to be replaced, `k` decreases by 1, and `r` moves to the right at the same time
+-   `r++` will be executed every time, `l++` is only triggered when the resource `k < 0`, therefore the value of `r - l` will only increase monotonically (or remain unchanged)
+-   When moving the left endpoint, if the current element is 0, it means that a resource can be released, `k` increases by 1
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -232,17 +231,36 @@ func longestOnes(nums []int, k int) int {
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
     let l = 0;
-    let res = k;
-    const count = [0, 0];
-    for (let r = 0; r < n; r++) {
-        count[nums[r]]++;
-        res = Math.max(res, r - l);
-        while (count[0] > k) {
-            count[nums[l]]--;
-            l++;
+    for (const num of nums) {
+        if (num === 0) {
+            k--;
+        }
+        if (k < 0 && nums[l++] === 0) {
+            k++;
+        }
+    }
+    return n - l;
+}
+```
+
+```rust
+impl Solution {
+    pub fn longest_ones(nums: Vec<i32>, mut k: i32) -> i32 {
+        let n = nums.len();
+        let mut l = 0;
+        for num in nums.iter() {
+            if num == &0 {
+                k -= 1;
+            }
+            if k < 0 {
+                if nums[l] == 0 {
+                    k += 1;
+                }
+                l += 1;
+            }
         }
+        (n - l) as i32
     }
-    return Math.max(res, n - l);
 }
 ```
 

solution/1000-1099/1004.Max Consecutive Ones III/Solution.ts

@@ -1,13 +1,12 @@
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
-    let l = 0;
-    for (const num of nums) {
-        if (num === 0) {
-            k--;
-        }
-        if (k < 0 && nums[l++] === 0) {
-            k++;
+    let [ans, cnt, j] = [0, 0, 0];
+    for (let i = 0; i < n; ++i) {
+        cnt += nums[i] ^ 1;
+        while (cnt > k) {
+            cnt -= nums[j++] ^ 1;
         }
+        ans = Math.max(ans, i - j + 1);
     }
-    return n - l;
+    return ans;
 }

solution/1000-1099/1004.Max Consecutive Ones III/Solution.rs solution/1000-1099/1004.Max Consecutive Ones III/Solution2.rs

@@ -1,15 +1,13 @@
 function longestOnes(nums: number[], k: number): number {
     const n = nums.length;
     let l = 0;
-    let res = k;
-    const count = [0, 0];
-    for (let r = 0; r < n; r++) {
-        count[nums[r]]++;
-        res = Math.max(res, r - l);
-        while (count[0] > k) {
-            count[nums[l]]--;
-            l++;
+    for (const num of nums) {
+        if (num === 0) {
+            k--;
+        }
+        if (k < 0 && nums[l++] === 0) {
+            k++;
         }
     }
-    return Math.max(res, n - l);
+    return n - l;
 }