Cells with Odd Values in a Matrix

Cells with Odd Values in a Matrix - Problem

Given an m x n matrix initialized to all zeros, and a 2D array indices where each indices[i] = [r_i, c_i] represents a location to perform increment operations.

For each location indices[i], do both of the following:

Increment all cells in row r_i
Increment all cells in column c_i

Return the number of cells with odd values in the matrix after applying all increment operations.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Matrix starts as zeros. After [0,1]: increment row 0 and column 1. After [1,1]: increment row 1 and column 1 again. Final matrix [[1,3,1],[1,3,1]] has 6 odd values.

Example 2 — Single Operation

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

› Output: 2

💡 Note: After [1,1]: increment row 1 and column 1. Final matrix [[0,1],[1,2]] has 2 odd values at positions (0,1) and (1,0).

Example 3 — No Operations

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

› Output: 0

💡 Note: No operations performed, matrix remains all zeros, so 0 odd values.

Constraints

1 ≤ m, n ≤ 50
1 ≤ indices.length ≤ 100
0 ≤ r_i < m
0 ≤ c_i < n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that a cell's final value equals the number of times its row was incremented plus the number of times its column was incremented. A cell has an odd value when this sum is odd, which happens when exactly one of (row count, column count) is odd. The optimal approach uses the mathematical formula: odd_rows × even_cols + even_rows × odd_cols. Time: O(k), Space: O(m + n)

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Count Row/Column Increments

⏱️ Time: O(k + m×n) Space: O(m + n)

Instead of building the matrix, count increments for each row and column, then calculate how many cells will be odd.

Mathematical Formula

⏱️ Time: O(k) Space: O(m + n)

A cell is odd when row_count + col_count is odd, which happens when exactly one of them is odd. Count odd/even rows and columns, then use multiplication.

Simulate Matrix Operations

⏱️ Time: O(k×(m+n)) Space: O(m×n)

Build an actual m×n matrix, process each index by incrementing entire rows and columns, then count cells with odd values.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct Node {
    int val;
    struct Node* left;
    struct Node* right;
    struct Node* parent;
};

struct Node* flipBinaryTree(struct Node* root, struct Node* leaf) {
    if (!root || !leaf || root == leaf) {
        return leaf;
    }
    
    struct Node* current = leaf;
    struct Node* newRoot = leaf;
    
    while (current->parent) {
        struct Node* parent = current->parent;
        struct Node* grandparent = parent->parent;
        
        // Remove current from parent's children
        if (parent->left == current) {
            parent->left = NULL;
        } else {
            parent->right = NULL;
        }
        
        // If current had a left child, move it to right
        if (current->left) {
            current->right = current->left;
        }
        
        // Make parent the left child of current
        current->left = parent;
        current->parent = grandparent;
        parent->parent = current;
        
        // Move up the tree
        current = grandparent;
    }
    
    newRoot->parent = NULL;
    return newRoot;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

892 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