Special Positions in a Binary Matrix

Special Positions in a Binary Matrix - Problem

Array Matrix Easy

Given an m x n binary matrix mat, return the number of special positions in mat.

A position (i, j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

Input & Output

Example 1 — Basic Matrix

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

› Output: 1

💡 Note: Position (1,2) is special: mat[1][2]=1, row 1 has sum 1, column 2 has sum 1

Example 2 — No Special Positions

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

› Output: 3

💡 Note: All three positions (0,0), (1,1), and (2,2) are special - each has unique row and column

Example 3 — Multiple 1s in Row/Column

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

› Output: 2

💡 Note: Positions (0,3) and (1,0) are special, but (2,1) and (2,2) are not because row 2 has multiple 1s

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
mat[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 12 A Amazon 8 M Microsoft 6

The key insight is that a position is special only when both its row sum and column sum equal 1. The optimized approach pre-calculates all row and column sums to avoid redundant calculations. Time: O(m×n), Space: O(m+n)

Common Approaches

✓ Brute Force Check

⏱️ Time: O(m²×n²) Space: O(1)

Iterate through every cell, and when we find a 1, check if all other cells in that row and column are 0. This means checking the entire row and column for each potential special position.

Pre-calculate Sums

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

Instead of recalculating row and column sums for each position, we pre-calculate all row sums and column sums once. Then we iterate through the matrix and check if a position with value 1 has both row sum = 1 and column sum = 1.

Brute Force Check — Algorithm Steps

Iterate through each cell (i,j)
If mat[i][j] == 1, check entire row i and column j
Count if it's the only 1 in both row and column

Visualization

Tap to expand

Step-by-Step Walkthrough

Find 1

Located mat[0][1] = 1

Check Row

Row 0: [1,0,0] sum = 1 ✓

Check Column

Column 1: [0,1,1] sum = 2 ✗

Code -

solution.c — C

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

int solution(int mat[][100], int m, int n) {
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 1) {
                // Check if this is the only 1 in row i
                int rowSum = 0;
                for (int k = 0; k < n; k++) {
                    rowSum += mat[i][k];
                }
                if (rowSum != 1) continue;
                
                // Check if this is the only 1 in column j
                int colSum = 0;
                for (int k = 0; k < m; k++) {
                    colSum += mat[k][j];
                }
                if (colSum == 1) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int mat[100][100];
    int m = 0, n = 0;
    
    // Simple JSON parsing
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find first [
    ptr++; // Skip [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '1') {
                    mat[m][n++] = *ptr - '0';
                }
                ptr++;
            }
            m++;
        }
        ptr++;
    }
    
    int result = solution(mat, m, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²×n²)

For each cell we check entire row (n elements) and column (m elements)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler