Number of Black Blocks

Number of Black Blocks - Problem

You are given two integers m and n representing the dimensions of a 0-indexed m x n grid.

You are also given a 0-indexed 2D integer matrix coordinates, where coordinates[i] = [x, y] indicates that the cell with coordinates [x, y] is colored black. All cells in the grid that do not appear in coordinates are white.

A block is defined as a 2 x 2 submatrix of the grid. More formally, a block with cell [x, y] as its top-left corner where 0 <= x < m - 1 and 0 <= y < n - 1 contains the coordinates [x, y], [x + 1, y], [x, y + 1], and [x + 1, y + 1].

Return a 0-indexed integer array arr of size 5 such that arr[i] is the number of blocks that contains exactly i black cells.

Input & Output

Example 1 — Basic 3x3 Grid

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

› Output: [0,3,1,0,0]

💡 Note: There are 4 possible 2x2 blocks. Block (0,0) contains cells [(0,0),(0,1),(1,0),(1,1)] with 2 black cells at (0,0) and (1,1). Block (0,1) contains 1 black cell at (1,1). Block (1,0) contains 1 black cell at (1,1). Block (1,1) contains 1 black cell at (1,1). So we have 0 blocks with 0 black, 3 blocks with 1 black, 1 block with 2 black, and 0 blocks with 3+ black.

Example 2 — All Black 2x2

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

› Output: [0,0,0,0,1]

💡 Note: Only one 2x2 block possible at (0,0) containing all 4 black cells [(0,0),(0,1),(1,0),(1,1)], so result is [0,0,0,0,1].

Example 3 — No Black Cells

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

› Output: [1,0,0,0,0]

💡 Note: Only one 2x2 block with no black cells, so result is [1,0,0,0,0].

Constraints

1 ≤ m, n ≤ 10⁵
0 ≤ coordinates.length ≤ 10⁴
coordinates[i].length == 2
0 ≤ x_i < m
0 ≤ y_i < n
It is guaranteed that coordinates contains pairwise distinct coordinates.

Visualization

Tap to expand

Asked in

M Microsoft 25 G Google 20

The key insight is to use a hash set for O(1) coordinate lookups instead of scanning the coordinates array repeatedly. Best approach uses hash map optimization: Time O(m×n + k), Space O(k).

Common Approaches

✓ Brute Force - Check Every Block

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

For each possible 2x2 block, count black cells by scanning the entire coordinates array to check if each of the 4 cells exists. This approach iterates through all blocks and for each block checks all coordinates.

Hash Map Optimization

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

Convert coordinates to a hash set for instant lookup. For each 2x2 block, check if each of the 4 cells exists in the hash set. This eliminates the need to scan the entire coordinates array for each cell.

Brute Force - Check Every Block — Algorithm Steps

Iterate through all possible 2x2 blocks
For each block, count black cells by searching coordinates array
Increment counter for blocks with 0,1,2,3,4 black cells

Visualization

Tap to expand

Step-by-Step Walkthrough

Grid Setup

3x3 grid with black cells at [0,0] and [1,1]

Check Blocks

For each 2x2 block, search coordinates array

Count Results

Count blocks by number of black cells

Code -

solution.c — C

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

void solution(int m, int n, int coordinates[][2], int coordSize, int* result) {
    for (int i = 0; i < 5; i++) result[i] = 0;
    
    // Check each possible 2x2 block
    for (int i = 0; i < m - 1; i++) {
        for (int j = 0; j < n - 1; j++) {
            int blackCount = 0;
            
            // Check all 4 cells in this block
            int blockCells[4][2] = {{i, j}, {i+1, j}, {i, j+1}, {i+1, j+1}};
            
            for (int k = 0; k < 4; k++) {
                // Check if this cell is in coordinates (brute force search)
                for (int l = 0; l < coordSize; l++) {
                    if (coordinates[l][0] == blockCells[k][0] && 
                        coordinates[l][1] == blockCells[k][1]) {
                        blackCount++;
                        break;
                    }
                }
            }
            
            result[blackCount]++;
        }
    }
}

int main() {
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    
    int coordSize = 0;
    int coordinates[1000][2];
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Parse coordinates using strtol-based parsing
    const char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse first number
        coordinates[coordSize][0] = (int)strtol(p, (char**)&p, 10);
        
        // Skip comma
        while (*p == ',' || *p == ' ') p++;
        
        // Parse second number
        coordinates[coordSize][1] = (int)strtol(p, (char**)&p, 10);
        
        // Skip closing bracket
        while (*p == ']' || *p == ' ') p++;
        
        coordSize++;
    }
    
    int result[5];
    solution(m, n, coordinates, coordSize, result);
    
    printf("[");
    for (int i = 0; i < 5; i++) {
        printf("%d", result[i]);
        if (i < 4) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m×n)×k)

For each of (m-1)×(n-1) blocks, we search through k coordinates

✓ Linear Growth

Space Complexity

O(1)

Only using counter variables, no extra data structures

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

156 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 Every Block — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler