Special Positions in a Binary Matrix - Practice Coding Problems

Special Positions in a Binary Matrix - Problem

Array Matrix Easy

You're given an m × n binary matrix where each cell contains either 0 or 1. Your task is to find all the "special positions" in this matrix.

A position (i, j) is considered special if:

The cell at mat[i][j] contains a 1
All other elements in row i are 0
All other elements in column j are 0

In other words, a special position is like finding a unique lighthouse in a grid - it's the only light (1) in both its row and column!

Goal: Return the total count of special positions in the matrix.

Input & Output

example_1.py — Basic Matrix

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

› Output: 1

💡 Note: Position (1,2) has value 1, is the only 1 in row 1, and the only 1 in column 2, making it special. Other 1s share their columns with other 1s.

example_2.py — Multiple Special

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

› Output: 3

💡 Note: This is a diagonal matrix where each 1 is the only 1 in both its row and column. All three positions (0,0), (1,1), and (2,2) are special.

example_3.py — No Special Positions

$ Input: mat = [[0,0],[0,0]]

› Output: 0

💡 Note: Matrix contains only zeros, so there are no 1s and therefore no special positions possible.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
mat[i][j] is either 0 or 1
Each cell contains exactly one binary digit

Visualization

Tap to expand

Understanding the Visualization

Scan the Ocean

Look at each territory in the grid to find all lighthouses (1s)

Check Isolation

For each lighthouse, verify it's the only one in its row AND column

Count Special Lighthouses

Increment counter for each lighthouse that meets both isolation criteria

Key Takeaway

🎯 Key Insight: Pre-calculating row and column sums allows us to determine if a lighthouse is special in constant time, transforming an O(m²n²) problem into O(mn).

Asked in

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

The optimal approach uses a two-pass strategy: first calculate row and column sums, then check each 1 in O(1) time. This achieves O(mn) time complexity with O(m+n) space, eliminating redundant calculations from the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Optimization	O(mn)	O(m + n)	Pre-calculate row and column sums, then check each 1 in O(1) time
Brute Force (Check Each Cell)	O(m²n²)	O(1)	For each 1, manually check if it's the only 1 in its row and column

Two-Pass Optimization — Algorithm Steps

First pass: Calculate sum of each row and store in rowSum array
First pass: Calculate sum of each column and store in colSum array
Second pass: For each cell with value 1, check if rowSum[i] == 1 and colSum[j] == 1
If both conditions are met, increment the special position counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Row Sums

First pass: sum each row and store results

Calculate Column Sums

Continue first pass: sum each column and store results

Quick Lookup

Second pass: for each 1, instantly check if row_sum=1 and col_sum=1

Code -

solution.c — C

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

int numSpecialPositions(int** mat, int matSize, int* matColSize) {
    int m = matSize, n = matColSize[0];
    
    // First pass: calculate row and column sums
    int* rowSums = (int*)calloc(m, sizeof(int));
    int* colSums = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            rowSums[i] += mat[i][j];
            colSums[j] += mat[i][j];
        }
    }
    
    // Second pass: check each 1 for special condition
    int specialCount = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 1 && rowSums[i] == 1 && colSums[j] == 1) {
                specialCount++;
            }
        }
    }
    
    free(rowSums);
    free(colSums);
    return specialCount;
}

int main() {
    printf("Two-pass solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Two passes through the m×n matrix, each cell visited exactly twice

✓ Linear Growth

Space Complexity

O(m + n)

Extra arrays to store row sums (size m) and column sums (size n)

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 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

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler