LeetCode 73: Set Matrix Zeroes
- [Problem Link 🔗](#Problem Link 🔗)
- [Solution Overview 🧭](#Solution Overview 🧭)
- [Solution 1: Additional Arrays (O(m+n) Space)](#Solution 1: Additional Arrays (O(m+n) Space))
-
- [Algorithm Idea](#Algorithm Idea)
- [Important Points](#Important Points)
- [Java Implementation](#Java Implementation)
- [Time & Space Complexity](#Time & Space Complexity)
- [Solution 2: In-place Marking (O(1) Space)](#Solution 2: In-place Marking (O(1) Space))
-
- [Algorithm Idea](#Algorithm Idea)
- [Important Points](#Important Points)
- [Java Implementation](#Java Implementation)
- [Time & Space Complexity](#Time & Space Complexity)
- [Solution 3: Optimized In-place (Single Variable)](#Solution 3: Optimized In-place (Single Variable))
-
- [Algorithm Idea](#Algorithm Idea)
- [Important Points](#Important Points)
- [Java Implementation](#Java Implementation)
- [Time & Space Complexity](#Time & Space Complexity)
- [Solution Comparison 📊](#Solution Comparison 📊)
- [Summary 📝](#Summary 📝)
Problem Link 🔗
LeetCode 73: Set Matrix Zeroes
Solution Overview 🧭
Given an m x n matrix, if an element is 0, set its entire row and column to 0. You must do it in-place.
Constraints:
m == matrix.length
n == matrix[i].length
1 <= m, n <= 200
-2³¹ <= matrix[i][j] <= 2³¹ - 1
Common approaches include:
Additional Arrays: Use separate arrays to mark rows and columns to be zeroed
In-place Marking: Use first row and first column as markers
Bit Manipulation: Use bits to track rows and columns (for smaller matrices)
Solution 1: Additional Arrays (O(m+n) Space)
Algorithm Idea
Create two boolean arrays: zeroRows and zeroCols
First pass: Mark which rows and columns contain zeros
Second pass: Set matrix elements to zero based on the markers
Important Points
Straightforward and easy to understand
Requires O(m + n) extra space
Time complexity is optimal
Java Implementation
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
boolean[] zeroRows = new boolean[m];
boolean[] zeroCols = new boolean[n];
// Mark rows and columns that contain zeros
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] == 0) {
zeroRows[i] = true;
zeroCols[j] = true;
}
}
}
// 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;
}
}
}
}
}Time & Space Complexity
Time Complexity: O(m × n)
Space Complexity: O(m + n)
Solution 2: In-place Marking (O(1) Space)
Algorithm Idea
Use first row and first column as markers
Use two additional variables to track if first row/column originally had zeros
First pass: Mark zeros in the first row and column
Second pass: Use markers to set zeros in the rest of the matrix
Finally: Handle first row and column based on the tracking variables
Important Points
Constant extra space (only 2 boolean variables)
More complex logic but space-optimal
Must handle first row/column separately
Java Implementation
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
boolean firstRowZero = false;
boolean firstColZero = false;
// Check if first row has zero
for (int j = 0; j < n; j++) {
if (matrix[0][j] == 0) {
firstRowZero = true;
break;
}
}
// Check if first column has zero
for (int i = 0; i < m; i++) {
if (matrix[i][0] == 0) {
firstColZero = true;
break;
}
}
// Use first row and column as markers
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (matrix[i][j] == 0) {
matrix[i][0] = 0;
matrix[0][j] = 0;
}
}
}
// Set zeros based on markers (excluding first row/column)
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (matrix[i][0] == 0 || matrix[0][j] == 0) {
matrix[i][j] = 0;
}
}
}
// Handle first row
if (firstRowZero) {
for (int j = 0; j < n; j++) {
matrix[0][j] = 0;
}
}
// Handle first column
if (firstColZero) {
for (int i = 0; i < m; i++) {
matrix[i][0] = 0;
}
}
}
}Time & Space Complexity
Time Complexity: O(m × n)
Space Complexity: O(1)
Solution 3: Optimized In-place (Single Variable)
Algorithm Idea
Use first row as column markers
Use a single variable to track if first row has zero
First pass: Set markers and handle first row
Process in reverse order to avoid overwriting markers
Important Points
Most space-efficient (only 1 boolean variable)
Processes matrix from bottom-right to top-left
More complex but optimal for space
Java Implementation
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
boolean firstRowHasZero = false;
// Check first row and set markers
for (int j = 0; j < n; j++) {
if (matrix[0][j] == 0) {
firstRowHasZero = true;
}
}
// Use first row as column markers
for (int i = 1; i < m; i++) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] == 0) {
matrix[0][j] = 0;
matrix[i][0] = 0;
}
}
}
// Set zeros from bottom-right to avoid overwriting markers
for (int i = m - 1; i >= 1; i--) {
for (int j = n - 1; j >= 0; j--) {
if (matrix[0][j] == 0 || matrix[i][0] == 0) {
matrix[i][j] = 0;
}
}
}
// Handle first row
if (firstRowHasZero) {
for (int j = 0; j < n; j++) {
matrix[0][j] = 0;
}
}
}
}Time & Space Complexity
Time Complexity: O(m × n)
Space Complexity: O(1)
Solution Comparison 📊
Summary 📝
Key Insight: Use the matrix itself to store information about which rows/columns need to be zeroed
Recommended Approach: Solution 2 (In-place Marking) provides the best balance between readability and space efficiency
Interview Tip: This problem tests your ability to optimize space usage while maintaining clarity
The in-place marking technique is a common pattern that appears in many matrix manipulation problems, making it valuable to understand thoroughly.