Given a Matrix arr of size M x N, the task is to set all rows and columns to zeroes if a particular element is zero, in constant space complexity.
Set Matrix Zeroes
Examples:
Input: [ [1, 1, 1],
[1, 0, 1],
[1, 1, 1]]
Output: [ [1, 0, 1],
[0, 0, 0],
[1, 0, 1]]
Explanation: one zero is present at cell(2,2), and all the elements in the 2nd row and 2nd column are marked as zeroes.Input: [[ 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]]
Explanation: There are zeroes present in the 1st row at 1st column and 4th column.
Naive approach:
- First, we traverse the matrix using two nested loops and store the maximum of matrix in k and increase its value by 1 .
- Then we will start to traverse the matrix again using 2 loops.
- For each cell (i, j) if it is 0 then mark all the elements of row i and col j as k except that contains zero.
- Then traverse the matrix and mark cell 0 which contains k.
- We get our final matrix.
Below is the Implementation of the above approach:
C++
// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;
void SetMatrixZeroes(vector<vector<int> >& arr)
{
// Traverse the matrix
// using 2 nested loops
int k=INT_MIN;
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
if (arr[i][j] <k)
k=arr[i][j] ;
}
}
k=k+1;
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
// If the cell contains zero
// then mark its row
// and column as (max+1)
if (arr[i][j] == 0) {
// Marking ith row elements (max+1)
for (int c = 0; c < arr[i].size(); c++) {
if (arr[i][c]) {
arr[i][c] =k ;
}
}
// Marking jth column elements (max + 1)
for (int r = 0; r < arr.size(); r++) {
if (arr[r][j]) {
arr[r][j] = k;
}
}
}
}
}
//conveting all the elements which are marked as (max+1) to 0
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
if (arr[i][j] == k)
arr[i][j] = 0;
}
}
}
// Driver code
int main()
{
vector<vector<int> > arr = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
SetMatrixZeroes(arr);
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
return 0;
}
Java
//Java code for the above approach
import java.util.Arrays;
public class GFG {
public static void setMatrixZeroes(int[][] matrix) {
int rows = matrix.length;
int cols = matrix[0].length;
// Arrays to mark rows and columns to be zeroed
boolean[] zeroRows = new boolean[rows];
boolean[] zeroCols = new boolean[cols];
// Traverse the matrix to mark rows and columns to be zeroed
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (matrix[i][j] == 0) {
zeroRows[i] = true;
zeroCols[j] = true;
}
}
}
// Set elements to zero based on marked rows and columns
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (zeroRows[i] || zeroCols[j]) {
matrix[i][j] = 0;
}
}
}
}
public static void main(String[] args) {
int[][] matrix = {
{0, 1, 2, 0},
{3, 4, 5, 2},
{1, 3, 1, 5}
};
// Function call
setMatrixZeroes(matrix);
// Print the modified matrix
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
}
Python3
def set_matrix_zeroes(matrix):
rows, cols = len(matrix), len(matrix[0])
zero_rows, zero_cols = set(), set()
# Identify rows and columns containing zeroes
for i in range(rows):
for j in range(cols):
if matrix[i][j] == 0:
zero_rows.add(i)
zero_cols.add(j)
# Set rows with zeroes to all zeroes
for row in zero_rows:
for j in range(cols):
matrix[row][j] = 0
# Set columns with zeroes to all zeroes
for col in zero_cols:
for i in range(rows):
matrix[i][col] = 0
# Driver code
if __name__ == "__main__":
matrix = [
[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]
]
set_matrix_zeroes(matrix)
for row in matrix:
for num in row:
print(num, end=" ")
print()
C#
using System;
using System.Collections.Generic;
class Program {
static void SetMatrixZeroes(List<List<int> > arr)
{
// Traverse the matrix using 2 nested loops
int k = int.MinValue;
for (int i = 0; i < arr.Count; i++)
{
for (int j = 0; j < arr[0].Count; j++)
{
if (arr[i][j] < k)
k = arr[i][j];
}
}
k = k + 1;
for (int i = 0; i < arr.Count; i++) {
for (int j = 0; j < arr[0].Count; j++) {
// If the cell contains zero, mark its row
// and column as (max+1)
if (arr[i][j] == 0) {
// Marking ith row elements as (max+1)
for (int c = 0; c < arr[i].Count; c++) {
if (arr[i][c] != 0) {
arr[i][c] = -1;
}
}
// Marking jth column elements as (max+1)
for (int r = 0; r < arr.Count; r++) {
if (arr[r][j] != 0) {
arr[r][j] = -1;
}
}
}
}
}
// Replace (max+1) with 0 in the matrix
for (int i = 0; i < arr.Count; i++) {
for (int j = 0; j < arr[0].Count; j++) {
if (arr[i][j] == -1) {
arr[i][j] = 0;
}
}
}
}
static void Main()
{
List<List<int> > arr = new List<List<int> >{
new List<int>{ 0, 1, 2, 0 },
new List<int>{ 3, 4, 5, 2 },
new List<int>{ 1, 3, 1, 5 }
};
// Function call
SetMatrixZeroes(arr);
for (int i = 0; i < arr.Count; i++) {
for (int j = 0; j < arr[0].Count; j++) {
Console.Write(arr[i][j] + " ");
}
Console.WriteLine();
}
}
}
Javascript
function setMatrixZeroes(matrix) {
// Variables to track rows and columns with zeroes
let zeroRows = new Set();
let zeroColumns = new Set();
// Traverse the matrix to find rows and columns with zeroes
for (let i = 0; i < matrix.length; i++) {
for (let j = 0; j < matrix[0].length; j++) {
if (matrix[i][j] === 0) {
zeroRows.add(i);
zeroColumns.add(j);
}
}
}
// Set rows with zeroes to all zeroes
zeroRows.forEach(row => {
for (let j = 0; j < matrix[0].length; j++) {
matrix[row][j] = 0;
}
});
// Set columns with zeroes to all zeroes
zeroColumns.forEach(col => {
for (let i = 0; i < matrix.length; i++) {
matrix[i][col] = 0;
}
});
}
// Test the code
const arr = [
[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]
];
setMatrixZeroes(arr);
for (let i = 0; i < arr.length; i++) {
console.log(arr[i].join(' '));
}
Output
0 0 0 0 0 4 5 0 0 3 1 0
Time Complexity: O((N*M)*(N + M)) + O(N*M), where N = no. of rows in the matrix and M = no. of columns in the matrix. we are traversing the matrix to find the cells with the value 0. It takes O(N*M).
Auxillary space: O(1) as we are not using any extra space.
Better Approach:
In the previous approach we have updated the row and column by -1 while traversing the matrix. So Idea here is Somehow we have to store which rows and columns are supposed to mark with zeroes.
Follow the steps to solve the problem:
- A row array of size N and a col array of size M are initialized with 0 to store which row and which column to mark with zeroes.
- Then, we will use two loops to traverse all the cells of the matrix.
- For each cell (i, j) containing the value 0, we will mark the ith index of the row array i.e. row[i], and jth index of col array col[j] as 1. It signifies that all the elements in the ith row and jth column will be 0 in the final matrix.
- Finally, we will again traverse the entire matrix and we will put 0 into all the cells (i, j) for which either row[i] or col[j] is marked as 1.
- Thus we will get our final matrix.
Below is the Implementation of the above approach:
C++
// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;
void SetMatrixZeroes(vector<vector<int> >& arr)
{
int n = arr.size(), m = arr[0].size();
// To store which rows and columns
// are supposed to mark with zeroes.
vector<int> row(n, 0), col(m, 0);
// Traverse the matrix using
// 2 nested loops
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
// If the cell contains zero
// then mark its row
// and column zero
if (arr[i][j] == 0) {
row[i] = 1;
col[j] = 1;
}
}
}
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
// Mark cells zero if any
// of the row[i] or col[j] is 1
if (row[i] || col[j])
arr[i][j] = 0;
}
}
}
// Driver Code
int main()
{
vector<vector<int> > arr = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
SetMatrixZeroes(arr);
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
return 0;
}
Java
import java.util.Arrays;
public class MatrixZeroes {
static void setMatrixZeroes(int[][] arr) {
int n = arr.length;
int m = arr[0].length;
// To store which rows and columns are supposed to mark with zeroes.
int[] row = new int[n];
int[] col = new int[m];
// Traverse the matrix using 2 nested loops
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// If the cell contains zero, then mark its row and column zero
if (arr[i][j] == 0) {
row[i] = 1;
col[j] = 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// Mark cells zero if any of the row[i] or col[j] is 1
if (row[i] == 1 || col[j] == 1)
arr[i][j] = 0;
}
}
}
public static void main(String[] args) {
int[][] arr = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
setMatrixZeroes(arr);
// Print the modified matrix
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[0].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
//This code is contributed by chinmaya121221
Python3
def set_matrix_zeroes(matrix):
n = len(matrix)
m = len(matrix[0])
# To store which rows and columns are supposed to mark with zeroes.
row = [0] * n
col = [0] * m
# Traverse the matrix using nested loops
for i in range(n):
for j in range(m):
# If the cell contains zero, mark its row and column as zero
if matrix[i][j] == 0:
row[i] = 1
col[j] = 1
for i in range(n):
for j in range(m):
# Set cells to zero if any of the row[i] or col[j] is 1
if row[i] or col[j]:
matrix[i][j] = 0
# Driver Code
if __name__ == "__main__":
arr = [[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]]
# Function call
set_matrix_zeroes(arr)
for i in range(len(arr)):
for j in range(len(arr[0])):
print(arr[i][j], end=" ")
print()
C#
using System;
public class MatrixZeroes {
static void SetMatrixZeroes(int[, ] arr)
{
int n = arr.GetLength(0);
int m = arr.GetLength(1);
// To store which rows and columns are supposed to
// mark with zeroes.
int[] row = new int[n];
int[] col = new int[m];
// Traverse the matrix using 2 nested loops
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// If the cell contains zero, then mark its
// row and column zero
if (arr[i, j] == 0) {
row[i] = 1;
col[j] = 1;
}
}
}
// Mark cells zero if any of the row[i] or col[j] is
// 1
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (row[i] == 1 || col[j] == 1)
arr[i, j] = 0;
}
}
}
public static void Main(string[] args)
{
int[, ] arr = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
SetMatrixZeroes(arr);
// Print the modified matrix
for (int i = 0; i < arr.GetLength(0); i++) {
for (int j = 0; j < arr.GetLength(1); j++) {
Console.Write(arr[i, j] + " ");
}
Console.WriteLine();
}
}
}
Javascript
function setMatrixZeroes(matrix) {
const n = matrix.length;
const m = matrix[0].length;
// To store which rows and columns are supposed to be marked with zeroes.
const row = new Array(n).fill(0);
const col = new Array(m).fill(0);
// Traverse the matrix using nested loops
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
// If the cell contains zero, mark its row and column as zero
if (matrix[i][j] === 0) {
row[i] = 1;
col[j] = 1;
}
}
}
for (let i = 0; i < n; i++) {
let rowString = "";
for (let j = 0; j < m; j++) {
// Set cells to zero if any of the row[i] or col[j] is 1
if (row[i] || col[j]) {
matrix[i][j] = 0;
}
rowString += matrix[i][j] + " ";
}
console.log(rowString);
}
}
// Driver Code
const arr = [
[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]
];
// Function call
setMatrixZeroes(arr);
Output
0 0 0 0 0 4 5 0 0 3 1 0
Time Complexity: O(2*(N*M)), where N = no. of rows in the matrix and M = no. of columns in the matrix.
Auxillary Space: O(N) + O(M), O(N) is for using the row array and O(M) is for using the col array.
Efficient Approach:
In the previous approach we had taken two arrays to store the ith row's and jth column's status, Idea here is to use the existing space i.e. matrix itself. We can use the first row and first column of a matrix to store which row elements and column elements to be marked as zeroes.
Follow the steps to solve the problem:
- First, we will traverse the matrix and update the first row and first column as follows we check for cell(i,j) if it is zero then we mark arr[i][0] equal to zero and arr[0][j] equal to zero.
- one special case to keep in mind is when i is 0, we will mark matrix[0][0] with 0 but if j is 0, we will mark the C0 variable with 0 instead of marking matrix[0][0] again because one cell can not represent for both row and column.
- Now we will traverse cells from (1,1) to (n-1,m-1) and update the matrix's cell(i,j) according to the first row and first column.
- In the end, we will change the matrix's first row and first column of the matrix as follows, we will change the row first and then the column.
- If arr[0][0] = 0, we will change all the elements from the cell (0,1) to (0, m-1), to 0.
- If C0 = 0, we will change all the elements from the cell (0,0) to (n-1, 0), to 0.
Below is the implementation of the above approach:
C++
// C++ code for the above aprpoach:
#include <bits/stdc++.h>
using namespace std;
void SetarrZeroes(vector<vector<int> >& arr)
{
int n = arr.size(), m = arr[0].size();
int C0 = 1;
// Traverse the arr and
// mark 1st row & 1st
// col as follows:
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 0) {
// mark i-th row:
arr[i][0] = 0;
// mark j-th column:
if (j == 0)
C0 = 0;
else
arr[0][j] = 0;
}
}
}
// Mark with 0 from (1,1)
// to (n-1, m-1):
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (arr[i][j] != 0) {
// Check for col & row:
if (arr[i][0] == 0 || arr[0][j] == 0) {
arr[i][j] = 0;
}
}
}
}
// Finally mark the
// 1st row then 1st col:
if (arr[0][0] == 0) {
for (int j = 0; j < m; j++) {
arr[0][j] = 0;
}
}
if (C0 == 0) {
for (int i = 0; i < n; i++) {
arr[i][0] = 0;
}
}
}
// Driver Code
int main()
{
vector<vector<int> > arr = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
SetarrZeroes(arr);
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[0].size(); j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
return 0;
}
Java
import java.util.Arrays;
public class SetMatrixZeroes {
public static void setMatrixZeroes(int[][] matrix)
{
int n = matrix.length;
int m = matrix[0].length;
int C0 = 1;
// Traverse the matrix and mark 1st row & 1st col as
// follows:
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (matrix[i][j] == 0) {
// mark i-th row:
matrix[i][0] = 0;
// mark j-th column:
if (j == 0)
C0 = 0;
else
matrix[0][j] = 0;
}
}
}
// Mark with 0 from (1,1) to (n-1, m-1):
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (matrix[i][j] != 0) {
// Check for col & row:
if (matrix[i][0] == 0
|| matrix[0][j] == 0) {
matrix[i][j] = 0;
}
}
}
}
// Finally mark the 1st row then 1st col:
if (matrix[0][0] == 0) {
Arrays.fill(matrix[0], 0);
}
if (C0 == 0) {
for (int i = 0; i < n; i++) {
matrix[i][0] = 0;
}
}
}
// Driver Code
public static void main(String[] args)
{
int[][] matrix = { { 0, 1, 2, 0 },
{ 3, 4, 5, 2 },
{ 1, 3, 1, 5 } };
// Function call
setMatrixZeroes(matrix);
// Print the resulting matrix
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
}
Python3
# Python program for the above approach
def set_arr_zeroes(arr):
n, m = len(arr), len(arr[0])
C0 = 1
# Traverse the arr and
# mark 1st row & 1st
# col as follows:
for i in range(n):
for j in range(m):
if arr[i][j] == 0:
# mark i-th row:
arr[i][0] = 0
# mark j-th column:
if j == 0:
C0 = 0
else:
arr[0][j] = 0
# Mark with 0 from (1,1)
# to (n-1, m-1):
for i in range(1, n):
for j in range(1, m):
if arr[i][j] != 0:
# Check for col & row:
if arr[i][0] == 0 or arr[0][j] == 0:
arr[i][j] = 0
# Finally mark the
# 1st row then 1st col:
if arr[0][0] == 0:
for j in range(m):
arr[0][j] = 0
if C0 == 0:
for i in range(n):
arr[i][0] = 0
arr = [[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]]
# Function call
set_arr_zeroes(arr)
for i in range(len(arr)):
for j in range(len(arr[0])):
print(arr[i][j], end=" ")
print()
# This code is contributed by Susobhan Akhuli
C#
using System;
using System.Collections.Generic;
class Program
{
static void SetMatrixZeroes(List<List<int>> matrix)
{
int n = matrix.Count;
int m = matrix[0].Count;
int C0 = 1;
// Traverse the matrix and mark the first row and first column if a zero is found
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
if (matrix[i][j] == 0)
{
// Mark i-th row
matrix[i][0] = 0;
// Mark j-th column
if (j == 0)
C0 = 0;
else
matrix[0][j] = 0;
}
}
}
// Mark with 0 from (1,1) to (n-1, m-1)
for (int i = 1; i < n; i++)
{
for (int j = 1; j < m; j++)
{
if (matrix[i][j] != 0)
{
// Check for column and row
if (matrix[i][0] == 0 || matrix[0][j] == 0)
{
matrix[i][j] = 0;
}
}
}
}
// Finally mark the first row and then the first column
if (matrix[0][0] == 0)
{
for (int j = 0; j < m; j++)
{
matrix[0][j] = 0;
}
}
if (C0 == 0)
{
for (int i = 0; i < n; i++)
{
matrix[i][0] = 0;
}
}
}
static void Main()
{
List<List<int>> matrix = new List<List<int>>{
new List<int>{0, 1, 2, 0},
new List<int>{3, 4, 5, 2},
new List<int>{1, 3, 1, 5}
};
// Function call
SetMatrixZeroes(matrix);
// Print the modified matrix
for (int i = 0; i < matrix.Count; i++)
{
for (int j = 0; j < matrix[0].Count; j++)
{
Console.Write(matrix[i][j] + " ");
}
Console.WriteLine();
}
}
}
Javascript
function setMatrixZeroes(matrix) {
const n = matrix.length;
const m = matrix[0].length;
let C0 = 1;
// Traverse the matrix and mark 1st row & 1st col as follows:
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (matrix[i][j] === 0) {
// mark i-th row:
matrix[i][0] = 0;
// mark j-th column:
if (j === 0) {
C0 = 0;
} else {
matrix[0][j] = 0;
}
}
}
}
// Mark with 0 from (1,1) to (n-1, m-1):
for (let i = 1; i < n; i++) {
for (let j = 1; j < m; j++) {
if (matrix[i][j] !== 0) {
// Check for col & row:
if (matrix[i][0] === 0 || matrix[0][j] === 0) {
matrix[i][j] = 0;
}
}
}
}
// Finally mark the 1st row then 1st col:
if (matrix[0][0] === 0) {
matrix[0].fill(0);
}
if (C0 === 0) {
for (let i = 0; i < n; i++) {
matrix[i][0] = 0;
}
}
}
// Driver Code
const matrix = [
[0, 1, 2, 0],
[3, 4, 5, 2],
[1, 3, 1, 5]
];
// Function call
setMatrixZeroes(matrix);
// Print the resulting matrix
for (let i = 0; i < matrix.length; i++) {
console.log(matrix[i].join(' '));
}
Output
0 0 0 0 0 4 5 0 0 3 1 0
Time Complexity: O(2*(N*M))
Auxillary space: O(1)