Cells with Odd Values in a Matrix - Practice Coding Problems

Cells with Odd Values in a Matrix - Problem

Matrix Increment Challenge: You're given an m × n matrix initially filled with zeros. Your task is to perform a series of increment operations and count how many cells end up with odd values.

Each operation is defined by indices[i] = [ri, ci], which means:
• Increment all cells in row ri
• Increment all cells in column ci

After applying all operations, return the total number of cells with odd values.

Example: With a 2×3 matrix and indices [[0,1], [1,1]], the matrix transforms from all zeros to having 6 cells with specific increment counts, and you need to count how many are odd.

Input & Output

example_1.py — Basic Case

$ Input: m = 2, n = 3, indices = [[0,1],[1,1]]

› Output: 6

💡 Note: After operations: matrix becomes [[1,3,1],[1,2,1]]. The odd values are 1,3,1,1,1 (5 cells with odd values) - wait, let me recalculate: all cells except [1,1] are odd, so 5 odd cells total.

example_2.py — Single Operation

$ Input: m = 2, n = 2, indices = [[1,1]]

› Output: 4

💡 Note: After operation [1,1]: matrix becomes [[0,1],[1,2]]. Cells with odd values: [0,1] and [1,0] have value 1, so 2 odd cells. Actually: row 1 and col 1 both get +1, so final matrix is [[0,1],[1,2]], giving us 2 odd cells.

example_3.py — No Operations

$ Input: m = 2, n = 3, indices = []

› Output: 0

💡 Note: No operations means all cells remain 0 (even), so 0 cells have odd values.

Visualization

Tap to expand

Understanding the Visualization

Key Observation

Each cell's final value equals the number of row operations affecting it plus column operations

Mathematical Formula

cell[i][j] = count_of_ops_on_row_i + count_of_ops_on_col_j

Odd/Even Rule

A sum of two integers is odd if and only if exactly one of them is odd

Optimization

Instead of O(m×n) matrix, use O(m+n) counters and apply the formula

Key Takeaway

🎯 Key Insight: Since each cell's value is simply the sum of its row and column operation counts, we can solve this in O(m+n) space by tracking only the counters, not the full matrix.

Time & Space Complexity

Time Complexity

⏱️

O(k + m×n)

k operations to count increments, then m×n iterations to check each cell

✓ Linear Growth

Space Complexity

O(m + n)

Only need arrays to store row and column increment counts

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 50
0 ≤ indices.length ≤ 100
0 ≤ r_i < m
0 ≤ c_i < n
Each indices[i] represents a valid matrix position

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach counts row and column increments separately, then uses the mathematical insight that cell (i,j) has value row_count[i] + col_count[j]. A sum is odd when exactly one addend is odd. This reduces space from O(m×n) to O(m+n) while maintaining O(k+m×n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Counting (Space Efficient)	O(k + m×n)	O(m + n)	Count row and column increments instead of simulating the full matrix

Optimized Counting (Space Efficient) — Algorithm Steps

Create arrays to count increments for each row and column
For each operation [ri, ci], increment row_count[ri] and col_count[ci]
For each cell (i,j), calculate value as row_count[i] + col_count[j]
Count cells where this sum is odd

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Operations

For indices [[0,1],[1,1]]: row_count=[1,1], col_count=[0,2,0]

Calculate Cell Values

Each cell (i,j) has value row_count[i] + col_count[j]

Check Odd Values

Count positions where row_count[i] + col_count[j] is odd

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int oddCells(int m, int n, int** indices, int indicesSize) {
    // Count increments for each row and column
    int* rowCount = (int*)calloc(m, sizeof(int));
    int* colCount = (int*)calloc(n, sizeof(int));
    
    // Process each operation
    for (int k = 0; k < indicesSize; k++) {
        rowCount[indices[k][0]]++;
        colCount[indices[k][1]]++;
    }
    
    // Count cells with odd values
    int oddCells = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Cell value = row increments + column increments
            if ((rowCount[i] + colCount[j]) % 2 == 1) {
                oddCells++;
            }
        }
    }
    
    free(rowCount);
    free(colCount);
    return oddCells;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    int indicesData[2][2] = {{0,1}, {1,1}};
    int* indices[2] = {indicesData[0], indicesData[1]};
    printf("%d\n", oddCells(m, n, indices, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k + m×n)

k operations to count increments, then m×n iterations to check each cell

✓ Linear Growth

Space Complexity

O(m + n)

Only need arrays to store row and column increment counts

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 50
0 ≤ indices.length ≤ 100
0 ≤ r_i < m
0 ≤ c_i < n
Each indices[i] represents a valid matrix position

23.5K Views

Medium Frequency

~8 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Counting (Space Efficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler