The “Cells with Odd Values in a Matrix” problem on Leetcode is an engaging problem that tests one’s ability to manipulate 2D arrays efficiently. Although this problem may seem simple at first glance, there are various ways to solve it, some of which are more optimized than others. In this article, we will dive into multiple approaches to solve this problem, evaluate their time and space complexities, and provide Python code samples to clarify each approach.

## Problem Statement

### Description

Given n and m which are the dimensions of a matrix initialized by zeros and given an array `indices`

of size idx × 2, where `indices[i] = [ri, ci]`

. For each pair of [ri,ci] you have to increment all cells in row ri and column ci by 1. Return the number of cells with odd values in the matrix after applying the increment to all `indices`

.

## Understanding the Problem

The task asks you to initialize an n×m matrix with zeros and increment cells based on given row and column indices. Finally, you’re supposed to count the number of cells with odd values.

## Approaches

### Approach 1: Brute Force Iteration

The simplest way to solve this problem is by using nested loops to increment each cell for every row-column pair in the array `indices`

.

#### Algorithm

- Initialize a n×m matrix filled with zeros.
- For each pair [ri,ci] in
`indices`

:- Increment all cells in row ri.
- Increment all cells in column ci.

- Count and return the number of cells with odd values.

#### Python Code Implementation

```
def odd_cells(n, m, indices):
matrix = [[0 for _ in range(m)] for _ in range(n)]
for ri, ci in indices:
for j in range(m):
matrix[ri][j] += 1
for i in range(n):
matrix[i][ci] += 1
return sum(cell % 2 != 0 for row in matrix for cell in row)
# Test the function
print(odd_cells(2, 3, [[0, 1], [1, 1]])) # Output should be 6
```

#### Time Complexity

This algorithm has a time complexity of O(n×m×idx).

#### Space Complexity

The space complexity is O(n×m).

### Approach 2: Optimization using Counters

We can optimize this by noting that incrementing a cell twice would result in an even value, essentially nullifying the effect of odd numbers. Hence, we could simply count how many times each row and each column needs to be incremented and then derive the number of odd cells.

#### Algorithm

- Initialize counters for rows and columns.
- For each pair [ri,ci] in
`indices`

:- Increment the row counter for ri.
- Increment the column counter for ci.

- Calculate the number of cells with odd values based on the row and column counters.

#### Python Code Implementation

```
def odd_cells(n, m, indices):
row_counter = [0] * n
col_counter = [0] * m
for ri, ci in indices:
row_counter[ri] += 1
col_counter[ci] += 1
odd_count = 0
for i in range(n):
for j in range(m):
odd_count += (row_counter[i] + col_counter[j]) % 2 != 0
return odd_count
# Test the function
print(odd_cells(2, 3, [[0, 1], [1, 1]])) # Output should be 6
```

#### Time Complexity

This algorithm has a time complexity of O(n×m+idx).

#### Space Complexity

The space complexity is O(n+m).

## Conclusion

The “Cells with Odd Values in a Matrix” problem offers an exciting exploration of 2D array manipulation. We looked at two approaches to solving the problem. The first approach is straightforward but less efficient, while the second approach optimizes the algorithm by using counters to track row and column increments.