Count the Number of Incremovable Subarrays I

Count the Number of Incremovable Subarrays I - Problem

You're given a 0-indexed array of positive integers nums. Your task is to count how many subarrays can be removed to make the remaining array strictly increasing.

A subarray is called incremovable if removing it results in a strictly increasing sequence. For example, in the array [5, 3, 4, 6, 7], removing the subarray [3, 4] gives us [5, 6, 7], which is strictly increasing.

Key points:

A subarray is a contiguous sequence of elements
An empty array is considered strictly increasing
You need to count all possible incremovable subarrays

Return the total number of incremovable subarrays in the given array.

Input & Output

example_1.py — Basic case

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

› Output: 10

💡 Note: Array is already strictly increasing. 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], [6,3], [3,7], [7,11], [6,3,7], [3,7,11] to get valid increasing sequences. Total = 9 subarrays.

example_3.py — Single element

$ Input: [5]

› Output: 1

💡 Note: Only one subarray [5] can be removed, leaving an empty array which is considered strictly increasing.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
All elements are positive integers
Subarray must be contiguous and non-empty

Visualization

Tap to expand

Understanding the Visualization

Identify prefix

Find the longest increasing sequence from the start

Identify suffix

Find the longest increasing sequence from the end

Count removals

Count all valid ways to remove middle elements

Verify connections

Ensure prefix and suffix can connect properly

Key Takeaway

🎯 Key Insight: The optimal approach leverages the fact that after removing any subarray, we're left with a prefix and suffix that must connect to form a strictly increasing sequence. By pre-computing the longest increasing prefix and suffix, we can efficiently count all valid removal combinations.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

This problem can be solved efficiently using a two-pointers approach that identifies the longest increasing prefix and suffix. The key insight is that after removing a subarray, we need the remaining prefix and suffix to form a strictly increasing sequence. The optimal O(n²) solution avoids the brute force O(n³) approach by leveraging the structure of increasing sequences.

Common Approaches

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

Two Pointers Optimization — Algorithm Steps

Find the longest strictly increasing prefix from left
Find the longest strictly increasing suffix from right
Use two pointers to count valid subarray removals
Handle cases where prefix and suffix can connect

Visualization

Tap to expand

Step-by-Step Walkthrough

Find increasing prefix

Scan from left until sequence breaks

Find increasing suffix

Scan from right until sequence breaks

Count combinations

Use two pointers to count valid removals

Handle connections

Check if prefix and suffix can connect

Code -

solution.c — C

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

int incremovableSubarrayCount(int* nums, int n) {
    // Find longest increasing prefix
    int prefixLen = 1;
    while (prefixLen < n && nums[prefixLen] > nums[prefixLen - 1]) {
        prefixLen++;
    }
    
    // If entire array is increasing, all subarrays are removable
    if (prefixLen == n) {
        return n * (n + 1) / 2;
    }
    
    // Find longest increasing suffix
    int suffixStart = n - 1;
    while (suffixStart > 0 && nums[suffixStart] > nums[suffixStart - 1]) {
        suffixStart--;
    }
    
    int count = 0;
    
    // Count subarrays that remove entire suffix or more
    count += prefixLen + 1;
    
    // Count subarrays that keep some suffix
    for (int j = suffixStart; j < n; j++) {
        int left = 0;
        while (left < prefixLen && nums[left] < nums[j]) {
            left++;
        }
        count += left + 1;
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to find prefix/suffix + O(n²) to count valid combinations with two pointers

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track pointers and boundaries

✓ Linear Space

28.9K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler