update: 添加问题“3350.检测相邻递增子数组II”的代码和题解 (#1174)

3350: AC.cpp (#1173)

WA.cpp+py+go+java+rust
AC.cpp - AC,5.12%,21.99%
WA.cpp - 写法2
AC.cpp - 写法2,AC,98.49%,48.80%
AC.py - AC,32.38%,85.24%
AC.go - AC,91.89%,54.05%
AC.java - AC,36.99%,75.72%
AC.rust - AC,100.00%,20.00%

Signed-off-by: LetMeFly666 <[email protected]>

Author: LetMeFly666

.commitmsg

@@ -1,12 +1,10 @@
-word: en+jp (#1169)
+3350: AC.cpp (#1173)
 
-en: 2025.10.12+2025.10.14（10.13背了但是没遇见生词）
-
-3349: AC.cpp+py+go+java+rust
-cpp - AC,85.94%,46.88%
-WA.py
-py - AC,80.43%,19.57%
-go - AC,12.50%,87.50%
-CE.java
-java - AC,100.00%,25.58%
-rust - AC,-%,100.00%
+WA.cpp+py+go+java+rust
+AC.cpp - AC,5.12%,21.99%
+WA.cpp - 写法2
+AC.cpp - 写法2,AC,98.49%,48.80%
+AC.py - AC,32.38%,85.24%
+AC.go - AC,91.89%,54.05%
+AC.java - AC,36.99%,75.72%
+AC.rust - AC,100.00%,20.00%

Codes/3349-adjacent-increasing-subarrays-detection-i.java

@@ -2,21 +2,21 @@
  * @Author: LetMeFly
  * @Date: 2025-10-14 20:14:45
  * @LastEditors: LetMeFly.xyz
- * @LastEditTime: 2025-10-14 20:30:13
+ * @LastEditTime: 2025-10-14 20:41:48
  */
-// THIS IS NOT RIGHT
+// THIS IS RIGHT
 class Solution {
     private boolean isOk(List<Integer> nums, int i, int k) {
         while (--k > 0) {
-            if (nums[i] >= nums[++i]) {
+            if (nums.get(i) >= nums.get(++i)) {
                 return false;
             }
         }
         return true;
     }
 
     public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {
-        for (int i = 0; i + 2 * k <= nums.length(); i++) {
+        for (int i = 0; i + 2 * k <= nums.size(); i++) {  // List没有length方法
             if (isOk(nums, i, k) && isOk(nums, i + k, k)) {
                 return true;
             }

Codes/3349-adjacent-increasing-subarrays-detection-i.py

@@ -2,14 +2,14 @@
 Author: LetMeFly
 Date: 2025-10-14 20:14:45
 LastEditors: LetMeFly.xyz
-LastEditTime: 2025-10-14 20:21:32
+LastEditTime: 2025-10-14 20:24:03
 '''
 from typing import List
 
 # THIS IS NOT RIGHT
 class Solution:
     def hasIncreasingSubarrays(self, nums: List[int], k: int) -> bool:
         for i in range(len(nums) - 2 * k + 1):
-            if all(nums[j + 1] > nums[j] for j in range(i, i + k)) and all(nums[j + 1] > nums[j] for j in range(i + k, i + k * 2)):
+            if all(nums[j + 1] > nums[j] for j in range(i, i + k - 1)) and all(nums[j + 1] > nums[j] for j in range(i + k, i + k * 2 - 1)):
                 return True
         return False

Codes/3349-adjacent-increasing-subarrays-detection-i_right.java

@@ -0,0 +1,29 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-10-15 22:07:17
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-10-15 22:12:42
+ */
+#if defined(_WIN32) || defined(__APPLE__)
+#include "_[1,2]toVector.h"
+#endif
+
+// THIS IS NOT RIGHT
+class Solution {
+public:
+    int maxIncreasingSubarrays(vector<int>& nums) {
+        int ans = 1;
+        int lastVal = 1000000001, lastCnt = 0, nowCnt = 0;
+        for (int t : nums) {
+            if (t <= lastVal) {
+                ans = max(ans, min(lastCnt, nowCnt));
+                ans = max(ans, nowCnt / 2);
+                lastCnt = nowCnt, nowCnt = 0;
+            } else {
+                nowCnt++;
+            }
+            lastVal = t;
+        }
+        return ans;
+    }
+};

Codes/3349-adjacent-increasing-subarrays-detection-i_right.py

@@ -0,0 +1,20 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-10-15 22:07:17
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-10-15 22:25:04
+ */
+package main
+
+// 我发现nowCnt特别容易打成nowCNt
+func maxIncreasingSubarrays(nums []int) int {
+    ans, lastCnt, nowCnt := 0, 0, 0
+    for i, t := range nums {
+        nowCnt++
+        if i == len(nums) - 1 || t >= nums[i + 1] {
+            ans = max(ans, max(min(lastCnt, nowCnt), nowCnt / 2))
+            lastCnt, nowCnt = nowCnt, 0
+        }
+    }
+    return ans
+}

Codes/3350-adjacent-increasing-subarrays-detection-ii.cpp

@@ -0,0 +1,20 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-10-15 22:07:17
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-10-15 22:28:53
+ */
+class Solution {
+    public int maxIncreasingSubarrays(List<Integer> nums) {
+        int ans = 0;
+        for (int i = 0, lastCnt = 0, nowCnt = 0; i < nums.size(); i++) {
+            nowCnt++;
+            if (i == nums.size() - 1 || nums.get(i) >= nums.get(i + 1)) {  // 昨天踩过的bug今天不会再踩一次
+                ans = Math.max(ans, Math.max(Math.min(lastCnt, nowCnt), nowCnt / 2));
+                lastCnt = nowCnt;
+                nowCnt = 0;
+            }
+        }
+        return ans;
+    }
+}

Codes/3350-adjacent-increasing-subarrays-detection-ii.go

@@ -0,0 +1,18 @@
+'''
+Author: LetMeFly
+Date: 2025-10-15 22:07:17
+LastEditors: LetMeFly.xyz
+LastEditTime: 2025-10-15 22:23:10
+'''
+from typing import List
+
+class Solution:
+    def maxIncreasingSubarrays(self, nums: List[int]) -> int:
+        ans = lastCnt = nowCnt = 0
+        for i in range(len(nums)):
+            nowCnt += 1
+            if i == len(nums) - 1 or nums[i] >= nums[i + 1]:
+                ans = max(ans, min(lastCnt, nowCnt), nowCnt // 2)
+                lastCnt = nowCnt
+                nowCnt = 0
+        return ans

Codes/3350-adjacent-increasing-subarrays-detection-ii.java

@@ -0,0 +1,23 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-10-15 22:07:17
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-10-15 22:32:24
+ */
+impl Solution {
+    pub fn max_increasing_subarrays(nums: Vec<i32>) -> i32 {
+        let mut ans: i32 = 0;
+        let mut last_cnt: i32 = 0;
+        let mut now_cnt: i32 = 0;
+        for i in 0..nums.len() {
+            now_cnt += 1;
+            if i == nums.len() - 1 || nums[i] >= nums[i + 1] {
+                ans = ans.max(last_cnt.min(now_cnt)).max(now_cnt / 2);
+                // (last_cnt, now_cnt) = (now_cnt, 0);
+                last_cnt = now_cnt;
+                now_cnt = 0;
+            }
+        }
+        ans
+    }
+}