Adjacent Increasing Subarrays Detection II

Adjacent Increasing Subarrays Detection II - Problem

Given an array nums of n integers, your task is to find the maximum value of k for which there exist two adjacent subarrays of length k each, such that both subarrays are strictly increasing.

Specifically, check if there are two subarrays of length k starting at indices a and b (a < b), where:

Both subarrays nums[a..a + k - 1] and nums[b..b + k - 1] are strictly increasing.
The subarrays must be adjacent, meaning b = a + k.

Return the maximum possible value of k. A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can find adjacent increasing subarrays of length 1, for example [2] at index 0 and [5] at index 1, both strictly increasing.

Example 2 — No Adjacent Pairs

$ Input: nums = [1,2,3,2,1]

› Output: 1

💡 Note: We can find adjacent increasing subarrays of length 1, for example [1] at index 0 and [2] at index 1, both strictly increasing.

Example 3 — Small Array

$ Input: nums = [1,2]

› Output: 0

💡 Note: Array is too small to have two adjacent subarrays of any positive length.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to precompute the length of increasing runs starting from each position, then use binary search to find the maximum k. The optimal approach has Time: O(n log n), Space: O(n).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n log n) Space: O(n)

Use binary search to find the maximum k. For each candidate k, use precomputed increasing lengths to efficiently check if two adjacent increasing subarrays of length k exist.

Brute Force

⏱️ Time: O(n³) Space: O(1)

For each possible length k from 1 to n/2, check every position to see if we can find two adjacent strictly increasing subarrays of length k.

Precompute Increasing Lengths

⏱️ Time: O(n²) Space: O(n)

First pass computes how long the increasing sequence is starting from each index. Second pass checks for adjacent pairs of sufficient length.

Binary Search on Answer — Algorithm Steps

Step 1: Precompute increasing run lengths from each position
Step 2: Binary search on possible k values
Step 3: For each k, check feasibility using precomputed lengths

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Search between left=0 and right=n/2

Check Feasibility

For each mid value, check if k=mid is possible

Narrow Range

Adjust search range based on feasibility

Code -

solution.c — C

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

bool canFindK(int* incLen, int k, int n) {
    for (int i = 0; i <= n - 2 * k; i++) {
        if (incLen[i] >= k && incLen[i + k] >= k) {
            return true;
        }
    }
    return false;
}

int solution(int* nums, int n) {
    if (n < 2) return 0;
    
    // Precompute increasing run lengths
    int* incLen = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        incLen[i] = 1;
    }
    
    for (int i = n - 2; i >= 0; i--) {
        if (nums[i] < nums[i + 1]) {
            incLen[i] = incLen[i + 1] + 1;
        }
    }
    
    int left = 0, right = n / 2;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canFindK(incLen, mid, n)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    free(incLen);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) preprocessing + O(log n) binary search iterations × O(n) feasibility check

⚠ Quadratic Growth

Space Complexity

O(n)

Array to store increasing run lengths from each position

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

234 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler