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 are given a n × n × n binary 3D array matrix. Implement the Matrix3D class:

Matrix3D(int n) Initializes the object with the 3D binary array matrix, where all elements are initially set to 0.

void setCell(int x, int y, int z) Sets the value at matrix[x][y][z] to 1.

void unsetCell(int x, int y, int z) Sets the value at matrix[x][y][z] to 0.

int largestMatrix() Returns the index x where matrix[x] contains the most number of 1's. If there are multiple such indices, return the largest x.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["Matrix3D", 2], ["setCell", 0, 0, 0], ["setCell", 1, 1, 1], ["largestMatrix"], ["setCell", 0, 1, 1], ["largestMatrix"]]

› Output: [null, null, null, 1, null, 0]

💡 Note: Initialize 2×2×2 matrix. Set (0,0,0) - layer 0 has 1 cell. Set (1,1,1) - layer 1 has 1 cell. Both layers tie with count 1, return larger index 1. Set (0,1,1) - layer 0 now has 2 cells. Layer 0 has most cells, return 0.

Example 2 — With Unset Operations

$ Input: operations = [["Matrix3D", 3], ["setCell", 1, 0, 0], ["setCell", 1, 0, 1], ["setCell", 2, 1, 1], ["largestMatrix"], ["unsetCell", 1, 0, 0], ["largestMatrix"]]

› Output: [null, null, null, null, 1, null, 2]

💡 Note: Initialize 3×3×3 matrix. Set cells in layers 1 (count=2) and 2 (count=1). Layer 1 has most, return 1. Unset one cell from layer 1 (count=1). Now layers 1 and 2 tie with count 1, return larger index 2.

Example 3 — All Layers Empty

$ Input: operations = [["Matrix3D", 2], ["largestMatrix"]]

› Output: [null, 1]

💡 Note: All layers have count 0, return the largest index which is 1 (n-1).

Constraints

1 ≤ n ≤ 100
0 ≤ x, y, z < n
At most 10⁴ calls will be made to setCell, unsetCell, and largestMatrix

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to track counts per layer instead of storing the full 3D matrix. The optimal approach uses an array to count 1's in each layer plus a set to track active cells, enabling O(1) operations for set/unset and O(n) for queries. Time: O(1) per operation, Space: O(n + k) where k is active cells.

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Brute Force with Full Matrix

⏱️ Time: O(n²) Space: O(n³)

Store the entire n×n×n matrix in memory. For setCell/unsetCell operations, directly modify the matrix. For largestMatrix, iterate through all layers and count 1's in each layer to find the maximum.

Layer Count Tracking

⏱️ Time: O(1) Space: O(n + k)

Instead of storing the full matrix, maintain a count array where count[x] tracks the number of 1's in layer x. Use a set to track which cells are currently set to 1 for validation during unset operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int n;
    int*** matrix;
} Matrix3D;

Matrix3D* createMatrix3D(int n) {
    Matrix3D* obj = (Matrix3D*)malloc(sizeof(Matrix3D));
    obj->n = n;
    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));
        }
    }
    
    return obj;
}

void setCell(Matrix3D* obj, int x, int y, int z) {
    obj->matrix[x][y][z] = 1;
}

void unsetCell(Matrix3D* obj, int x, int y, int z) {
    obj->matrix[x][y][z] = 0;
}

int largestMatrix(Matrix3D* obj) {
    int maxCount = -1;
    int result = 0;
    
    for (int x = 0; x < obj->n; x++) {
        int count = 0;
        for (int y = 0; y < obj->n; y++) {
            for (int z = 0; z < obj->n; z++) {
                count += obj->matrix[x][y][z];
            }
        }
        
        if (count >= maxCount) {
            maxCount = count;
            result = x;
        }
    }
    
    return result;
}

void freeMatrix3D(Matrix3D* obj) {
    for (int i = 0; i < obj->n; i++) {
        for (int j = 0; j < obj->n; j++) {
            free(obj->matrix[i][j]);
        }
        free(obj->matrix[i]);
    }
    free(obj->matrix);
    free(obj);
}

char* parseString(const char* s, int* pos) {
    if (s[*pos] != '"') return NULL;
    (*pos)++; // skip opening quote
    
    int start = *pos;
    while (*pos < strlen(s) && s[*pos] != '"') {
        (*pos)++;
    }
    
    int len = *pos - start;
    char* result = (char*)malloc((len + 1) * sizeof(char));
    strncpy(result, s + start, len);
    result[len] = '\0';
    
    (*pos)++; // skip closing quote
    return result;
}

int parseInt(const char* s, int* pos) {
    int result = 0;
    int sign = 1;
    
    if (s[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    while (*pos < strlen(s) && s[*pos] >= '0' && s[*pos] <= '9') {
        result = result * 10 + (s[*pos] - '0');
        (*pos)++;
    }
    
    return result * sign;
}

int main() {
    char* line = (char*)malloc(10000 * sizeof(char));
    if (fgets(line, 10000, stdin) == NULL) {
        free(line);
        return 1;
    }
    
    int results[1000];
    char* result_types[1000]; // "null" or "int"
    int result_count = 0;
    Matrix3D* matrix3d = NULL;
    
    int pos = 1; // skip opening [
    
    while (pos < strlen(line) && line[pos] != ']') {
        if (line[pos] == '[') {
            pos++; // skip [
            
            char* operation = NULL;
            int args[10];
            int arg_count = 0;
            
            while (pos < strlen(line) && line[pos] != ']') {
                if (line[pos] == '"') {
                    if (operation == NULL) {
                        operation = parseString(line, &pos);
                    } else {
                        free(parseString(line, &pos)); // consume but don't use
                    }
                } else if ((line[pos] >= '0' && line[pos] <= '9') || line[pos] == '-') {
                    args[arg_count++] = parseInt(line, &pos);
                } else {
                    pos++;
                }
            }
            
            pos++; // skip ]
            
            if (strcmp(operation, "Matrix3D") == 0) {
                matrix3d = createMatrix3D(args[0]);
                result_types[result_count] = "null";
                result_count++;
            } else if (strcmp(operation, "setCell") == 0) {
                setCell(matrix3d, args[0], args[1], args[2]);
                result_types[result_count] = "null";
                result_count++;
            } else if (strcmp(operation, "unsetCell") == 0) {
                unsetCell(matrix3d, args[0], args[1], args[2]);
                result_types[result_count] = "null";
                result_count++;
            } else if (strcmp(operation, "largestMatrix") == 0) {
                results[result_count] = largestMatrix(matrix3d);
                result_types[result_count] = "int";
                result_count++;
            }
            
            free(operation);
        } else {
            pos++;
        }
    }
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(", ");
        if (strcmp(result_types[i], "null") == 0) {
            printf("null");
        } else {
            printf("%d", results[i]);
        }
    }
    printf("]\n");
    
    if (matrix3d) {
        freeMatrix3D(matrix3d);
    }
    free(line);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

23.4K Views

Medium 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