C++ में ब्लैक पिक्सल्स को बंद करने वाला सबसे छोटा आयत

मान लीजिए कि हमारे पास एक छवि है और उस छवि को एक बाइनरी मैट्रिक्स द्वारा एक सफेद पिक्सेल के रूप में 0 और एक काले पिक्सेल के रूप में दर्शाया गया है। यहां ब्लैक पिक्सल जुड़े हुए हैं, इसलिए केवल एक ब्लैक रीजन है। पिक्सेल क्षैतिज और लंबवत रूप से जुड़े हुए हैं। यदि हमारे पास किसी एक काले पिक्सेल का स्थान (x, y) है, तो हमें सभी काले पिक्सेल को घेरने वाले सबसे छोटे (अक्ष-संरेखित) आयत का क्षेत्रफल ज्ञात करना होगा।

तो, अगर इनपुट पसंद है

0	0	1	0
0	1	1	0
0	1	0	0

और x =0, y =2, तो आउटपुट 6 होगा

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

एक 2डी सरणी को परिभाषित करें v
फ़ंक्शन searchRows() को परिभाषित करें, इसमें i, j, लेफ्ट, राइट, एक,
. लगेगा
जबकि मैं <जे, करता हूं -
- मध्य :=i + (j - i) / 2
- कश्मीर:=बाएं
- जबकि (k <दाएँ और v[mid, k] '0' के समान है), करें -
  - (के द्वारा 1 बढ़ाएँ)
- यदि k <' दायाँ एक के समान है, तो -
  - जे:=मध्य
- अन्यथा
  - मैं :=मध्य + 1
वापसी मैं
एक फ़ंक्शन को परिभाषित करें searchColumn(), इसमें i, j, ऊपर, नीचे, एक,
. लगेगा
जबकि i, j के बराबर नहीं है, −
. करें
- मध्य :=i + (j - i) / 2
- कश्मीर:=शीर्ष
- जबकि (k <नीचे और v[k, mid] '0' के समान है), करें -
  - (के द्वारा 1 बढ़ाएँ)
- यदि k <बॉटम एक के समान है, तो -
  - जे:=मध्य
- अन्यथा
  - मैं :=मध्य + 1
वापसी मैं
मुख्य विधि से निम्न कार्य करें -
वी:=छवि
रिट:=0
n :=छवि का पंक्ति आकार
मी :=छवि का कोल आकार
शीर्ष :=searchRows(0, x, 0, m, true)
नीचे :=searchRows(x + 1, n, 0, m, false)
बाएँ:=searchColumn(0, y, ऊपर, नीचे, सत्य)
दाएँ:=searchColumn(y + 1, m, ऊपर, नीचे, झूठा)
वापसी (दाएं-बाएं) * (नीचे - ऊपर)

उदाहरण

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

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   vector < vector <char> > v;
   int searchRows(int i, int j, int left, int right, bool one){
      while (i < j) {
         int mid = i + (j - i) / 2;
         int k = left;
         while (k < right && v[mid][k] == '0')
            k++;
         if (k < right == one) {
            j = mid;
         }
         else {
            i = mid + 1;
         }
      }
      return i;
   }
   int searchColumn(int i, int j, int top, int bottom, bool one){
      while (i != j) {
         int mid = i + (j - i) / 2;
         int k = top;
         while (k < bottom && v[k][mid] == '0')
            k++;
         if (k < bottom == one) {
            j = mid;
         }
         else {
            i = mid + 1;
         }
      }
      return i;
   }
   int minArea(vector<vector<char>>& image, int x, int y) {
      v = image;
      int ret = 0;
      int n = image.size();
      int m = image[0].size();
      int top = searchRows(0, x, 0, m, true);
      int bottom = searchRows(x + 1, n, 0, m, false);
      int left = searchColumn(0, y, top, bottom, true);
      int right = searchColumn(y + 1, m, top, bottom, false);
      return (right - left) * (bottom - top);
   }
};
main(){
   Solution ob;
   vector<vector<char>> v =
   {{'0','0','1','0'},{'0','1','1','0'},{'0','1','0','0'}};
   cout << (ob.minArea(v, 0, 2));
}

इनपुट

{{'0','0','1','0'},{'0','1','1','0'},{'0','1','0','0'}}, 0, 2