Set Matrix Zeroes In Place in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main goal of the "Set Matrix Zeroes In Place" problem?

To modify a given matrix so that if an element is 0, its entire row and column are set to 0, without using extra space for another matrix.

intermediate

Why do we use the first row and first column of the matrix as markers in the in-place solution?

Because using the first row and column as markers helps track which rows and columns should be zeroed without extra space, saving memory.

intermediate

In the in-place approach, how do we handle the first row and first column separately?

We use two separate boolean flags to remember if the first row or first column originally contained any zero, so we can zero them at the end if needed.

beginner

What is the time complexity of the in-place solution for setting matrix zeroes?

O(m * n), where m is the number of rows and n is the number of columns, because we scan the matrix multiple times but each scan is linear in size.

beginner

Explain why using extra space to store zero positions is not optimal for this problem.

Using extra space like additional arrays or sets increases memory usage, which is not efficient. The in-place method avoids this by cleverly using the matrix itself for marking.

What does the in-place solution use to mark rows and columns that need to be zeroed?

A A separate boolean matrix

B The first row and first column of the matrix

C A hash map

D A queue

The in-place solution uses the first row and first column as markers to avoid extra space.

How do we know if the first row needs to be zeroed in the in-place method?

A By checking a separate flag set during the first scan

B By scanning the entire matrix again

C By checking the last row only

D By using recursion

A boolean flag is set if any zero is found in the first row during the initial scan.

What is the space complexity of the in-place solution?

A O(1)

B O(m + n)

C O(m * n)

D O(log(m * n))

The in-place solution uses constant extra space by marking within the matrix.

Which step is done last in the in-place algorithm?

A Scanning the matrix for zeros

B Marking zeros in the matrix

C Zeroing the first row and first column if needed

D Returning the matrix

Zeroing the first row and column is done last to avoid overwriting markers early.

If a matrix element at (i, j) is zero, which parts of the matrix are set to zero?

A Only column j

B Only row i

C Diagonal elements

D Row i and column j

Both the entire row i and column j are set to zero.

Describe the step-by-step process of the in-place algorithm to set matrix zeroes.

Think about how to mark and then zero without extra space.

Explain why the first row and first column need special handling in the in-place solution.

Consider what happens if you overwrite markers too early.

Practice

1. What is the main goal of the Set Matrix Zeroes In Place problem?

easy

A. Sort each row of the matrix in ascending order.

B. Find the sum of all elements in the matrix.

C. Count the number of zero elements in the matrix.

D. Modify the matrix so that if an element is 0, its entire row and column become 0 without using extra space.

Solution

1. Step 1: Understand the problem requirement

   The problem requires changing the matrix so that any row or column containing a zero is set entirely to zero.

2. Step 2: Note the in-place constraint

   We must do this without using extra space for another matrix or large data structures.

3. Final Answer:

   Modify the matrix so that if an element is 0, its entire row and column become 0 without using extra space. -> Option D

4. Quick Check:

   In-place zeroing = Modify matrix rows and columns [OK]

Hint: Remember: zero means zero entire row and column in place [OK]

Common Mistakes:

• Using extra space like another matrix
• Only zeroing the element itself, not row and column
• Not handling the in-place requirement

2. Which of the following C++ code snippets correctly declares a 2D vector to represent a matrix for the Set Matrix Zeroes In Place problem?

easy

A. std::vector matrix(cols, std::vector<int>(rows));

B. std::vector<int> matrix(rows, cols);

C. std::vector matrix(rows, std::vector<int>(cols));

D. std::vector<int> matrix[rows][cols];

Solution

1. Step 1: Understand 2D vector declaration

   To create a matrix with 'rows' rows and 'cols' columns, use vector of vectors with inner vector size 'cols'.

2. Step 2: Check each option

   std::vector matrix(rows, std::vector<int>(cols)); correctly creates a vector of vectors with 'rows' outer vectors and 'cols' inner vectors each.

3. Final Answer:

   std::vector matrix(rows, std::vector<int>(cols)); -> Option C

4. Quick Check:

   Correct 2D vector syntax = std::vector matrix(rows, std::vector<int>(cols)); [OK]

Hint: Use vector of vectors with inner vector size as columns [OK]

Common Mistakes:

• Using single vector with two sizes incorrectly
• Swapping rows and columns in inner vector
• Using array syntax instead of vector

3. What will be the state of the matrix after running the following code snippet for Set Matrix Zeroes In Place?

std::vector matrix = {
  {1, 2, 3},
  {4, 0, 6},
  {7, 8, 9}
};
// Assume correct in-place zeroing function is called here
setZeroes(matrix);
// Print matrix

medium

A. [[1, 2, 3], [4, 0, 6], [7, 8, 9]]

B. [[1, 0, 3], [0, 0, 0], [7, 0, 9]]

C. [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

D. [[1, 2, 3], [0, 0, 0], [7, 8, 9]]

Solution

1. Step 1: Identify zero positions

   The zero is at position (1,1) (second row, second column).

2. Step 2: Set entire row and column to zero

   Row 1 becomes [0,0,0], column 1 becomes zero in rows 0 and 2, so matrix becomes [[1,0,3],[0,0,0],[7,0,9]].

3. Final Answer:

   [[1, 0, 3], [0, 0, 0], [7, 0, 9]] -> Option B

4. Quick Check:

   Zero at (1,1) zeroes row 1 and column 1 [OK]

Hint: Zero row and column where zero found [OK]

Common Mistakes:

• Zeroing entire matrix instead of row and column
• Not zeroing column correctly
• Leaving original zero row unchanged

4. Consider this buggy code snippet for Set Matrix Zeroes In Place. What is the main error?

void setZeroes(std::vector& matrix) {
  int rows = matrix.size();
  int cols = matrix[0].size();
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      if (matrix[i][j] == 0) {
        for (int k = 0; k < cols; k++) matrix[i][k] = 0;
        for (int k = 0; k < rows; k++) matrix[k][j] = 0;
      }
    }
  }
}

medium

A. Modifying matrix inside loops causes multiple zeroing and incorrect results.

B. The loops do not cover all rows and columns.

C. The function does not return the modified matrix.

D. The matrix size is not checked for empty input.

Solution

1. Step 1: Analyze modification during iteration

   The code sets zeros immediately when a zero is found, changing matrix during iteration.

2. Step 2: Understand side effects

   This causes new zeros to appear and cause more zeroing, leading to incorrect results.

3. Final Answer:

   Modifying matrix inside loops causes multiple zeroing and incorrect results. -> Option A

4. Quick Check:

   Immediate modification causes cascading zeroing [OK]

Hint: Mark zeros first, then modify matrix after loops [OK]

Common Mistakes:

• Changing matrix while scanning causes wrong zeroing
• Not using markers or flags to delay zeroing
• Ignoring empty matrix edge cases

5. Given a matrix with multiple zeros, how can you efficiently set matrix zeroes in place without extra space? Choose the best approach.

hard

A. Use first row and first column as markers to store zero flags, then update matrix accordingly.

B. Create a copy of the matrix and update zeros in the copy.

C. Use a hash map to store zero positions and then update matrix.

D. Iterate multiple times over the matrix zeroing rows and columns immediately when zero found.

Solution

1. Step 1: Use first row and column as markers

   Mark zeros found in first row and column to remember which rows and columns to zero later.

2. Step 2: Update matrix based on markers

   After marking, zero out rows and columns except first row and column, then handle first row and column separately.

3. Final Answer:

   Use first row and first column as markers to store zero flags, then update matrix accordingly. -> Option A

4. Quick Check:

   In-place marking with first row/column = Use first row and first column as markers to store zero flags, then update matrix accordingly. [OK]

Hint: Use matrix edges as flags to avoid extra space [OK]

Common Mistakes:

• Using extra space violating in-place rule
• Zeroing immediately causing cascading errors
• Not handling first row and column separately