Count Unguarded Cells in the Grid - Practice Coding Problems

Count Unguarded Cells in the Grid - Problem

Imagine you're designing a security system for a building represented by an m × n grid. The building has guards stationed at specific positions and walls that block visibility.

Each guard can see in all four cardinal directions (north, east, south, west) from their position, but their line of sight is blocked by walls or other guards. A cell is considered "guarded" if at least one guard can see it.

Your task is to determine how many cells in the building are unoccupied and unguarded - these represent potential security vulnerabilities!

Input:

m, n: dimensions of the grid
guards[][]: array of guard positions [row, col]
walls[][]: array of wall positions [row, col]

Output: Number of cells that are neither occupied (by guards/walls) nor guarded.

Input & Output

example_1.py — Basic Case

$ Input: m = 4, n = 6 guards = [[0,0],[1,1],[2,3]] walls = [[0,1],[2,2],[1,4]]

› Output: 7

💡 Note: Guards can see in straight lines until blocked by walls. The unguarded cells are those that no guard can see due to walls blocking their vision or being outside all sight lines.

example_2.py — Small Grid

$ Input: m = 3, n = 3 guards = [[1,1]] walls = [[0,1],[1,0],[2,1],[1,2]]

› Output: 4

💡 Note: The guard in the center is surrounded by walls, so it can't see any other cells. All corner cells remain unguarded.

example_3.py — No Walls

$ Input: m = 2, n = 4 guards = [[0,0],[1,2]] walls = []

› Output: 2

💡 Note: With no walls, guards have clear sight lines. The first guard sees the entire first row and first column, the second guard sees remaining cells in its row and column.

Constraints

1 ≤ m, n ≤ 10⁵
2 ≤ m * n ≤ 10⁵
1 ≤ guards.length, walls.length ≤ 5 * 10⁴
guards[i].length == walls[j].length == 2
0 ≤ row_i, col_i < m, n
All positions in guards and walls are unique

Visualization

Tap to expand

Understanding the Visualization

Setup Security Grid

Place guards (green) and walls (gray) in the warehouse

Cast Vision Lines

Each guard looks in 4 directions: north, south, east, west

Mark Guarded Areas

Vision extends until hitting walls or other guards (yellow areas)

Identify Blind Spots

Count white cells - these are security vulnerabilities!

Key Takeaway

🎯 Key Insight: Instead of checking each cell individually, we simulate guard vision by tracing sight lines from each guard position. This transforms an O(m*n*g*(m+n)) brute force into an optimal O(m*n) solution by processing each cell at most 4 times.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses grid simulation in O(m*n) time. We mark guards and walls on a grid, then for each guard, trace sight lines in all 4 directions until hitting obstacles. This efficiently marks all guarded cells, and we count the remaining empty cells.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Cell)	O(mng*(m+n))	O(m*n)	For each empty cell, check if any guard can see it by tracing lines of sight
Grid Simulation (Optimal)	O(m*n)	O(m*n)	Simulate each guard's vision by tracing sight lines in all four directions

Brute Force (Check Each Cell) — Algorithm Steps

Create a grid to mark guard and wall positions
For each empty cell, iterate through all guards
For each guard, trace lines in 4 directions to see if they reach the current cell
If any guard can see the cell, mark it as guarded
Count unguarded cells

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Grid

Mark guards (G) and walls (W) on the grid

Check Cell

For each empty cell, trace lines from all guards

Mark Guarded

If any guard can see the cell, mark it as guarded (X)

Count Unguarded

Count remaining empty cells (.)

Code -

solution.c — C

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

int canGuardSeeCell(int** grid, int guardR, int guardC, int targetR, int targetC) {
    if (guardR == targetR) { // Same row
        int start = (guardC < targetC) ? guardC : targetC;
        int end = (guardC > targetC) ? guardC : targetC;
        for (int c = start + 1; c < end; c++) {
            if (grid[guardR][c] == 1 || grid[guardR][c] == 2) {
                return 0;
            }
        }
        return 1;
    } else if (guardC == targetC) { // Same column
        int start = (guardR < targetR) ? guardR : targetR;
        int end = (guardR > targetR) ? guardR : targetR;
        for (int r = start + 1; r < end; r++) {
            if (grid[r][guardC] == 1 || grid[r][guardC] == 2) {
                return 0;
            }
        }
        return 1;
    }
    return 0;
}

int countUnguarded(int m, int n, int** guards, int guardsSize, int* guardsColSize, int** walls, int wallsSize, int* wallsColSize) {
    // Create grid: 0=empty, 1=guard, 2=wall, 3=guarded
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Mark guards and walls
    for (int i = 0; i < guardsSize; i++) {
        grid[guards[i][0]][guards[i][1]] = 1;
    }
    for (int i = 0; i < wallsSize; i++) {
        grid[walls[i][0]][walls[i][1]] = 2;
    }
    
    // Check each empty cell
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (grid[r][c] == 0) { // Empty cell
                for (int i = 0; i < guardsSize; i++) {
                    if (canGuardSeeCell(grid, guards[i][0], guards[i][1], r, c)) {
                        grid[r][c] = 3; // Mark as guarded
                        break;
                    }
                }
            }
        }
    }
    
    // Count unguarded cells
    int count = 0;
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (grid[r][c] == 0) count++;
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*g*(m+n))

For each cell (m*n), check all guards (g), trace lines up to m+n length

✓ Linear Growth

Space Complexity

O(m*n)

Grid to store cell states

⚡ Linearithmic Space

28.9K Views

Medium-High Frequency

~15 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 (Check Each Cell) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler