Count Unguarded Cells in the Grid

Count Unguarded Cells in the Grid - Problem

You are given two integers m and n representing a 0-indexed m × n grid. You are also given two 2D integer arrays guards and walls where:

guards[i] = [row_i, col_i] represents the position of the i-th guard
walls[j] = [row_j, col_j] represents the position of the j-th wall

A guard can see every cell in the four cardinal directions (north, east, south, west) starting from their position unless obstructed by a wall or another guard. A cell is guarded if there is at least one guard that can see it.

Return the number of unoccupied cells that are not guarded.

Input & Output

Example 1 — Basic Grid

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

› Output: 7

💡 Note: Guards at (0,0), (1,1), and (2,3) can see in 4 directions until blocked by walls. After marking all guarded cells, 7 cells remain unguarded.

Example 2 — Small Grid

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

› Output: 4

💡 Note: Single guard at center (1,1) is surrounded by walls, can only see 4 adjacent cells. The 4 corner cells remain unguarded.

Example 3 — No Walls

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

› Output: 0

💡 Note: Guard at (0,0) can see all other cells in the 2×2 grid since there are no walls blocking the view.

Constraints

1 ≤ m, n ≤ 10⁵
2 ≤ m × n ≤ 10⁵
1 ≤ guards.length, walls.length ≤ 5 × 10⁴

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 M Microsoft 4

The key insight is to simulate guard vision by casting rays in 4 directions until hitting obstacles. Best approach is Grid Marking Simulation which marks all guarded cells first, then counts unmarked ones. Time: O(m×n×g), Space: O(m×n)

Common Approaches

✓ Check Each Cell Individually

⏱️ Time: O(m²×n²×g) Space: O(1)

For every cell in the grid, iterate through all guards and check if the guard can see this cell by verifying no walls or other guards block the path. This requires checking horizontal/vertical lines between guard and cell.

Grid Marking Simulation

⏱️ Time: O(m×n×g) Space: O(m×n)

Create a grid to track cell states. Place guards and walls, then simulate each guard's vision by casting rays in 4 directions until hitting obstacles. Finally count cells that remain unmarked.

Check Each Cell Individually — Algorithm Steps

Step 1: For each empty cell in the grid
Step 2: Check if any guard can see it (no obstacles in between)
Step 3: If no guard sees it, count as unguarded

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Cell

Pick an empty cell to check

Test Guards

Check if any guard can see this cell

Count Result

If no guard sees it, increment unguarded count

Code -

solution.c — C

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

int guards[1000][2], walls[1000][2];
int guardCount = 0, wallCount = 0;

void parseArray(char* str, int arr[][2], int* count) {
    *count = 0;
    if (strcmp(str, "[]") == 0) return;
    
    char* ptr = str + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int first = 0, second = 0;
            
            // Parse first number
            while (*ptr >= '0' && *ptr <= '9') {
                first = first * 10 + (*ptr - '0');
                ptr++;
            }
            
            // Skip comma
            if (*ptr == ',') ptr++;
            
            // Parse second number
            while (*ptr >= '0' && *ptr <= '9') {
                second = second * 10 + (*ptr - '0');
                ptr++;
            }
            
            arr[*count][0] = first;
            arr[*count][1] = second;
            (*count)++;
            
            // Skip closing bracket
            if (*ptr == ']') ptr++;
        } else {
            ptr++;
        }
    }
}

int canGuardSee(int guardR, int guardC, int targetR, int targetC) {
    if (guardR == targetR) {
        int start = (guardC < targetC) ? guardC : targetC;
        int end = (guardC > targetC) ? guardC : targetC;
        
        for (int c = start + 1; c < end; c++) {
            // Check if blocked by wall
            for (int i = 0; i < wallCount; i++) {
                if (walls[i][0] == guardR && walls[i][1] == c) {
                    return 0;
                }
            }
            // Check if blocked by guard
            for (int i = 0; i < guardCount; i++) {
                if (guards[i][0] == guardR && guards[i][1] == c) {
                    return 0;
                }
            }
        }
        return 1;
    } else if (guardC == targetC) {
        int start = (guardR < targetR) ? guardR : targetR;
        int end = (guardR > targetR) ? guardR : targetR;
        
        for (int r = start + 1; r < end; r++) {
            // Check if blocked by wall
            for (int i = 0; i < wallCount; i++) {
                if (walls[i][0] == r && walls[i][1] == guardC) {
                    return 0;
                }
            }
            // Check if blocked by guard
            for (int i = 0; i < guardCount; i++) {
                if (guards[i][0] == r && guards[i][1] == guardC) {
                    return 0;
                }
            }
        }
        return 1;
    }
    return 0;
}

int solution(int m, int n) {
    int unguarded = 0;
    
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            // Check if this cell is a guard or wall
            int isOccupied = 0;
            
            for (int i = 0; i < guardCount; i++) {
                if (guards[i][0] == r && guards[i][1] == c) {
                    isOccupied = 1;
                    break;
                }
            }
            
            if (!isOccupied) {
                for (int i = 0; i < wallCount; i++) {
                    if (walls[i][0] == r && walls[i][1] == c) {
                        isOccupied = 1;
                        break;
                    }
                }
            }
            
            if (!isOccupied) {
                // Check if any guard can see this cell
                int seen = 0;
                for (int i = 0; i < guardCount && !seen; i++) {
                    if (canGuardSee(guards[i][0], guards[i][1], r, c)) {
                        seen = 1;
                    }
                }
                
                if (!seen) {
                    unguarded++;
                }
            }
        }
    }
    
    return unguarded;
}

int main() {
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    
    char guardsStr[10000], wallsStr[10000];
    scanf("%s", guardsStr);
    scanf("%s", wallsStr);
    
    parseArray(guardsStr, guards, &guardCount);
    parseArray(wallsStr, walls, &wallCount);
    
    int result = solution(m, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²×n²×g)

For each of m×n cells, check g guards, each requiring O(m+n) line trace

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

⚡ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Check Each Cell Individually — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler