Finding the Number of Visible Mountains - Problem

You are given a 0-indexed 2D integer array peaks where peaks[i] = [xi, yi] states that mountain i has a peak at coordinates (xi, yi).

A mountain can be described as a right-angled isosceles triangle, with its base along the x-axis and a right angle at its peak. More formally, the gradients of ascending and descending the mountain are 1 and -1 respectively.

A mountain is considered visible if its peak does not lie within another mountain (including the border of other mountains).

Return the number of visible mountains.

Input & Output

Example 1 — Basic Visibility

$ Input: peaks = [[2,1],[2,2],[1,4]]

› Output: 2

💡 Note: Mountain at (2,1) has base [1,3], mountain at (2,2) has base [0,4], mountain at (1,4) has base [-3,5]. The first mountain is completely contained within the second (same left boundary but smaller right), so only 2 mountains are visible.

Example 2 — All Visible

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

› Output: 3

💡 Note: Mountain bases are [-2,4], [0,2], [0,4]. No mountain completely contains another, so all 3 are visible.

Example 3 — Duplicate Peaks

$ Input: peaks = [[0,1],[1,0]]

› Output: 2

💡 Note: Peak (0,1) creates base [-1,1] and peak (1,0) creates base [1,1]. These are different ranges with no containment, so both mountains are visible.

Constraints

1 ≤ peaks.length ≤ 10⁵
peaks[i].length == 2
1 ≤ xi, yi ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is converting mountain peaks to base intervals and recognizing this as an interval containment problem. A mountain with peak (x,y) spans base [x-y, x+y]. The optimal monotonic stack approach sorts intervals and maintains visible mountains efficiently. Time: O(n log n), Space: O(n)

Common Approaches

✓ Greedy

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

Brute Force - Check All Pairs

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

Convert each mountain peak to its base range, then check every mountain against every other mountain to see if one completely contains another. A mountain with peak (x,y) has base from (x-y) to (x+y).

Monotonic Stack Approach

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

Sort mountains by left boundary and height, then use a stack to maintain currently visible mountains. When processing a new mountain, pop from stack all mountains that are completely contained by the new one.

Sort and Sweep

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

Convert peaks to base intervals, sort by left boundary, then sweep from left to right. Use the fact that if two mountains have the same left boundary, the wider one (larger right boundary) will hide the narrower one.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int peaks[1000][2];
static int peaksSize;

// Parse 2D array from string like "[[2,1],[2,2],[1,4]]"
void parse2DArray(const char* str) {
    peaksSize = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        if (*p == '[') {
            p++; // skip '['
            // Parse first number
            peaks[peaksSize][0] = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse second number
            peaks[peaksSize][1] = (int)strtol(p, (char**)&p, 10);
            
            // Skip to ']'
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            peaksSize++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
}

// Check if mountain i is hidden by mountain j
int isHidden(int i, int j) {
    int xi = peaks[i][0], yi = peaks[i][1];
    int xj = peaks[j][0], yj = peaks[j][1];
    
    // Mountain i is hidden by mountain j if:
    // 1. Mountain j completely contains mountain i
    // This happens when mountain j has same or higher peak and covers the base range of mountain i
    
    // For mountain at (x,y), the base extends from (x-y) to (x+y)
    int leftI = xi - yi, rightI = xi + yi;
    int leftJ = xj - yj, rightJ = xj + yj;
    
    // Mountain j hides mountain i if:
    // j's base completely covers i's base AND j's peak is at least as high
    return (leftJ <= leftI && rightI <= rightJ && yj >= yi);
}

int solution() {
    int visible = 0;
    
    for (int i = 0; i < peaksSize; i++) {
        int isVisible = 1;
        
        for (int j = 0; j < peaksSize; j++) {
            if (i != j && isHidden(i, j)) {
                isVisible = 0;
                break;
            }
        }
        
        if (isVisible) {
            visible++;
        }
    }
    
    return visible;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin) != NULL) {
        // Remove newline
        input[strcspn(input, "\n")] = 0;
        
        parse2DArray(input);
        int result = solution();
        printf("%d\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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