Set Matrix Zeroes - Practice Coding Problems

Set Matrix Zeroes - Problem

Set Matrix Zeroes is a classic matrix manipulation problem that tests your ability to modify data structures in place efficiently.

Given an m x n integer matrix, your task is to identify all cells containing zero and then set the entire row and column of each zero cell to zero. The challenge is that you must perform this transformation in place without using extra space for a copy of the matrix.

Key Requirements:
• Modify the original matrix directly (in-place)
• When you find a zero, mark its entire row and column to become zero
• Preserve the original zero positions while processing

Example: If you have a 3x3 matrix and position (1,1) contains zero, then row 1 and column 1 should become all zeros in the final result.

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]

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

💡 Note: The zero at position (1,1) causes the entire row 1 and column 1 to be set to zero. Row 1 becomes [0,0,0] and column 1 becomes [0,0,0].

example_2.py — Multiple Zeros

$ Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]

› Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]

💡 Note: Zeros at (0,0) and (0,3) cause row 0 to become all zeros, and columns 0 and 3 to become zeros. The intersecting cells follow the zero rule.

example_3.py — Single Element Matrix

$ Input: matrix = [[0]]

› Output: [[0]]

💡 Note: Edge case: A single-element matrix containing zero remains unchanged since there are no other rows or columns to modify.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through the matrix with some additional first row/column processing

✓ Linear Growth

Space Complexity

O(1)

Only using two boolean flags and repurposing existing matrix cells as markers

✓ Linear Space

Constraints

m == matrix.length
n == matrix[0].length
1 ≤ m, n ≤ 200
-2³¹ ≤ matrix[i][j] ≤ 2³¹ - 1
Follow up: A straightforward solution using O(mn) space is probably a bad idea. A simple improvement uses O(m + n) space, but still not the best solution. Could you devise a constant space solution?

Asked in

The optimal solution uses the matrix's first row and column as marker storage to achieve O(1) space complexity. By carefully handling the border cells and using boolean flags for the first row/column state, we can solve this problem in-place without any additional data structures. This approach demonstrates the power of repurposing existing memory to optimize space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Extra Matrix Copy)	O(m*n)	O(m*n)	Create a copy of the matrix and modify the original based on zeros found in the copy
Optimal In-Place (First Row/Column as Markers)	O(m*n)	O(1)	Use the first row and column as marker storage to achieve O(1) space complexity
Two-Pass with Sets	O(m*n)	O(m+n)	First pass to collect zero positions in sets, second pass to apply changes

Brute Force (Extra Matrix Copy) — Algorithm Steps

Create a complete copy of the input matrix
Iterate through every cell in the copied matrix
For each zero found in the copy, mark the corresponding row and column in the original matrix
Set all marked rows and columns to zero in the original matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Copy

Make a complete copy of the original matrix

Scan Copy

Find all zero positions in the copied matrix

Modify Original

Set rows and columns to zero in the original matrix based on copy

Code -

solution.c — C

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

void setZeroes(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0) return;
    
    int rows = matrixSize;
    int cols = matrixColSize[0];
    
    // Create a copy of the matrix
    int** matrixCopy = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrixCopy[i] = (int*)malloc(cols * sizeof(int));
        memcpy(matrixCopy[i], matrix[i], cols * sizeof(int));
    }
    
    // Find zeros in copy and modify original
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrixCopy[i][j] == 0) {
                // Set entire row to zero
                memset(matrix[i], 0, cols * sizeof(int));
                // Set entire column to zero
                for (int k = 0; k < rows; k++) {
                    matrix[k][j] = 0;
                }
            }
        }
    }
    
    // Free allocated memory
    for (int i = 0; i < rows; i++) {
        free(matrixCopy[i]);
    }
    free(matrixCopy);
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We scan the matrix twice: once to copy and once to identify zeros and modify

✓ Linear Growth

Space Complexity

O(m*n)

We create a complete copy of the input matrix

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[0].length
1 ≤ m, n ≤ 200
-2³¹ ≤ matrix[i][j] ≤ 2³¹ - 1
Follow up: A straightforward solution using O(mn) space is probably a bad idea. A simple improvement uses O(m + n) space, but still not the best solution. Could you devise a constant space solution?

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Extra Matrix Copy) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler