Longest Mountain in Array

Longest Mountain in Array - Problem

You may recall that an array arr is a mountain array if and only if:

arr.length >= 3
There exists some index i (0-indexed) with 0 < i < arr.length - 1 such that:
- arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
- arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Given an integer array arr, return the length of the longest subarray which is a mountain.

Return 0 if there is no mountain subarray.

Input & Output

Example 1 — Basic Mountain

$ Input: arr = [2,1,4,7,3,2,5]

› Output: 5

💡 Note: The longest mountain is [1,4,7,3,2] with length 5. It goes up: 1<4<7, then down: 7>3>2.

Example 2 — No Mountain

$ Input: arr = [2,2,2]

› Output: 0

💡 Note: No mountain exists because all elements are equal. A mountain requires strictly increasing then decreasing.

Example 3 — Multiple Mountains

$ Input: arr = [0,1,2,3,4,5,4,3,2,1,0]

› Output: 11

💡 Note: The entire array forms one mountain: 0<1<2<3<4<5>4>3>2>1>0, length 11.

Constraints

1 ≤ arr.length ≤ 1000
0 ≤ arr[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 8 G Google 5

The key insight is that a mountain must have both strictly increasing and strictly decreasing parts. Best approach uses one pass tracking of up/down streaks. Time: O(n), Space: O(1)

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force

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

For each starting position, try all possible ending positions and check if the subarray forms a valid mountain (strictly increasing then strictly decreasing).

One Pass Solution

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

Use two variables to track current upward and downward streak lengths. When we find a complete mountain (up then down), update the maximum length.

Two Pass Solution

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

First pass calculates how far each position can extend upward. Second pass calculates downward extensions. Combine both to find mountain lengths.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solveNonDecreasing(int* nums, int n) {
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int range = maxVal - minVal + 201;
    int* prevDp = (int*)malloc(range * sizeof(int));
    int* currDp = (int*)malloc(range * sizeof(int));
    
    // Initialize for first position
    for (int i = 0; i < range; i++) {
        int val = minVal - 100 + i;
        prevDp[i] = abs(nums[0] - val);
    }
    
    // Process each position
    for (int pos = 1; pos < n; pos++) {
        for (int i = 0; i < range; i++) {
            currDp[i] = INT_MAX;
            int currVal = minVal - 100 + i;
            
            // For non-decreasing: current value >= previous value
            for (int j = 0; j <= i; j++) {
                if (prevDp[j] != INT_MAX) {
                    int cost = prevDp[j] + abs(nums[pos] - currVal);
                    if (cost < currDp[i]) {
                        currDp[i] = cost;
                    }
                }
            }
        }
        
        // Swap arrays
        int* temp = prevDp;
        prevDp = currDp;
        currDp = temp;
    }
    
    int result = INT_MAX;
    for (int i = 0; i < range; i++) {
        if (prevDp[i] < result) {
            result = prevDp[i];
        }
    }
    
    free(prevDp);
    free(currDp);
    return result;
}

int solveNonIncreasing(int* nums, int n) {
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int range = maxVal - minVal + 201;
    int* prevDp = (int*)malloc(range * sizeof(int));
    int* currDp = (int*)malloc(range * sizeof(int));
    
    // Initialize for first position
    for (int i = 0; i < range; i++) {
        int val = minVal - 100 + i;
        prevDp[i] = abs(nums[0] - val);
    }
    
    // Process each position
    for (int pos = 1; pos < n; pos++) {
        for (int i = 0; i < range; i++) {
            currDp[i] = INT_MAX;
            int currVal = minVal - 100 + i;
            
            // For non-increasing: current value <= previous value
            for (int j = i; j < range; j++) {
                if (prevDp[j] != INT_MAX) {
                    int cost = prevDp[j] + abs(nums[pos] - currVal);
                    if (cost < currDp[i]) {
                        currDp[i] = cost;
                    }
                }
            }
        }
        
        // Swap arrays
        int* temp = prevDp;
        prevDp = currDp;
        currDp = temp;
    }
    
    int result = INT_MAX;
    for (int i = 0; i < range; i++) {
        if (prevDp[i] < result) {
            result = prevDp[i];
        }
    }
    
    free(prevDp);
    free(currDp);
    return result;
}

int solution(int* nums, int n) {
    if (n <= 1) return 0;
    
    int nonDecCost = solveNonDecreasing(nums, n);
    int nonIncCost = solveNonIncreasing(nums, n);
    
    return nonDecCost < nonIncCost ? nonDecCost : nonIncCost;
}

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

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

67.9K Views

Medium Frequency

~25 min Avg. Time

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