3349.检测相邻递增子数组 I:既然是I,那就先暴力模拟吧

【LetMeFly】3349.检测相邻递增子数组 I:既然是I,那就先暴力模拟吧

力扣题目链接:https://leetcode.cn/problems/adjacent-increasing-subarrays-detection-i/

给你一个由 n 个整数组成的数组 nums 和一个整数 k,请你确定是否存在 两个 相邻 且长度为 k严格递增 子数组。具体来说,需要检查是否存在从下标 ab (a < b) 开始的 两个 子数组,并满足下述全部条件:

  • 这两个子数组 nums[a..a + k - 1]nums[b..b + k - 1] 都是 严格递增 的。
  • 这两个子数组必须是 相邻的,即 b = a + k

如果可以找到这样的 两个 子数组,请返回 true;否则返回 false

子数组 是数组中的一个连续 非空 的元素序列。

 

示例 1:

输入:nums = [2,5,7,8,9,2,3,4,3,1], k = 3

输出:true

解释:

  • 从下标 2 开始的子数组为 [7, 8, 9],它是严格递增的。
  • 从下标 5 开始的子数组为 [2, 3, 4],它也是严格递增的。
  • 两个子数组是相邻的,因此结果为 true

示例 2:

输入:nums = [1,2,3,4,4,4,4,5,6,7], k = 5

输出:false

 

提示:

  • 2 <= nums.length <= 100
  • 1 <= 2 * k <= nums.length
  • -1000 <= nums[i] <= 1000

解题方法:模拟

写一个函数isOk判断nums数组从下标i开始是否为k个连续递增的。

接着枚举每一个“两连续递增数组的起点下标”,判断这个下标开始是否为两个连续的k个递增数组。

  • 时间复杂度$O(nk)$
  • 空间复杂度$O(1)$

AC代码

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
* @LastEditTime: 2025-10-14 20:18:02
*/
class Solution {
private:
inline bool isOk(vector<int>& nums, int i, int k) {
while (--k) {
if (nums[i] >= nums[++i]) {
return false;
}
}
return true;
}
public:
bool hasIncreasingSubarrays(vector<int>& nums, int k) {
int n = nums.size();
for (int i = 0; i + 2 * k <= n; i++) {
if (isOk(nums, i, k) && isOk(nums, i + k, k)) {
return true;
}
}
return false;
}
};

Python

1
2
3
4
5
6
7
8
9
10
11
12
'''
LastEditTime: 2025-10-14 20:21:32
'''
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)):
return True
return False

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
* @LastEditTime: 2025-10-14 20:31:34
*/
class Solution {
private boolean isOk(List<Integer> nums, int i, int k) {
while (--k > 0) {
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.size(); i++) { // List没有length方法
if (isOk(nums, i, k) && isOk(nums, i + k, k)) {
return true;
}
}
return false;
}
}

Go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
* @LastEditTime: 2025-10-14 20:26:58
*/
package main


func isOk3349(nums []int, i, k int) bool {
for j := 0; j + 1 < k; j++ {
if nums[i + j] >= nums[i + j + 1] {
return false
}
}
return true
}

func hasIncreasingSubarrays(nums []int, k int) bool {
for i := 0; i + 2 * k <= len(nums); i++ {
if isOk3349(nums, i, k) && isOk3349(nums, i + k, k) {
return true
}
}
return false
}

Rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
* @LastEditTime: 2025-10-14 20:37:25
*/
impl Solution {
fn is_ok(nums: &[i32], i: i32, k: i32) -> bool {
for i in i..i+k-1 {
if nums[i as usize] >= nums[(i + 1) as usize] {
return false
}
}
true
}

pub fn has_increasing_subarrays(nums: Vec<i32>, k: i32) -> bool {
for i in 0..nums.len()+1-(2*k) as usize {
if Self::is_ok(&nums, i as i32, k) && Self::is_ok(&nums, i as i32 + k, k) {
return true
}
}
false
}
}

同步发文于CSDN和我的个人博客,原创不易,转载经作者同意后请附上原文链接哦~

千篇源码题解已开源


3349.检测相邻递增子数组 I:既然是I,那就先暴力模拟吧
https://blog.letmefly.xyz/2025/10/14/LeetCode 3349.检测相邻递增子数组I/
作者
发布于
2025年10月14日
许可协议