Adjacent Increasing Subarrays Detection II

Adjacent Increasing Subarrays Detection II - Problem

Imagine you're analyzing data patterns in a sequence of measurements. You need to find the maximum length of two consecutive patterns where both show a strictly increasing trend.

Given an array nums of n integers, find the maximum value of k such that there exist two adjacent subarrays of length k each, where both subarrays are strictly increasing.

Requirements:

Find two subarrays of length k starting at indices a and b where a < b
Both nums[a..a + k - 1] and nums[b..b + k - 1] must be strictly increasing
The subarrays must be adjacent: b = a + k
Return the maximum possible value of k

Example: For [2, 5, 7, 8, 9, 2, 3, 4, 3, 1], the answer is 3 because we can have subarrays [2, 5, 7] and [8, 9, 2]... wait, that's not right! We need [5, 7, 8] and [8, 9, 2] but [8, 9, 2] isn't increasing. Let's find valid adjacent increasing pairs!

Input & Output

example_1.py — Basic Case

$ Input: [2, 5, 7, 8, 9, 2, 3, 4, 3, 1]

› Output: 2

💡 Note: We can find subarrays [2, 5] and [7, 8] (both strictly increasing, length 2) or [7, 8] and [9, 2] but [9, 2] is decreasing. The maximum valid k is 2 with subarrays [2, 5] and [7, 8] at positions 0-1 and 2-3.

example_2.py — Perfect Case

$ Input: [1, 2, 3, 4, 5, 6]

› Output: 3

💡 Note: We can have [1, 2, 3] and [4, 5, 6], both strictly increasing subarrays of length 3.

example_3.py — No Valid Pairs

$ Input: [5, 4, 3, 2, 1]

› Output: 0

💡 Note: The array is strictly decreasing, so no increasing subarrays of length > 0 exist.

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

First, we map out all uphill sections and their lengths from each starting point

Binary Search Strategy

Instead of trying every route length, we use binary search - if routes of length k work, try longer; if not, try shorter

Quick Validation

Using our terrain map, we can quickly check if any position allows two consecutive uphill routes of length k

Find Maximum

Continue binary search until we find the maximum possible route length

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with preprocessing allows us to find the maximum length efficiently in O(n log n) time rather than O(n³) brute force.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) for trying different k values × O(n) for trying positions × O(n) to check if subarray is increasing

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Array contains at least 2 elements
Subarrays must be strictly increasing (no equal elements allowed)

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses binary search on the answer combined with preprocessing. We precompute the maximum length of increasing subarrays ending at each position, then binary search for the maximum k where two adjacent increasing subarrays of length k exist. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Lengths)	O(n³)	O(1)	Try every possible length k and check all positions for adjacent increasing subarrays
Binary Search + Preprocessing	O(n log n)	O(n)	Binary search on the answer k, with preprocessing to quickly check increasing subarrays

Brute Force (Try All Lengths) — Algorithm Steps

Try each length k from n/2 down to 1
For each k, try every valid starting position a
Check if subarray [a, a+k-1] is strictly increasing
Check if subarray [a+k, a+2k-1] is strictly increasing
Return the first k that works (maximum valid k)

Visualization

Tap to expand

Step-by-Step Walkthrough

Try k=3

Check all positions where two subarrays of length 3 can be adjacent

Check Position

Verify if both subarrays are strictly increasing

Continue

If not found, try k=2, then k=1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool isIncreasing(int* nums, int start, int length) {
    for (int i = start + 1; i < start + length; i++) {
        if (nums[i] <= nums[i - 1]) {
            return false;
        }
    }
    return true;
}

int maxIncreasingCells(int* nums, int n) {
    for (int k = n / 2; k >= 1; k--) {
        for (int a = 0; a <= n - 2 * k; a++) {
            if (isIncreasing(nums, a, k) && isIncreasing(nums, a + k, k)) {
                return k;
            }
        }
    }
    return 0;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c) >= 1) {
        n++;
        if (c == '\n') break;
    }
    printf("%d\n", maxIncreasingCells(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) for trying different k values × O(n) for trying positions × O(n) to check if subarray is increasing

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Array contains at least 2 elements
Subarrays must be strictly increasing (no equal elements allowed)

28.9K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Lengths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler