Lonely Pixel I

Lonely Pixel I - Problem

Given an m x n picture consisting of black 'B' and white 'W' pixels, return the number of black lonely pixels.

A black lonely pixel is a character 'B' that is located at a specific position where the same row and same column don't have any other black pixels.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Only the black pixel at (1,1) is lonely. Row 1 has 1 black pixel, column 1 has 1 black pixel. The other black pixels have companions in their rows or columns.

Example 2 — No Lonely Pixels

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

› Output: 0

💡 Note: No lonely pixels exist. The black pixel at (0,0) shares row 0 with (0,1), pixel at (0,1) shares both row 0 and column 1, and pixel at (1,0) shares column 0.

Example 3 — Single Black Pixel

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

› Output: 1

💡 Note: The single black pixel at (1,1) is lonely since it's the only black pixel in both row 1 and column 1.

Constraints

m == picture.length
n == picture[i].length
1 ≤ m, n ≤ 500
picture[i][j] is either 'W' or 'B'

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that a lonely pixel must be the ONLY black pixel in both its row AND column. Best approach uses two-pass counting: first pass counts blacks per row/column, second pass checks each black pixel. Time: O(mn), Space: O(m+n)

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Check Each Position

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

Iterate through each cell, and when we find a 'B', scan its entire row and column to count black pixels. If both counts are exactly 1, it's lonely.

Two Pass with Counting

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

Use two passes: first to count black pixels in each row and column, then second to check each black pixel against these precomputed counts.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

int maxLength;

int max(int a, int b) {
    return a > b ? a : b;
}

void dfs(struct TreeNode* node, int* leftPath, int* rightPath) {
    if (!node) {
        *leftPath = 0;
        *rightPath = 0;
        return;
    }
    
    int leftLeft, leftRight;
    int rightLeft, rightRight;
    
    dfs(node->left, &leftLeft, &leftRight);
    dfs(node->right, &rightLeft, &rightRight);
    
    int currLeft = node->left ? leftRight + 1 : 0;
    int currRight = node->right ? rightLeft + 1 : 0;
    
    maxLength = max(maxLength, max(currLeft, currRight));
    
    *leftPath = currLeft;
    *rightPath = currRight;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    maxLength = 0;
    int leftPath, rightPath;
    dfs(root, &leftPath, &rightPath);
    return maxLength;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    struct TreeNode* root = createNode(1);
    printf("%d\n", solution(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

245 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