# [LeetCode] 533. Lonely Pixel II 孤独的像素 II

2021年09月15日 阅读数：1

Given a picture consisting of black and white pixels, and a positive integer N, find the number of black pixels located at some specific row R and column C that align with all the following rules:html

1. Row R and column C both contain exactly N black pixels.
2. For all rows that have a black pixel at column C, they should be exactly the same as row R

The picture is represented by a 2D char array consisting of 'B' and 'W', which means black and white pixels respectively.java

Example:python

```Input:
[['W', 'B', 'W', 'B', 'B', 'W'],
['W', 'B', 'W', 'B', 'B', 'W'],
['W', 'B', 'W', 'B', 'B', 'W'],
['W', 'W', 'B', 'W', 'B', 'W']]

N = 3
Output: 6
Explanation: All the bold 'B' are the black pixels we need (all 'B's at column 1 and 3).
0    1    2    3    4    5         column index
0    [['W', 'B', 'W', 'B', 'B', 'W'],
1     ['W', 'B', 'W', 'B', 'B', 'W'],
2     ['W', 'B', 'W', 'B', 'B', 'W'],
3     ['W', 'W', 'B', 'W', 'B', 'W']]
row index

Take 'B' at row R = 0 and column C = 1 as an example:
Rule 1, row R = 0 and column C = 1 both have exactly N = 3 black pixels.
Rule 2, the rows have black pixel at column C = 1 are row 0, row 1 and row 2. They are exactly the same as row R = 0.
```

Note:app

1. The range of width and height of the input 2D array is [1,200].

531. Lonely Pixel I 的拓展，这题多了一个整数N，行和列能够最多含有N个黑元素。post

0[['W', 'B', 'W', 'B', 'B', 'W'],
1 ['W', 'W', 'B', 'B', 'B', 'W'],
2 ['W', 'B', 'W', 'B', 'B', 'W'],
3 ['W', 'B', 'W', 'W', 'B', 'W']] url

Java:htm

```public int findBlackPixel(char[][] picture, int N) {
int m = picture.length;
if (m == 0) return 0;
int n = picture[0].length;
if (n == 0) return 0;

Map<String, Integer> map = new HashMap<>();
int[] colCount = new int[n];

for (int i = 0; i < m; i++) {
String key = scanRow(picture, i, N, colCount);
if (key.length() != 0) {
map.put(key, map.getOrDefault(key, 0) + 1);
}
}

int result = 0;
for (String key : map.keySet()) {
if (map.get(key) == N) {
for (int j = 0; j < n; j++) {
if (key.charAt(j) == 'B' && colCount[j] == N) {
result += N;
}
}
}
}

return result;
}

private String scanRow(char[][] picture, int row, int target, int[] colCount) {
int n = picture[0].length;
int rowCount = 0;
StringBuilder sb = new StringBuilder();

for (int j = 0; j < n; j++) {
if (picture[row][j] == 'B') {
rowCount++;
colCount[j]++;
}
sb.append(picture[row][j]);
}

if (rowCount == target) return sb.toString();
return "";
}　　```

Java: using hashmap to store the string of rows. So that we don't need to check rule 2blog

```public int findBlackPixel(char[][] picture, int N) {
if (picture == null || picture.length == 0 || picture[0].length == 0) return 0;
int m = picture.length, n = picture[0].length;
int[] cols = new int[n];
Map<String, Integer> map = new HashMap<>();

for (int i = 0; i < m; i++) {
int count = 0;
StringBuilder sb = new StringBuilder();
for (int j = 0; j < n; j++) {
if (picture[i][j] == 'B') {
cols[j]++;
count++;
}
sb.append(picture[i][j]);
}
if (count == N) {
String curRow = sb.toString();
map.put(curRow, map.getOrDefault(curRow, 0) + 1);
}
}

int res = 0;
for (String row : map.keySet()) {
if (map.get(row) != N) continue;
for (int i = 0; i < n; i++) {
if (row.charAt(i) == 'B' && cols[i] == N) {
res += N;
}
}
}
return res;
}　```

Python:ip

```class Solution(object):
def findBlackPixel(self, picture, N):
"""
:type picture: List[List[str]]
:type N: int
:rtype: int
"""
rows, cols = [0] * len(picture),  [0] * len(picture[0])
lookup = collections.defaultdict(int)
for i in xrange(len(picture)):
for j in xrange(len(picture[0])):
if picture[i][j] == 'B':
rows[i] += 1
cols[j] += 1
lookup[tuple(picture[i])] += 1

result = 0
for i in xrange(len(picture)):
if rows[i] == N and lookup[tuple(picture[i])] == N:
for j in xrange(len(picture[0])):
result += picture[i][j] == 'B' and cols[j] == N
return result
```

Python:

```class Solution(object):
def findBlackPixel(self, picture, N):
"""
:type picture: List[List[str]]
:type N: int
:rtype: int
"""
lookup = collections.Counter(map(tuple, picture))
cols = [col.count('B') for col in zip(*picture)]
return sum(N * zip(row, cols).count(('B', N)) \
for row, cnt in lookup.iteritems() \
if cnt == N == row.count('B'))
```

Python:

```class Solution(object):
def findBlackPixel(self, picture, N):
"""
:type picture: List[List[str]]
:type N: int
:rtype: int
"""
w, h = len(picture), len(picture[0])
rows, cols = [0] * w, [0] * h
for x in range(w):
for y in range(h):
if picture[x][y] == 'B':
rows[x] += 1
cols[y] += 1

sdict = collections.defaultdict(int)
for idx, row in enumerate(picture):
sdict[''.join(row)] += 1

ans = 0
for x in range(w):
row = ''.join(picture[x])
if sdict[row] != N:
continue
for y in range(h):
if picture[x][y] == 'B':
if rows[x] == N:
if cols[y] == N:
ans += 1
return ans　　```

C++:

```class Solution {
public:
int findBlackPixel(vector<vector<char>>& picture, int N) {
vector<int> rows = vector<int>(picture.size());
vector<int> cols = vector<int>(picture[0].size());

unordered_map<string, int> lookup;
vector<string> srows;
for (int i = 0; i < picture.size(); ++i) {
string s;
for (int j = 0; j < picture[0].size(); ++j) {
if (picture[i][j] == 'B') {
++rows[i];
++cols[j];
}
s.push_back(picture[i][j]);
}
++lookup[s];
srows.emplace_back(move(s));
}

int result = 0;
for (int i = 0; i < picture.size(); ++i) {
if (rows[i] == N && lookup[srows[i]] == N) {
for (int j = 0; j < picture[0].size(); ++j) {
result += picture[i][j] == 'B' && cols[j] == N;
}
}
}
return result;
}
};
```

[LeetCode] 531. Lonely Pixel I 孤独的像素 I