If a cell in a matrix is zero, zero out its entire row and column, then return the matrix. Test your code and explore the solution. Free online practice.

Set Matrix Zeroes – Solve Online

Spiral Matrix II

First Missing Positive

If a cell in a matrix is zero, zero out its entire row and column, then return the matrix.

Given an `m x n` integer matrix, if a cell contains `0`, set its entire row and column to `0`. Return the modified matrix.

**Input / output**
- Input: `matrix: int[][]`
- Output: `int[][]` (the modified matrix)

**Examples**
1. `matrix = [[1,1,1],[1,0,1],[1,1,1]]` returns `[[1,0,1],[0,0,0],[1,0,1]]`.
2. `matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]` returns `[[0,0,0,0],[0,4,5,0],[0,3,1,0]]`.
3. `matrix = [[1]]` returns `[[1]]` (no zero present).

**Constraints**
- `1 <= matrix.length, matrix[0].length <= 200`
- `-2^31 <= matrix[i][j] <= 2^31 - 1`

**Follow-up**
Can you do it using `O(1)` extra space by reusing the first row and first column of the matrix itself as marker storage, instead of allocating separate row/column tracking sets?

- A single `0` anywhere in the matrix wipes out its whole row and its whole column.
- The tricky part is not overwriting a cell to `0` and then mistakenly treating that new `0` as if it were an original zero later in the scan.

Understanding the problem

- Make a copy of the original matrix so zeroing decisions are always based on the untouched values.
- Scan the copy for zeros, and zero the corresponding row/column in the real matrix.
- Uses `O(m*n)` extra space, but is simple and clearly correct.

Brute-force with an extra copy

- Instead of copying the whole matrix, do one pass to record which row indices and column indices contain a zero.
- Then do a second pass and zero any cell whose row or column was recorded.
- This drops space from `O(m*n)` to `O(m + n)`.

Reduce space with row/column marker sets

Trace `matrix = [[1,0],[0,1]]`.

| step | action | zero_rows | zero_cols |
|---|---|---|---|
| scan (0,1) | value is 0 | `{0}` | `{1}` |
| scan (1,0) | value is 0 | `{0,1}` | `{0,1}` |

Second pass: every row is in `zero_rows` and every column is in `zero_cols`, so all four cells become `0`, giving `[[0,0],[0,0]]`.

Dry run / state trace

- Zeroing cells while still scanning for the *original* zeros, which turns freshly-zeroed cells into false positives for later iterations.
- Forgetting the empty-matrix guard before indexing `matrix[0]`.
- Follow-up: the true `O(1)` extra-space version reuses `matrix[0]` and the first column as the marker arrays themselves, with one extra boolean to remember whether the first row/column originally had a zero — worth mentioning even though this judge's tests only check the returned values, not memory usage.

Common mistakes and follow-ups

- A `1x1` matrix with either a zero or non-zero value.
- A matrix with no zero at all (must be returned unchanged).
- A matrix where every row and column ends up zeroed.
- Negative values mixed with a single zero.

Edge cases to test mentally

Record zero rows/columns in a first pass, then zero matching cells in a second pass. Time is `O(m*n)`, and extra space is `O(m + n)` for the marker sets.