Count Covered Buildings

Count Covered Buildings - Problem

You are given a positive integer n, representing an n x n city. You are also given a 2D grid buildings, where buildings[i] = [x, y] denotes a unique building located at coordinates [x, y].

A building is covered if there is at least one building in all four directions: left, right, above, and below.

Return the number of covered buildings.

Input & Output

Example 1 — Grid with One Covered Building

$ Input: n = 4, buildings = [[2,2],[1,2],[3,2],[2,1],[2,3]]

› Output: 1

💡 Note: Building at (2,2) is covered: left (2,1), right (2,3), above (1,2), below (3,2). All other buildings lack coverage in at least one direction.

Example 2 — No Covered Buildings

$ Input: n = 3, buildings = [[1,1],[1,2],[2,1]]

› Output: 0

💡 Note: No building has coverage in all four directions. Each building is missing at least one directional neighbor.

Example 3 — Multiple Covered Buildings

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

› Output: 2

💡 Note: Buildings (2,2) and (2,3) are both covered, each having neighbors in all four cardinal directions.

Constraints

1 ≤ n ≤ 10³
1 ≤ buildings.length ≤ 5 × 10²
buildings[i] = [x_i, y_i]
1 ≤ x_i, y_i ≤ n
All buildings are at unique locations

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that a building is covered only when it has at least one neighbor in each of the four cardinal directions. The optimal approach uses hash sets for O(1) coordinate lookups, achieving O(m×n) time complexity where we check each building against potential positions in all directions. Time: O(m×n), Space: O(m).

Common Approaches

✓ Brute Force

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

For each building, iterate through all other buildings to find if there exists at least one building in each of the four directions (left, right, above, below). Count buildings that have coverage in all four directions.

Hash Set Optimization

⏱️ Time: O(m²) Space: O(m)

Store all building coordinates in a hash set for constant-time lookups. For each building, check if there exists at least one building in each direction by scanning coordinates systematically.

Brute Force — Algorithm Steps

Iterate through each building
For each building, check all other buildings
Count buildings in left, right, above, below directions
If all four directions have buildings, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Building

Pick a building to check for coverage

Scan All Directions

Check all other buildings for left/right/above/below coverage

Count if Covered

If all 4 directions have buildings, increment counter

Code -

solution.c — C

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

int solution(int n, int buildings[][2], int m) {
    int coveredCount = 0;
    
    for (int i = 0; i < m; i++) {
        int x = buildings[i][0];
        int y = buildings[i][1];
        bool left = false, right = false, above = false, below = false;
        
        for (int j = 0; j < m; j++) {
            if (i == j) continue;
            int bx = buildings[j][0];
            int by = buildings[j][1];
            
            if (bx == x && by < y) {  // Same row, left side
                left = true;
            } else if (bx == x && by > y) {  // Same row, right side
                right = true;
            } else if (by == y && bx < x) {  // Same column, above
                above = true;
            } else if (by == y && bx > x) {  // Same column, below
                below = true;
            }
        }
        
        if (left && right && above && below) {
            coveredCount++;
        }
    }
    
    return coveredCount;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Simple parsing for format [[x1,y1],[x2,y2],...]
    int buildings[1000][2];
    int m = 0;
    
    char* ptr = line + 1;  // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            buildings[m][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;  // Skip comma
            buildings[m][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;  // Skip closing ']'
            m++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(n, buildings, m);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

For each of m buildings, we check all other m buildings

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

23.4K Views

Medium Frequency

~18 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler