Design a 3D Binary Matrix with Efficient Layer Tracking

Design a 3D Binary Matrix with Efficient Layer Tracking - Problem

Array Hash Table Design Heap (Priority Queue) Matrix Ordered Set Medium

You need to design and implement a 3D Binary Matrix data structure that efficiently tracks which layer (2D slice) contains the most 1's.

Imagine you're managing a multi-story building where each floor is represented as a 2D grid, and you need to quickly determine which floor has the most occupied rooms (1's) at any given time.

Your Matrix3D class should support:

Matrix3D(int n) - Initialize an n×n×n matrix with all cells set to 0
setCell(int x, int y, int z) - Set matrix[x][y][z] to 1
unsetCell(int x, int y, int z) - Set matrix[x][y][z] to 0
largestMatrix() - Return the layer index x with the most 1's (if tied, return the largest x)

Example:

Matrix3D matrix = new Matrix3D(3);
matrix.setCell(0, 1, 1);     // Layer 0 has 1 one
matrix.setCell(1, 0, 0);     // Layer 1 has 1 one  
matrix.setCell(1, 2, 2);     // Layer 1 has 2 ones
matrix.largestMatrix();      // Returns 1 (layer 1 has most 1's)

Input & Output

example_1.py — Basic Operations

$ Input: Matrix3D matrix = new Matrix3D(3); matrix.setCell(0, 1, 1); matrix.setCell(1, 0, 0); matrix.setCell(1, 2, 2); matrix.largestMatrix();

› Output: 1

💡 Note: Layer 0 has 1 one at position [0,1,1]. Layer 1 has 2 ones at positions [1,0,0] and [1,2,2]. Layer 2 has 0 ones. Layer 1 has the most ones, so we return 1.

example_2.py — Tie Handling

$ Input: Matrix3D matrix = new Matrix3D(2); matrix.setCell(0, 0, 0); matrix.setCell(1, 1, 1); matrix.largestMatrix();

› Output: 1

💡 Note: Both layer 0 and layer 1 have exactly 1 one each. Since we need to return the largest index when there's a tie, we return 1.

example_3.py — Unset Operations

$ Input: Matrix3D matrix = new Matrix3D(2); matrix.setCell(0, 0, 0); matrix.setCell(0, 1, 1); matrix.setCell(1, 0, 0); matrix.largestMatrix(); // returns 0 (layer 0 has 2, layer 1 has 1) matrix.unsetCell(0, 1, 1); matrix.largestMatrix(); // returns 1 (both have 1, prefer larger index)

› Output: 0, then 1

💡 Note: Initially layer 0 has 2 ones and layer 1 has 1 one, so we return 0. After unsetting one cell in layer 0, both layers have 1 one each, so we return the larger index 1.

Visualization

Tap to expand

Understanding the Visualization

Initialize Building

Create a 3×3×3 building with floor counters [0,0,0]

Car Parks (setCell)

When a car parks on floor 1, increment counter[1] and check if it's the new busiest floor

Car Leaves (unsetCell)

When a car leaves, decrement the counter and recheck maximum if needed

Query Busiest Floor

Return the tracked maximum floor instantly without counting all spaces

Key Takeaway

🎯 Key Insight: Instead of recounting all cells every time, maintain running counters for each layer and track the current maximum. This transforms an O(n³) query into an O(1) operation in most cases!

Time & Space Complexity

Time Complexity

⏱️

O(1) avg for all operations, O(n) worst case for unset

Set operations are O(1), unset is O(1) average but O(n) when we need to find new maximum

✓ Linear Growth

Space Complexity

O(n³ + n)

Need O(n³) for matrix plus O(n) for layer counters and tracking variables

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 100
0 ≤ x, y, z < n
At most 10⁴ calls will be made to setCell, unsetCell, and largestMatrix
All coordinates (x, y, z) are guaranteed to be valid

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23

The optimal approach uses layer counters to track the number of 1's in each 2D layer, combined with maximum tracking to avoid scanning all layers for each query. This achieves O(1) average time for all operations, with O(n) worst-case only when the current maximum layer loses its maximum status.

Common Approaches

Approach	Time	Space	Notes
✓ Layer Counter with Max Tracking (Optimal)	O(1) avg for all operations, O(n) worst case for unset	O(n³ + n)	Maintain a counter for each layer and track the current maximum layer efficiently
Brute Force (Count Every Layer)	O(1) for set/unset, O(n³) for largestMatrix	O(n³)	For each largestMatrix() call, iterate through all cells in all layers to count 1's

Layer Counter with Max Tracking (Optimal) — Algorithm Steps

Initialize counter array to track 1's in each layer
For setCell: increment counter[x] and update max layer if needed
For unsetCell: decrement counter[x] and recompute max if needed
For largestMatrix: return the tracked maximum layer
Handle ties by preferring larger indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Start with counter array [0,0,0] for 3 layers

Set Cell Operation

Increment layer counter and update max if needed

Track Maximum

Maintain current maximum layer without full scan

Handle Unset

Decrement counter, rescan only if max layer affected

Code -

solution.c — C

typedef struct {
    int n;
    int*** matrix;
    int* layerCounts;
    int maxLayer;
    int maxCount;
} Matrix3D;

void updateMaxLayer(Matrix3D* obj) {
    obj->maxCount = 0;
    obj->maxLayer = 0;
    
    for (int i = 0; i < obj->n; i++) {
        if (obj->layerCounts[i] >= obj->maxCount) {
            obj->maxCount = obj->layerCounts[i];
            obj->maxLayer = i;
        }
    }
}

Matrix3D* matrix3DCreate(int n) {
    Matrix3D* obj = (Matrix3D*)malloc(sizeof(Matrix3D));
    obj->n = n;
    obj->maxLayer = 0;
    obj->maxCount = 0;
    
    obj->matrix = (int***)malloc(n * sizeof(int**));
    for (int i = 0; i < n; i++) {
        obj->matrix[i] = (int**)malloc(n * sizeof(int*));
        for (int j = 0; j < n; j++) {
            obj->matrix[i][j] = (int*)calloc(n, sizeof(int));
        }
    }
    
    obj->layerCounts = (int*)calloc(n, sizeof(int));
    return obj;
}

void matrix3DSetCell(Matrix3D* obj, int x, int y, int z) {
    if (obj->matrix[x][y][z] == 0) {
        obj->matrix[x][y][z] = 1;
        obj->layerCounts[x]++;
        
        if (obj->layerCounts[x] >= obj->maxCount) {
            obj->maxCount = obj->layerCounts[x];
            obj->maxLayer = x;
        }
    }
}

void matrix3DUnsetCell(Matrix3D* obj, int x, int y, int z) {
    if (obj->matrix[x][y][z] == 1) {
        obj->matrix[x][y][z] = 0;
        obj->layerCounts[x]--;
        
        if (x == obj->maxLayer) {
            updateMaxLayer(obj);
        }
    }
}

int matrix3DLargestMatrix(Matrix3D* obj) {
    return obj->maxLayer;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) avg for all operations, O(n) worst case for unset

Set operations are O(1), unset is O(1) average but O(n) when we need to find new maximum

✓ Linear Growth

Space Complexity

O(n³ + n)

Need O(n³) for matrix plus O(n) for layer counters and tracking variables

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 100
0 ≤ x, y, z < n
At most 10⁴ calls will be made to setCell, unsetCell, and largestMatrix
All coordinates (x, y, z) are guaranteed to be valid

23.5K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Layer Counter with Max Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler