Array
Hash Table
Matrix
Description
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 located at a specific position where the same row and same column don't have any other black pixels.
Example 1:
Input: picture = [["W","W","B"],["W","B","W"],["B","W","W"]]
Output: 3
Explanation: All the three 'B's are black lonely pixels.
Example 2:
Input: picture = [["B","B","B"],["B","B","W"],["B","B","B"]]
Output: 0
Constraints:
m == picture.length
n == picture[i].length
1 <= m, n <= 500
picture[i][j]
is 'W'
or 'B'
.
Solutions
Solution 1: Counting + Enumeration
According to the problem description, we need to count the number of black pixels in each row and column, which are recorded in the arrays rows
and cols
respectively. Then we traverse each black pixel, check whether there is only one black pixel in its row and column. If so, we increment the answer by one.
The time complexity is $O(m \times n)$, and the space complexity is $O(m + n)$, where $m$ and $n$ are the number of rows and columns in the matrix respectively.
Python3 Java C++ Go TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 class Solution :
def findLonelyPixel ( self , picture : List [ List [ str ]]) -> int :
rows = [ 0 ] * len ( picture )
cols = [ 0 ] * len ( picture [ 0 ])
for i , row in enumerate ( picture ):
for j , x in enumerate ( row ):
if x == "B" :
rows [ i ] += 1
cols [ j ] += 1
ans = 0
for i , row in enumerate ( picture ):
for j , x in enumerate ( row ):
if x == "B" and rows [ i ] == 1 and cols [ j ] == 1 :
ans += 1
return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 class Solution {
public int findLonelyPixel ( char [][] picture ) {
int m = picture . length , n = picture [ 0 ] . length ;
int [] rows = new int [ m ] ;
int [] cols = new int [ n ] ;
for ( int i = 0 ; i < m ; ++ i ) {
for ( int j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] == 'B' ) {
++ rows [ i ] ;
++ cols [ j ] ;
}
}
}
int ans = 0 ;
for ( int i = 0 ; i < m ; ++ i ) {
for ( int j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] == 'B' && rows [ i ] == 1 && cols [ j ] == 1 ) {
++ ans ;
}
}
}
return ans ;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 class Solution {
public :
int findLonelyPixel ( vector < vector < char >>& picture ) {
int m = picture . size (), n = picture [ 0 ]. size ();
vector < int > rows ( m );
vector < int > cols ( n );
for ( int i = 0 ; i < m ; ++ i ) {
for ( int j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] == 'B' ) {
++ rows [ i ];
++ cols [ j ];
}
}
}
int ans = 0 ;
for ( int i = 0 ; i < m ; ++ i ) {
for ( int j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] == 'B' && rows [ i ] == 1 && cols [ j ] == 1 ) {
++ ans ;
}
}
}
return ans ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 func findLonelyPixel ( picture [][] byte ) ( ans int ) {
rows := make ([] int , len ( picture ))
cols := make ([] int , len ( picture [ 0 ]))
for i , row := range picture {
for j , x := range row {
if x == 'B' {
rows [ i ] ++
cols [ j ] ++
}
}
}
for i , row := range picture {
for j , x := range row {
if x == 'B' && rows [ i ] == 1 && cols [ j ] == 1 {
ans ++
}
}
}
return
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 function findLonelyPixel ( picture : string [][]) : number {
const m = picture . length ;
const n = picture [ 0 ]. length ;
const rows : number [] = Array ( m ). fill ( 0 );
const cols : number [] = Array ( n ). fill ( 0 );
for ( let i = 0 ; i < m ; ++ i ) {
for ( let j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] === 'B' ) {
++ rows [ i ];
++ cols [ j ];
}
}
}
let ans = 0 ;
for ( let i = 0 ; i < m ; ++ i ) {
for ( let j = 0 ; j < n ; ++ j ) {
if ( picture [ i ][ j ] === 'B' && rows [ i ] === 1 && cols [ j ] === 1 ) {
++ ans ;
}
}
}
return ans ;
}
GitHub