Difference Between Ones and Zeros in Row and Column

Difference Between Ones and Zeros in Row and Column - Problem

You are given a binary matrix grid of size m × n, where each cell contains either 0 or 1.

Your task is to create a difference matrix where each cell diff[i][j] represents the "balance" of ones versus zeros for position (i,j).

The formula:
diff[i][j] = onesInRow[i] + onesInCol[j] - zerosInRow[i] - zerosInCol[j]

In other words, for each position, you:

Count all ones in the same row and column
Count all zeros in the same row and column
Calculate: (ones count) - (zeros count)

Goal: Return the complete difference matrix.

Input & Output

example_1.py — Basic 3×3 Matrix

$ Input: grid = [[0,1,1],[1,0,1],[0,0,1]]

› Output: [[0,0,4],[0,0,4],[-2,-2,2]]

💡 Note: For position (0,0): row 0 has 2 ones and 1 zero, column 0 has 1 one and 2 zeros. Formula: 2+1-1-2 = 0. For position (2,2): row 2 has 1 one and 2 zeros, column 2 has 3 ones and 0 zeros. Formula: 1+3-2-0 = 2.

example_2.py — All Ones Matrix

$ Input: grid = [[1,1],[1,1]]

› Output: [[4,4],[4,4]]

💡 Note: Every row has 2 ones and 0 zeros, every column has 2 ones and 0 zeros. For any position: 2+2-0-0 = 4.

example_3.py — Single Cell Matrix

$ Input: grid = [[1]]

› Output: [[2]]

💡 Note: The single row has 1 one and 0 zeros, the single column has 1 one and 0 zeros. Formula: 1+1-0-0 = 2.

Visualization

Tap to expand

Location: 2nd St & B Ave (currently 😞)🏪 2nd Street: 😊😞😊 → 2 positive, 1 negative🛣️ B Avenue: 😊😞😞 → 1 positive, 2 negative📊 Score: (2+1) - (1+2) = 0💡 Key Insight: Pre-count each street/avenue once!⚡ Optimization StrategyStep 1: Send scouts to count reviews on each streetStep 2: Send scouts to count reviews on each avenueStep 3: For each restaurant, instant lookup + formula🎯 Result: O(m×n) time instead of O(m×n×(m+n))

Understanding the Visualization

City Grid Setup

Each restaurant location has either positive (1) or negative (0) reviews

Street & Avenue Analysis

For each location, we consider all reviews on its street (row) and avenue (column)

Smart Preprocessing

Instead of walking the same streets repeatedly, send scouts once to count all reviews

Efficient Calculation

For each restaurant, quickly look up the pre-counted totals and apply the formula

Key Takeaway

🎯 Key Insight: By preprocessing row and column statistics once, we transform an O(m×n×(m+n)) brute force solution into an optimal O(m×n) approach, similar to how sending scouts once to count street reviews is far more efficient than walking the same streets repeatedly for each restaurant.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Two passes: O(m×n) to compute statistics + O(m×n) to build result

✓ Linear Growth

Space Complexity

O(m + n)

Extra arrays to store ones count for each row and column

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
grid[i][j] is either 0 or 1

Asked in

G Google 32 a Amazon 28 ⊞ Microsoft 24 f Meta 18

The optimal solution uses a two-pass preprocessing approach with O(m×n) time and O(m+n) space. First, count ones in each row and column. Then, apply the formula using precomputed values, eliminating redundant counting that would occur in the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Preprocessing	O(m × n)	O(m + n)	Pre-compute row and column statistics, then build difference matrix
Brute Force (Nested Loops)	O(m × n × (m + n))	O(1)	For each cell, count ones/zeros in its row and column separately

Optimized Preprocessing — Algorithm Steps

First pass: Calculate ones count for each row and column
Calculate zeros count using: zeros = total_length - ones
Second pass: For each cell, look up precomputed values
Apply formula using cached row/column statistics
Build and return the difference matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Calculate ones/zeros count for each row and column

Cache Results

Store the counts in arrays for quick lookup

Second Pass

Build result matrix using cached values

Formula Application

Apply formula with O(1) lookups for each cell

Code -

solution.c — C

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

int** onesMinusZeros(int** grid, int m, int n) {
    // First pass: compute row and column statistics
    int* rowOnes = (int*)calloc(m, sizeof(int));
    int* colOnes = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            rowOnes[i] += grid[i][j];
            colOnes[j] += grid[i][j];
        }
    }
    
    int* rowZeros = (int*)malloc(m * sizeof(int));
    int* colZeros = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < m; i++) rowZeros[i] = n - rowOnes[i];
    for (int j = 0; j < n; j++) colZeros[j] = m - colOnes[j];
    
    // Second pass: build difference matrix
    int** diff = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        diff[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            diff[i][j] = rowOnes[i] + colOnes[j] - rowZeros[i] - colZeros[j];
        }
    }
    
    free(rowOnes); free(colOnes);
    free(rowZeros); free(colZeros);
    return diff;
}

int main() {
    int m = 3, n = 3;
    int** grid = (int**)malloc(m * sizeof(int*));
    int data[3][3] = {{0,1,1},{1,0,1},{0,0,1}};
    
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            grid[i][j] = data[i][j];
        }
    }
    
    int** result = onesMinusZeros(grid, m, n);
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Two passes: O(m×n) to compute statistics + O(m×n) to build result

✓ Linear Growth

Space Complexity

O(m + n)

Extra arrays to store ones count for each row and column

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
grid[i][j] is either 0 or 1

23.4K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler