feat: add solutions to lc problem: No.2760 (doocs#1966)

yanglbme · web-flow · commit 6e704f28b2f4 · 2023-11-14T21:40:18.000+08:00
No.2760.Longest Even Odd Subarray With Threshold
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/README.md b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/README.md
@@ -65,7 +65,13 @@
 
 我们在 $[0,..n-1]$ 范围内枚举所有 $l$，如果 $nums[l]$ 满足 $nums[l] \bmod 2 = 0$ 并且 $nums[l] \leq threshold$，那么我们就从 $l+1$ 开始，查找最大的满足条件的 $r$，那么此时以 $nums[l]$ 作为左端点的最长奇偶子数组的长度为 $r - l$，取所有 $r - l$ 的最大值作为答案即可。
 
-时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。
+时间复杂度 $O(n^2)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
+
+**方法二：枚举优化**
+
+我们注意到，题目实际上会把数组划分成不相交的若干个满足条件的子数组，我们只需要找到这些子数组中最长的一个即可。因此，在枚举 $l$ 和 $r$ 时，我们不需要回退，只需要从左往右遍历一遍即可。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -86,6 +92,22 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:
+        ans, l, n = 0, 0, len(nums)
+        while l < n:
+            if nums[l] % 2 == 0 and nums[l] <= threshold:
+                r = l + 1
+                while r < n and nums[r] % 2 != nums[r - 1] % 2 and nums[r] <= threshold:
+                    r += 1
+                ans = max(ans, r - l)
+                l = r
+            else:
+                l += 1
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -108,6 +130,27 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int longestAlternatingSubarray(int[] nums, int threshold) {
+        int ans = 0;
+        for (int l = 0, n = nums.length; l < n;) {
+            if (nums[l] % 2 == 0 && nums[l] <= threshold) {
+                int r = l + 1;
+                while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
+                    ++r;
+                }
+                ans = Math.max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -129,11 +172,33 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int longestAlternatingSubarray(vector<int>& nums, int threshold) {
+        int ans = 0;
+        for (int l = 0, n = nums.size(); l < n;) {
+            if (nums[l] % 2 == 0 && nums[l] <= threshold) {
+                int r = l + 1;
+                while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
+                    ++r;
+                }
+                ans = max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
-func longestAlternatingSubarray(nums []int, threshold int) int {
-	ans, n := 0, len(nums)
+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {
+	n := len(nums)
 	for l := range nums {
 		if nums[l]%2 == 0 && nums[l] <= threshold {
 			r := l + 1
@@ -143,7 +208,25 @@ func longestAlternatingSubarray(nums []int, threshold int) int {
 			ans = max(ans, r-l)
 		}
 	}
-	return ans
+	return
+}
+```
+
+```go
+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {
+	for l, n := 0, len(nums); l < n; {
+		if nums[l]%2 == 0 && nums[l] <= threshold {
+			r := l + 1
+			for r < n && nums[r]%2 != nums[r-1]%2 && nums[r] <= threshold {
+				r++
+			}
+			ans = max(ans, r-l)
+			l = r
+		} else {
+			l++
+		}
+	}
+	return
 }
 ```
 
@@ -166,6 +249,26 @@ function longestAlternatingSubarray(nums: number[], threshold: number): number {
 }
 ```
 
+```ts
+function longestAlternatingSubarray(nums: number[], threshold: number): number {
+    const n = nums.length;
+    let ans = 0;
+    for (let l = 0; l < n; ) {
+        if (nums[l] % 2 === 0 && nums[l] <= threshold) {
+            let r = l + 1;
+            while (r < n && nums[r] % 2 !== nums[r - 1] % 2 && nums[r] <= threshold) {
+                ++r;
+            }
+            ans = Math.max(ans, r - l);
+            l = r;
+        } else {
+            ++l;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/README_EN.md b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/README_EN.md
@@ -57,6 +57,18 @@ Hence, the answer is the length of the subarray, 3. We can show that 3 is the ma
 
 ## Solutions
 
+**Solution 1: Enumeration**
+
+We enumerate all $l$ in the range $[0,..n-1]$. If $nums[l]$ satisfies $nums[l] \bmod 2 = 0$ and $nums[l] \leq threshold$, then we start from $l+1$ to find the largest $r$ that meets the condition. At this time, the length of the longest odd-even subarray with $nums[l]$ as the left endpoint is $r - l$. We take the maximum of all $r - l$ as the answer.
+
+The time complexity is $O(n^2)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
+**Solution 2: Optimized Enumeration**
+
+We notice that the problem actually divides the array into several disjoint subarrays that meet the condition. We only need to find the longest one among these subarrays. Therefore, when enumerating $l$ and $r$, we don't need to backtrack, we just need to traverse from left to right once.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -74,6 +86,22 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:
+        ans, l, n = 0, 0, len(nums)
+        while l < n:
+            if nums[l] % 2 == 0 and nums[l] <= threshold:
+                r = l + 1
+                while r < n and nums[r] % 2 != nums[r - 1] % 2 and nums[r] <= threshold:
+                    r += 1
+                ans = max(ans, r - l)
+                l = r
+            else:
+                l += 1
+        return ans
+```
+
 ### **Java**
 
 ```java
@@ -94,6 +122,27 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int longestAlternatingSubarray(int[] nums, int threshold) {
+        int ans = 0;
+        for (int l = 0, n = nums.length; l < n;) {
+            if (nums[l] % 2 == 0 && nums[l] <= threshold) {
+                int r = l + 1;
+                while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
+                    ++r;
+                }
+                ans = Math.max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -115,11 +164,33 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int longestAlternatingSubarray(vector<int>& nums, int threshold) {
+        int ans = 0;
+        for (int l = 0, n = nums.size(); l < n;) {
+            if (nums[l] % 2 == 0 && nums[l] <= threshold) {
+                int r = l + 1;
+                while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
+                    ++r;
+                }
+                ans = max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
-func longestAlternatingSubarray(nums []int, threshold int) int {
-	ans, n := 0, len(nums)
+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {
+	n := len(nums)
 	for l := range nums {
 		if nums[l]%2 == 0 && nums[l] <= threshold {
 			r := l + 1
@@ -129,7 +200,25 @@ func longestAlternatingSubarray(nums []int, threshold int) int {
 			ans = max(ans, r-l)
 		}
 	}
-	return ans
+	return
+}
+```
+
+```go
+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {
+	for l, n := 0, len(nums); l < n; {
+		if nums[l]%2 == 0 && nums[l] <= threshold {
+			r := l + 1
+			for r < n && nums[r]%2 != nums[r-1]%2 && nums[r] <= threshold {
+				r++
+			}
+			ans = max(ans, r-l)
+			l = r
+		} else {
+			l++
+		}
+	}
+	return
 }
 ```
 
@@ -152,6 +241,26 @@ function longestAlternatingSubarray(nums: number[], threshold: number): number {
 }
 ```
 
+```ts
+function longestAlternatingSubarray(nums: number[], threshold: number): number {
+    const n = nums.length;
+    let ans = 0;
+    for (let l = 0; l < n; ) {
+        if (nums[l] % 2 === 0 && nums[l] <= threshold) {
+            let r = l + 1;
+            while (r < n && nums[r] % 2 !== nums[r - 1] % 2 && nums[r] <= threshold) {
+                ++r;
+            }
+            ans = Math.max(ans, r - l);
+            l = r;
+        } else {
+            ++l;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.cpp b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.cpp
@@ -1,14 +1,17 @@
 class Solution {
 public:
     int longestAlternatingSubarray(vector<int>& nums, int threshold) {
-        int ans = 0, n = nums.size();
-        for (int l = 0; l < n; ++l) {
+        int ans = 0;
+        for (int l = 0, n = nums.size(); l < n;) {
             if (nums[l] % 2 == 0 && nums[l] <= threshold) {
                 int r = l + 1;
                 while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
                     ++r;
                 }
                 ans = max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
             }
         }
         return ans;
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.go b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.go
@@ -1,13 +1,15 @@
-func longestAlternatingSubarray(nums []int, threshold int) int {
-	ans, n := 0, len(nums)
-	for l := range nums {
+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {
+	for l, n := 0, len(nums); l < n; {
 		if nums[l]%2 == 0 && nums[l] <= threshold {
 			r := l + 1
 			for r < n && nums[r]%2 != nums[r-1]%2 && nums[r] <= threshold {
 				r++
 			}
 			ans = max(ans, r-l)
+			l = r
+		} else {
+			l++
 		}
 	}
-	return ans
+	return
 }
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.java b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.java
@@ -1,13 +1,16 @@
 class Solution {
     public int longestAlternatingSubarray(int[] nums, int threshold) {
-        int ans = 0, n = nums.length;
-        for (int l = 0; l < n; ++l) {
+        int ans = 0;
+        for (int l = 0, n = nums.length; l < n;) {
             if (nums[l] % 2 == 0 && nums[l] <= threshold) {
                 int r = l + 1;
                 while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {
                     ++r;
                 }
                 ans = Math.max(ans, r - l);
+                l = r;
+            } else {
+                ++l;
             }
         }
         return ans;
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.py b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.py
@@ -1,10 +1,13 @@
 class Solution:
     def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:
-        ans, n = 0, len(nums)
-        for l in range(n):
+        ans, l, n = 0, 0, len(nums)
+        while l < n:
             if nums[l] % 2 == 0 and nums[l] <= threshold:
                 r = l + 1
                 while r < n and nums[r] % 2 != nums[r - 1] % 2 and nums[r] <= threshold:
                     r += 1
                 ans = max(ans, r - l)
+                l = r
+            else:
+                l += 1
         return ans
diff --git a/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.ts b/solution/2700-2799/2760.Longest Even Odd Subarray With Threshold/Solution.ts

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,15 @@`
`1`		`-func longestAlternatingSubarray(nums []int, threshold int) int {`
`2`		`- ans, n := 0, len(nums)`
`3`		`- for l := range nums {`
	`1`	`+func longestAlternatingSubarray(nums []int, threshold int) (ans int) {`
	`2`	`+ for l, n := 0, len(nums); l < n; {`
`4`	`3`	`if nums[l]%2 == 0 && nums[l] <= threshold {`
`5`	`4`	`r := l + 1`
`6`	`5`	`for r < n && nums[r]%2 != nums[r-1]%2 && nums[r] <= threshold {`
`7`	`6`	`r++`
`8`	`7`	`}`
`9`	`8`	`ans = max(ans, r-l)`
	`9`	`+ l = r`
	`10`	`+ } else {`
	`11`	`+ l++`
`10`	`12`	`}`
`11`	`13`	`}`
`12`		`- return ans`
	`14`	`+ return`
`13`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,16 @@`
`1`	`1`	`class Solution {`
`2`	`2`	`public int longestAlternatingSubarray(int[] nums, int threshold) {`
`3`		`- int ans = 0, n = nums.length;`
`4`		`- for (int l = 0; l < n; ++l) {`
	`3`	`+ int ans = 0;`
	`4`	`+ for (int l = 0, n = nums.length; l < n;) {`
`5`	`5`	`if (nums[l] % 2 == 0 && nums[l] <= threshold) {`
`6`	`6`	`int r = l + 1;`
`7`	`7`	`while (r < n && nums[r] % 2 != nums[r - 1] % 2 && nums[r] <= threshold) {`
`8`	`8`	`++r;`
`9`	`9`	`}`
`10`	`10`	`ans = Math.max(ans, r - l);`
	`11`	`+ l = r;`
	`12`	`+ } else {`
	`13`	`+ ++l;`
`11`	`14`	`}`
`12`	`15`	`}`
`13`	`16`	`return ans;`