Grid Illumination - Practice Coding Problems

Grid Illumination - Problem

Imagine you're managing a smart lighting system in a massive n × n grid building where each room has a special lamp. Initially, all lamps are turned off, but when activated, these aren't ordinary lamps - they're super-powered!

Each lamp illuminates not just its own room, but entire rows, columns, and both diagonals that pass through it. Think of it like placing a queen on a chessboard - it controls everything in its line of sight!

You're given:

lamps: Array of lamp positions that are initially turned on
queries: Array of room positions to check for illumination

For each query, you need to:

Check if the room is illuminated (by any lamp's row/column/diagonal coverage)
Turn off the queried lamp (if it exists) plus all 8 adjacent lamps

Goal: Return an array where 1 means the room was illuminated, 0 means it wasn't.

Input & Output

example_1.py — Basic illumination

$ Input: n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]

› Output: [1,1]

💡 Note: Query (1,1): Lamp at (0,0) illuminates main diagonal including (1,1). Query (1,0): Lamp at (0,0) illuminates column 0 including (1,0). After first query, lamp at (0,0) is turned off, but second query still illuminated by remaining coverage.

example_2.py — Multiple coverage

$ Input: n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]

› Output: [1,0]

💡 Note: First query (1,1): Both lamps contribute to illumination via diagonals. After query, lamp at (1,1) and neighbors are turned off (including (0,0)). Second query (1,1): Only lamp at (4,4) remains, which doesn't illuminate (1,1).

example_3.py — Edge case: no illumination

$ Input: n = 5, lamps = [[0,0]], queries = [[4,4]]

› Output: [0]

💡 Note: Query (4,4): Lamp at (0,0) illuminates row 0, column 0, and main diagonal (r-c=0). Position (4,4) has r-c=0 so it's on the main diagonal - this should return [1]. The lamp is then turned off along with its neighbors.

Constraints

1 ≤ n ≤ 10⁹
0 ≤ lamps.length ≤ 20000
0 ≤ queries.length ≤ 20000
lamps[i].length == 2
queries[j].length == 2
0 ≤ row_i, col_i, row_j, col_j < n

Visualization

Tap to expand

Understanding the Visualization

Install Smart Tracking

Instead of monitoring each lamp individually, install sensors that count total illumination in each row, column, and diagonal pathway

Instant Status Check

When security queries a location, instantly check if any pathway sensor shows illumination > 0

Efficient Maintenance

When turning off lamps, simply decrement the pathway counters rather than scanning all lamps

Key Takeaway

🎯 Key Insight: By tracking illumination counts per row/column/diagonal instead of individual lamps, we transform an O(L) problem into O(1) queries!

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses hash tables to track illuminated areas by maintaining counters for each row, column, and diagonal. This reduces query time from O(L) to O(1) by avoiding the need to check individual lamps. The key insight is that we only need to know how many lamps illuminate each area, not which specific lamps do it.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table Optimization (Optimal)	O(L + Q)	O(L)	Track illuminated rows, columns, and diagonals using counters for O(1) query time
Brute Force (Check Every Lamp)	O(Q × L)	O(L)	For each query, check every active lamp to see if it illuminates the target position

Hash Table Optimization (Optimal) — Algorithm Steps

Create hash maps to count lamps in each row, column, main diagonal, and anti-diagonal
Store actual lamp positions for turn-off operations
For each query, check if any counter > 0 for that row/column/diagonal
Turn off lamps and decrement corresponding counters
Return illumination status

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Create hash maps for rows, columns, and diagonals

Process Lamps

Increment counters for each lamp's coverage areas

O(1) Query

Check if any counter > 0 for query position

Update Counters

Decrement counters when turning off lamps

Code -

solution.c — C

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

#define HASH_SIZE 100003
#define MAX_LAMPS 20000

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* table[HASH_SIZE];
} HashMap;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void put(HashMap* map, int key, int value) {
    int idx = hash(key);
    HashNode* node = map->table[idx];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = map->table[idx];
    map->table[idx] = newNode;
}

int get(HashMap* map, int key) {
    int idx = hash(key);
    HashNode* node = map->table[idx];
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

void removeKey(HashMap* map, int key) {
    int idx = hash(key);
    HashNode** node = &map->table[idx];
    while (*node) {
        if ((*node)->key == key) {
            HashNode* toDelete = *node;
            *node = (*node)->next;
            free(toDelete);
            return;
        }
        node = &(*node)->next;
    }
}

int* gridIllumination(int n, int** lamps, int lampsSize, int* lampsColSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    HashMap rows = {0}, cols = {0}, mainDiag = {0}, antiDiag = {0};
    int lampGrid[MAX_LAMPS][2];
    int lampCount = 0;
    
    // Process unique lamps
    for (int i = 0; i < lampsSize; i++) {
        int r = lamps[i][0], c = lamps[i][1];
        int found = 0;
        for (int j = 0; j < lampCount; j++) {
            if (lampGrid[j][0] == r && lampGrid[j][1] == c) {
                found = 1;
                break;
            }
        }
        if (!found) {
            lampGrid[lampCount][0] = r;
            lampGrid[lampCount][1] = c;
            lampCount++;
            put(&rows, r, get(&rows, r) + 1);
            put(&cols, c, get(&cols, c) + 1);
            put(&mainDiag, r - c, get(&mainDiag, r - c) + 1);
            put(&antiDiag, r + c, get(&antiDiag, r + c) + 1);
        }
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    int directions[9][2] = {{-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,0}, {0,1}, {1,-1}, {1,0}, {1,1}};
    
    for (int q = 0; q < queriesSize; q++) {
        int queryR = queries[q][0], queryC = queries[q][1];
        
        int illuminated = get(&rows, queryR) > 0 || 
                         get(&cols, queryC) > 0 || 
                         get(&mainDiag, queryR - queryC) > 0 || 
                         get(&antiDiag, queryR + queryC) > 0;
        
        result[q] = illuminated ? 1 : 0;
        
        // Turn off lamps
        for (int d = 0; d < 9; d++) {
            int nr = queryR + directions[d][0];
            int nc = queryC + directions[d][1];
            if (nr >= 0 && nr < n && nc >= 0 && nc < n) {
                for (int i = 0; i < lampCount; i++) {
                    if (lampGrid[i][0] == nr && lampGrid[i][1] == nc) {
                        // Remove lamp
                        lampGrid[i] = lampGrid[lampCount - 1];
                        lampCount--;
                        i--;
                        
                        int val = get(&rows, nr) - 1;
                        if (val == 0) removeKey(&rows, nr);
                        else put(&rows, nr, val);
                        
                        val = get(&cols, nc) - 1;
                        if (val == 0) removeKey(&cols, nc);
                        else put(&cols, nc, val);
                        
                        val = get(&mainDiag, nr - nc) - 1;
                        if (val == 0) removeKey(&mainDiag, nr - nc);
                        else put(&mainDiag, nr - nc, val);
                        
                        val = get(&antiDiag, nr + nc) - 1;
                        if (val == 0) removeKey(&antiDiag, nr + nc);
                        else put(&antiDiag, nr + nc, val);
                        break;
                    }
                }
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(L + Q)

L to process lamps, Q for queries (each query is O(1))

✓ Linear Growth

Space Complexity

O(L)

Store lamp positions and counters for rows/columns/diagonals

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 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

Hash Table Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler