C++ में Lonely Pixel I

मान लीजिए हमारे पास काले और सफेद पिक्सेल से बनी एक तस्वीर है, हमें काले अकेले पिक्सेल की संख्या ढूंढनी है। यहाँ तस्वीर को 'B' और 'W' से बने 2D कैरेक्टर सरणी द्वारा दर्शाया गया है, काले और सफेद पिक्सेल के लिए क्रमशः।

एक काला अकेला पिक्सेल वास्तव में 'B' है जो एक विशिष्ट स्थिति पर स्थित है जहां उसी पंक्ति और उसी स्तंभ में कोई अन्य काला पिक्सेल नहीं है।

यदि इनपुट इस तरह है:

W	W	B
W	B	W
B	W	W

आउटपुट 3 होगा। क्योंकि सभी तीन 'B' काले अकेले पिक्सेल हैं।

समाधान दृष्टिकोण

इसे हल करने के लिए, हम निम्न चरणों का पालन करेंगे:

n := picture का आकार
m := (यदि n शून्येतर है, तो स्तंभ का आकार, अन्यथा 0)
आकार n के दो सरणी row और col परिभाषित करें
ret := 0, firstRow := 0
i := 0 से आरंभ करें, जब i < n, अपडेट करें (i को 1 से बढ़ाएँ), करें:
- j := 0 से आरंभ करें, जब j < m, अपडेट करें (j को 1 से बढ़ाएँ), करें:
  - यदि picture[i][j] 'B' के समान है, तो:
    - यदि picture[0][j] < 'Y' और picture[0][j] != 'V', तो:
      - picture[0][j] को 1 से बढ़ाएँ
    - यदि i 0 के समान है, तो:
      - firstRow को 1 से बढ़ाएँ
    - अन्यथा जब picture[i][0] < 'Y' और picture[i][0] != 'V', तो:
      - picture[i][0] को 1 से बढ़ाएँ
i := 0 से आरंभ करें, जब i < n, अपडेट करें (i को 1 से बढ़ाएँ), करें:
- j := 0 से आरंभ करें, जब j < m, अपडेट करें (j को 1 से बढ़ाएँ), करें:
  - यदि picture[i][j] < 'W' और (picture[0][j] 'C' के समान है या picture[0][j] 'X' के समान है), तो:
    - यदि i 0 के समान है, तो:
      - ret := (यदि ret + firstRow 1 के समान है, तो 1, अन्यथा 0)
    - अन्यथा जब picture[i][0] 'C' के समान है या picture[i][0] 'X' के समान है, तो:
      - ret को 1 से बढ़ाएँ
ret लौटाएँ

उदाहरण

बेहतर समझ के लिए निम्न कार्यान्वयन देखें:

#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    int findLonelyPixel(vector<vector<char>>& picture) {
        int n = picture.size();
        int m = n ? picture[0].size() : 0;
        vector<int> row(n);
        vector<int> col(m);
        int ret = 0;
        int firstRow = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (picture[i][j] == 'B') {
                    if (picture[0][j] < 'Y' && picture[0][j] != 'V') {
                        picture[0][j]++;
                    }
                    if (i == 0)
                        firstRow++;
                    else if (picture[i][0] < 'Y' && picture[i][0] != 'V') {
                        picture[i][0]++;
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (picture[i][j] < 'W' && (picture[0][j] == 'C' || picture[0][j] == 'X')) {
                    if (i == 0)
                        ret += firstRow == 1 ? 1 : 0;
                    else if (picture[i][0] == 'C' || picture[i][0] == 'X')
                        ret++;
                }
            }
        }
        return ret;
    }
};

int main() {
    Solution ob;
    vector<vector<char>> v = {{'W','W','B'},{'W','B','W'},{'B','W','W'}};
    cout << (ob.findLonelyPixel(v));
    return 0;
}

इनपुट

{{'W','W','B'},{'W','B','W'},{'B','W','W'}}