Minimum Number of Removals to Make Mountain Array

Minimum Number of Removals to Make Mountain Array - Problem

Mountain Array Transformation Challenge

Imagine you have an array of integers that you need to transform into a mountain array by removing the minimum number of elements. A mountain array is a special sequence that:

• Has at least 3 elements
• Strictly increases to a peak, then strictly decreases
• The peak cannot be at the first or last position

For example: [1, 3, 5, 4, 2] is a mountain (increases to 5, then decreases)

Your Goal: Given an integer array nums, find the minimum number of elements to remove to make it a valid mountain array.

Key Insight: This is essentially finding the longest mountain subsequence, then subtracting its length from the total array length!

Input & Output

example_1.py — Basic Mountain

$ Input: [1,3,1]

› Output: 0

💡 Note: The array [1,3,1] is already a perfect mountain - it increases to peak 3, then decreases. No removals needed!

example_2.py — Need to Remove Elements

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

› Output: 3

💡 Note: We can form mountain [1,5,6,2,1] by removing elements at positions 0,2,6. The mountain increases from 1→5→6, then decreases 6→2→1.

example_3.py — Minimum Length Case

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

› Output: 4

💡 Note: Best mountain is [1,2,3,1] with length 4, so we remove 8-4=4 elements. The mountain goes 1→2→3→1.

Visualization

Tap to expand

Understanding the Visualization

Identify Climbing Potential

For each position, calculate how long an increasing sequence can be that ends there

Identify Descending Potential

For each position, calculate how long a decreasing sequence can be that starts there

Find the Best Peak

Combine both calculations to find positions that can serve as mountain peaks

Calculate Removals

Subtract the longest mountain length from the total array length

Key Takeaway

🎯 Key Insight: Transform the problem into finding the longest mountain subsequence using LIS algorithms, then subtract from total length to get minimum removals.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
All elements in the final mountain must be strictly increasing then strictly decreasing

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses dynamic programming with binary search to find the longest mountain subsequence. We compute the Longest Increasing Subsequence (LIS) ending at each position and starting at each position. For any valid peak position, the mountain length is LIS_left + LIS_right - 1. The answer is array_length - max_mountain_length. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsequences)	O(2^n * n)	O(n)	Generate all subsequences and check which ones form valid mountains
Dynamic Programming with Binary Search (Optimal)	O(n log n)	O(n)	Use LIS algorithm with binary search to find longest increasing/decreasing subsequences

Brute Force (Try All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation (2^n possibilities)
For each subsequence with length ≥ 3, check if it's a valid mountain
A valid mountain has a peak where arr[0] < ... < arr[peak] > ... > arr[n-1]
Track the longest valid mountain found
Return original length minus longest mountain length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Use bit mask to generate all 2^n possible subsequences

Validate Mountain

Check if subsequence has valid mountain structure

Track Maximum

Keep track of longest valid mountain found

Code -

solution.c — C

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

bool isMountain(int* arr, int size) {
    if (size < 3) return false;
    
    for (int i = 1; i < size - 1; i++) {
        if (arr[i] > arr[i-1] && arr[i] > arr[i+1]) {
            bool increasing = true;
            for (int j = 0; j < i; j++) {
                if (arr[j] >= arr[j+1]) {
                    increasing = false;
                    break;
                }
            }
            
            bool decreasing = true;
            for (int j = i; j < size - 1; j++) {
                if (arr[j] <= arr[j+1]) {
                    decreasing = false;
                    break;
                }
            }
            
            if (increasing && decreasing) return true;
        }
    }
    return false;
}

int minimumMountainRemovals(int* nums, int numsSize) {
    if (numsSize < 3) return numsSize;
    
    int maxMountain = 0;
    int* subseq = (int*)malloc(numsSize * sizeof(int));
    
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subseqSize = 0;
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subseq[subseqSize++] = nums[i];
            }
        }
        
        if (isMountain(subseq, subseqSize)) {
            if (subseqSize > maxMountain) {
                maxMountain = subseqSize;
            }
        }
    }
    
    free(subseq);
    return numsSize - maxMountain;
}

int main() {
    int nums[] = {1, 3, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", minimumMountainRemovals(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
All elements in the final mountain must be strictly increasing then strictly decreasing

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.6K 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 Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler