Buildings With an Ocean View

Buildings With an Ocean View - Problem

There are n buildings in a line. You are given an integer array heights of size n that represents the heights of the buildings in the line.

The ocean is to the right of the buildings. A building has an ocean view if the building can see the ocean without obstructions. Formally, a building has an ocean view if all the buildings to its right have a smaller height.

Return a list of indices (0-indexed) of buildings that have an ocean view, sorted in increasing order.

Input & Output

Example 1 — Basic Case

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

› Output: [0,2,3]

💡 Note: Building 0 (height 4) can see ocean because all buildings to its right (2,3,1) are shorter. Building 2 (height 3) can see ocean because building 3 (height 1) is shorter. Building 3 (height 1) is rightmost so it always has ocean view.

Example 2 — All Buildings Have Ocean View

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

› Output: [0,1,2,3]

💡 Note: Heights are in decreasing order, so each building can see over all buildings to its right. All buildings have ocean view.

Example 3 — Only Rightmost Has View

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

› Output: [3]

💡 Note: Building 3 (height 4) is the tallest and rightmost, so only it has ocean view. All other buildings are blocked by building 3.

Constraints

1 ≤ heights.length ≤ 10⁵
1 ≤ heights[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 8 a Amazon 5

The key insight is that we can process buildings from right to left, tracking the maximum height seen so far. A building has an ocean view if it's taller than all buildings to its right. Best approach uses single pass with O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Check Each Building

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

Iterate through each building and for each one, scan all buildings to its right. If no building to the right is taller or equal, add the current building's index to the result.

Monotonic Stack - Right to Left

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

Use a monotonic decreasing stack to efficiently track which buildings can see the ocean. Process buildings from right to left, using the stack to maintain buildings that could potentially block the ocean view.

Single Pass - Track Maximum Height

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

Process buildings from right to left while maintaining the maximum height encountered. A building has an ocean view if its height is greater than the maximum height seen to its right.

Brute Force - Check Each Building — Algorithm Steps

For each building i from 0 to n-1
Check all buildings j from i+1 to n-1
If all buildings to the right are shorter, add i to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from leftmost

Check building at index 0 against all buildings to its right

Continue checking

For each building, scan all buildings to the right

Add valid indices

Buildings with no taller buildings to the right have ocean view

Code -

solution.c — C

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

int* solution(int* heights, int heightsSize, int* returnSize) {
    int* result = (int*)malloc(heightsSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < heightsSize; i++) {
        int hasOceanView = 1;
        // Check all buildings to the right
        for (int j = i + 1; j < heightsSize; j++) {
            if (heights[j] >= heights[i]) {
                hasOceanView = 0;
                break;
            }
        }
        
        if (hasOceanView) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array properly
    int heights[1000];
    int size = 0;
    char* ptr = line;
    
    // Skip to first number
    while (*ptr && !isdigit(*ptr)) ptr++;
    
    // Parse numbers
    while (*ptr) {
        if (isdigit(*ptr)) {
            heights[size++] = atoi(ptr);
            while (*ptr && isdigit(*ptr)) ptr++;
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int* result = solution(heights, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop runs n times, inner loop runs up to n times

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, result array doesn't count toward space complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force - Check Each Building — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler