Count the Number of Incremovable Subarrays II

Count the Number of Incremovable Subarrays II - Problem

You're given a 0-indexed array of positive integers nums. Your task is to find all possible incremovable subarrays - subarrays that, when removed, make the remaining array strictly increasing.

An incremovable subarray is any contiguous sequence of elements that you can delete to transform the array into a strictly increasing sequence. For example, in the array [5, 3, 4, 6, 7], removing the subarray [3, 4] results in [5, 6, 7], which is strictly increasing.

Goal: Return the total count of all incremovable subarrays in the given array.

Note: An empty array is considered strictly increasing, and a subarray must contain at least one element.

Input & Output

example_1.py — Basic Case

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

› Output: 10

💡 Note: The array is already strictly increasing, so we can remove any subarray: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], [1,2,3,4]. Total = 10 subarrays.

example_2.py — Mixed Case

$ Input: [6, 3, 7, 11]

› Output: 9

💡 Note: We can remove: [6], [3], [7], [11] (removing single elements), [6,3], [3,7], [7,11] (removing pairs), [6,3,7] and [6,3,7,11] (removing larger subarrays). Total = 9 subarrays.

example_3.py — Edge Case

$ Input: [10, 5, 7]

› Output: 6

💡 Note: Valid removals: [10] → [5,7] ✓, [5] → [10,7] ✗, [7] → [10,5] ✗, [10,5] → [7] ✓, [5,7] → [10] ✓, [10,5,7] → [] ✓. Actually valid: [10], [10,5], [5,7], [10,5,7] = 4 subarrays. Need to recount: all 6 possible subarrays work in different ways.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers
Array is 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Identify Good Segments

Find the longest increasing sequences from both ends of the assembly line

Mark Defective Areas

The middle section between good segments contains defects that can be removed

Count Removal Options

Calculate how many different ways we can remove defective segments

Optimize Production

Each valid removal results in a perfect increasing quality sequence

Key Takeaway

🎯 Key Insight: By identifying the natural increasing boundaries in the array, we can mathematically calculate all valid subarray removals without explicitly checking each one, reducing complexity from O(n³) to O(n).

Asked in

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

The optimal solution uses two pointers to find the longest increasing prefix and suffix in O(n) time. Instead of checking every possible subarray removal (O(n³)), we mathematically count valid combinations by identifying the boundaries where removals preserve the strictly increasing property. The key insight is that any removal between these boundaries will maintain the increasing sequence.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Find longest increasing prefix and suffix, then count valid removal combinations
Brute Force (Check All Subarrays)	O(n³)	O(n)	Try removing every possible subarray and check if remaining array is strictly increasing

Two Pointers (Optimal) — Algorithm Steps

Find the longest increasing prefix from left
Find the longest increasing suffix from right
Handle special cases where array is already sorted
For each position in prefix, find valid suffix positions using binary search or two pointers
Count all valid removal combinations mathematically

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Increasing Prefix

Identify longest increasing sequence from left

Find Increasing Suffix

Identify longest increasing sequence from right

Calculate Valid Combinations

Count all valid subarray removals mathematically

Handle Edge Cases

Special handling for fully sorted arrays

Code -

solution.c — C

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

long long countIncremovableSubarrays(int* nums, int n) {
    // Find longest increasing prefix
    int prefixLen = 0;
    for (int i = 0; i < n - 1; i++) {
        if (nums[i] < nums[i + 1]) {
            prefixLen = i + 1;
        } else {
            break;
        }
    }
    
    if (prefixLen == n - 1) prefixLen = n;
    
    // If entire array is increasing
    if (prefixLen == n) {
        return (long long) n * (n + 1) / 2;
    }
    
    // Find longest increasing suffix
    int suffixStart = n;
    for (int i = n - 1; i > 0; i--) {
        if (nums[i - 1] < nums[i]) {
            suffixStart = i - 1;
        } else {
            break;
        }
    }
    
    long long count = 0;
    
    // Count different scenarios
    count += prefixLen + 1;
    count += n - suffixStart;
    
    int j = suffixStart;
    for (int i = 0; i <= prefixLen; i++) {
        while (j < n && (i == 0 || nums[i - 1] >= nums[j])) {
            j++;
        }
        count += n - j;
    }
    
    return count;
}

int main() {
    int nums[100000];
    int n = 0;
    int x;
    
    while (scanf("%d", &x) == 1) {
        nums[n++] = x;
    }
    
    printf("%lld\n", countIncremovableSubarrays(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find prefix/suffix + O(n) to count valid combinations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and counters

✓ Linear Space

42.5K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler