Number of People That Can Be Seen in a Grid

Number of People That Can Be Seen in a Grid - Problem

The Stadium Seating Problem: Imagine you're at a stadium with people of different heights sitting in a grid formation. You want to determine how many people each person can see in front of them.

You are given an m × n grid where each cell contains the height of a person at that position. A person at position (row1, col1) can see another person at position (row2, col2) if:

1. Line of sight: The second person is either directly to the right (same row, further column) or directly below (same column, further row)
2. Clear view: Everyone between them must be shorter than both the viewer and the person being viewed

Goal: Return a grid where each cell contains the number of people that person can see.

Think of it like counting how many people you can spot from your seat without anyone tall blocking your view!

Input & Output

example_1.py — Basic Grid

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

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

💡 Note: Person at (0,0) with height 3 can see 2 people: height 4 to the right and height 1 below. Person at (0,1) with height 1 can see 1 person: height 4 to the right. Bottom row people can't see anyone (no one below or to their right).

example_2.py — Single Row

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

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

💡 Note: Person with height 1 can see both people to the right (heights 2 and 3). Person with height 2 can see one person to the right (height 3). Last person sees no one.

example_3.py — Tall Blocker

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

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

💡 Note: Person with height 1 can only see the tall person (height 5) - the tall person blocks everyone else behind them. The tall person can see heights 2 and 3. Person with height 2 can see height 3.

Constraints

m == heights.length
n == heights[i].length
1 ≤ m, n ≤ 1000
1 ≤ heights[i][j] ≤ 10⁵
All heights are positive integers

Visualization

Tap to expand

Understanding the Visualization

Setup the Grid

Place people with different heights in a grid formation

Check Horizontal

For each person, count visible people to their right using monotonic stack

Check Vertical

For each person, count visible people below them using monotonic stack

Combine Results

Sum the counts from both directions for each person

Key Takeaway

🎯 Key Insight: The monotonic stack acts like a smart 'skyline tracker' - it automatically handles the blocking logic by maintaining only the people who can actually be seen, making the solution both elegant and efficient!

Asked in

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

This problem is optimally solved using monotonic stacks. The key insight is that visibility follows a monotonic decreasing pattern in each direction. By processing each row right-to-left and each column bottom-to-top with a decreasing monotonic stack, we can efficiently count visible people in O(mn) time. The stack maintains people in decreasing height order, and when a taller person appears, they can see everyone shorter in the stack.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m²n²)	O(1)	Check every possible viewing pair manually with nested loops
Monotonic Stack (Optimal)	O(mn)	O(max(m,n))	Use monotonic stacks to efficiently track visible people in each direction

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each person in the grid as the viewer
For each viewer, check all people to their right in the same row
For each viewer, check all people below them in the same column
For each potential target, scan everyone in between to check for blockers
A person blocks the view if they're taller than or equal to both viewer and target

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Viewer

Pick a person in the grid as our current viewer

Check Right

Look at each person to the right, checking for blockers in between

Check Down

Look at each person below, checking for blockers in between

Count Visible

Sum up all people this viewer can see

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int** seePeopleInGrid(int** heights, int m, int n) {
    int** result = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = calloc(n, sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int count = 0;
            
            // Check right in same row
            for (int k = j + 1; k < n; k++) {
                int canSee = 1;
                for (int l = j + 1; l < k; l++) {
                    if (heights[i][l] >= min(heights[i][j], heights[i][k])) {
                        canSee = 0;
                        break;
                    }
                }
                if (canSee) count++;
            }
            
            // Check down in same column
            for (int k = i + 1; k < m; k++) {
                int canSee = 1;
                for (int l = i + 1; l < k; l++) {
                    if (heights[l][j] >= min(heights[i][j], heights[k][j])) {
                        canSee = 0;
                        break;
                    }
                }
                if (canSee) count++;
            }
            
            result[i][j] = count;
        }
    }
    
    return result;
}

int main() {
    // Sample usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of the m×n people, we potentially check all people to right/below, and for each target, scan all people in between

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for iteration, not counting the output grid

✓ Linear Space

42.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler