Lonely Pixel II - Practice Coding Problems

Lonely Pixel II - Problem

Imagine you're analyzing a digital image represented as a matrix of black ('B') and white ('W') pixels. Your task is to find lonely black pixels - special black pixels that meet very specific criteria!

A black lonely pixel is a 'B' located at position (r, c) where:

Both row r and column c contain exactly target black pixels
All rows that have a black pixel at column c must be identical to row r

Goal: Count how many black lonely pixels exist in the given m × n picture.

Example: If target = 3, a black pixel is lonely only if its row and column both have exactly 3 black pixels, and any other rows with black pixels in the same column are identical to this row.

Input & Output

example_1.py — Basic Case

$ Input: picture = [["W","B","W","B","B","W"],["W","B","W","B","B","W"],["W","B","W","B","B","W"],["W","W","B","W","B","B"]], target = 3

› Output: 6

💡 Note: The first three rows are identical and each has 3 black pixels. For columns 1, 3, 4: each has exactly 3 black pixels and all blacks in these columns come from identical rows. Each black pixel in these positions is lonely, giving us 3 rows × 3 columns = 6 lonely pixels.

example_2.py — No Lonely Pixels

$ Input: picture = [["W","W","B"],["W","W","B"],["W","W","B"]], target = 1

› Output: 0

💡 Note: Column 2 has 3 black pixels, but target is 1, so no black pixel can be lonely. Even though each row has exactly 1 black pixel, the column condition fails.

example_3.py — Different Row Patterns

$ Input: picture = [["B","W"],["W","B"]], target = 1

› Output: 0

💡 Note: Each row and column has exactly 1 black pixel, but the rows with black pixels in the same column are different (["B","W"] vs ["W","B"]), so no pixels are lonely.

Constraints

m == picture.length
n == picture[i].length
1 ≤ m, n ≤ 200
picture[i][j] is either 'W' or 'B'
1 ≤ target ≤ min(m, n)

Visualization

Tap to expand

Understanding the Visualization

Group Identical Patterns

Use hash map to group rows with identical camera arrangements

Filter Valid Groups

Keep only groups where each row has exactly target cameras

Column Analysis

For each column position with cameras, count total cameras in that column

Validate Consistency

Ensure all cameras in a column come from the same row pattern

Count Lonely Cameras

Sum up all valid cameras meeting all conditions

Key Takeaway

🎯 Key Insight: Using hash map to group identical row patterns eliminates redundant comparisons and enables O(mn) solution by validating row consistency efficiently.

Asked in

G Google 42 a Amazon 28 f Meta 35 ⊞ Microsoft 31

The optimal approach uses a hash map to group identical rows by their string signatures. This eliminates the need for repeated row comparisons and allows efficient validation of the condition that all rows with black pixels in the same column must be identical. The solution achieves O(mn) time complexity with smart preprocessing and grouping.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m²n²)	O(1)	Check each black pixel by counting its row/column and validating all conditions
Optimized Hash Map Solution	O(mn)	O(mn)	Use hash map to group identical rows and validate conditions efficiently
Two-Pass Optimization	O(mn)	O(m + n)	Pre-compute row/column statistics and row signatures for efficient validation

Brute Force (Nested Loops) — Algorithm Steps

Iterate through every cell in the matrix
For each black pixel, count black pixels in its row
Count black pixels in its column
Find all rows that have black pixels in this column
Compare each of these rows with the current row
If all conditions met, increment the lonely pixel count

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Black Pixel

Locate a black pixel at position (r,c)

Count Row

Scan entire row r to count black pixels

Count Column

Scan entire column c to count black pixels

Validate Rows

Compare all rows with black pixels in column c

Code -

solution.c — C

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

int findBlackPixel(char** picture, int pictureSize, int* pictureColSize, int target) {
    if (pictureSize == 0 || pictureColSize[0] == 0) {
        return 0;
    }
    
    int m = pictureSize, n = pictureColSize[0];
    int count = 0;
    
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (picture[r][c] == 'B') {
                // Count black pixels in row r
                int rowBlacks = 0;
                for (int j = 0; j < n; j++) {
                    if (picture[r][j] == 'B') rowBlacks++;
                }
                
                // Count black pixels in column c
                int colBlacks = 0;
                for (int i = 0; i < m; i++) {
                    if (picture[i][c] == 'B') colBlacks++;
                }
                
                // Check if row and column have exactly target blacks
                if (rowBlacks == target && colBlacks == target) {
                    // Find all rows with black pixel at column c
                    int valid = 1;
                    for (int i = 0; i < m; i++) {
                        if (picture[i][c] == 'B') {
                            // Compare row i with row r
                            if (strcmp(picture[i], picture[r]) != 0) {
                                valid = 0;
                                break;
                            }
                        }
                    }
                    
                    if (valid) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, we might scan entire rows and columns (O(m+n)) and compare multiple rows (O(mn))

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and comparison

✓ Linear Space

23.6K Views

Medium Frequency

~25 min Avg. Time

847 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler