Set Matrix Zeroes

Set Matrix Zeroes - Problem

Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's.

You must do it in place.

Follow up: Can you solve it using O(1) extra space?

Input & Output

Example 1 — Basic Matrix with Zero

$ 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 row 1 and column 1 to become all zeros

Example 2 — 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, columns 0 and 3 to become zero

Example 3 — Single Row Matrix

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

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

💡 Note: Single row with a zero becomes entirely zero

Constraints

m == matrix.length
n == matrix[0].length
1 ≤ m, n ≤ 200
-2³¹ ≤ matrix[i][j] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 35 Apple 25

The key insight is to use the matrix's first row and column as flags to mark which rows and columns need to be zeroed, achieving O(1) space complexity. The optimal approach handles the borders separately to avoid conflicts. Time: O(m×n), Space: O(1)

Common Approaches

✓ Extra Space Approach

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

First scan the matrix to identify all zero positions. Store the row and column indices separately. Then iterate through the stored positions to set entire rows and columns to zero.

O(1) Space Using First Row/Column as Flags

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

Instead of using extra space, use the first row and column of the matrix itself to mark which rows and columns need to be zeroed. Handle the first row and column separately since they serve as markers.

Extra Space Approach — Algorithm Steps

Scan matrix to find all zero positions
Store row and column indices in sets
Zero out all marked rows and columns

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Zeros

Scan matrix and record zero positions

Store Indices

Keep sets of rows and columns to zero

Apply Changes

Zero out marked rows and columns

Code -

solution.c — C

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

// Global arrays to avoid stack overflow
static int matrix[1000][1000];
static int zeroRows[1000];
static int zeroCols[1000];
static char input[100000];

int main() {
    // Read input
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    int len = strlen(input);
    if (input[len-1] == '\n') input[len-1] = '\0';
    
    // Parse matrix dimensions and values
    int m = 0, n = 0;
    char* ptr = input;
    
    // Skip first '['
    ptr++;
    
    // Parse each row
    while (*ptr) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            int j = 0;
            
            while (*ptr && *ptr != ']') {
                // Parse number
                char* endptr;
                matrix[m][j] = (int)strtol(ptr, &endptr, 10);
                ptr = endptr;
                
                // Skip comma and spaces
                while (*ptr == ',' || *ptr == ' ') ptr++;
                j++;
            }
            
            if (m == 0) n = j; // Set column count from first row
            m++;
            
            if (*ptr == ']') ptr++; // Skip ']'
        }
        
        // Skip comma and spaces
        while (*ptr == ',' || *ptr == ' ') ptr++;
        
        if (*ptr == ']') break; // End of matrix
    }
    
    // Handle empty matrix
    if (m == 0 || n == 0) {
        printf("[]");
        return 0;
    }
    
    // Initialize zero tracking arrays
    memset(zeroRows, 0, sizeof(zeroRows));
    memset(zeroCols, 0, sizeof(zeroCols));
    
    // Find all zero positions
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 0) {
                zeroRows[i] = 1;
                zeroCols[j] = 1;
            }
        }
    }
    
    // Set rows to zero
    for (int i = 0; i < m; i++) {
        if (zeroRows[i]) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = 0;
            }
        }
    }
    
    // Set columns to zero
    for (int j = 0; j < n; j++) {
        if (zeroCols[j]) {
            for (int i = 0; i < m; i++) {
                matrix[i][j] = 0;
            }
        }
    }
    
    // Print result
    printf("[");
    for (int i = 0; i < m; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", matrix[i][j]);
            if (j < n - 1) printf(",");
        }
        printf("]");
        if (i < m - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Two passes through the matrix: one to find zeros, one to set zeros

✓ Linear Growth

Space Complexity

O(m+n)

Sets to store row and column indices that need to be zeroed

⚡ Linearithmic Space

262.0K Views

High Frequency

~25 min Avg. Time

8.5K 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

Extra Space Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler