C++ . में दीवारें और गेट

मान लीजिए कि हमारे पास एक m x n 2D ग्रिड है, और यह इन तीन संभावित मानों के साथ आरंभ किया गया है।

• -1 दीवार या बाधा के लिए।

• 0 गेट के लिए।

• INF यह अनंत का अर्थ है एक खाली कमरा।

यहाँ 2^31 - 1 =2147483647 INF है क्योंकि हम मान सकते हैं कि एक गेट की दूरी 2147483647 से कम है। प्रत्येक खाली कमरे को उसके निकटतम गेट की दूरी से भरें। अगर किसी गेट तक पहुंचना नामुमकिन है, तो उसे आईएनएफ से भरा जाना चाहिए।

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

तो आउटपुट होगा

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

• आकार की एक सरणी dir परिभाषित करें:4 x 2 :={{1, 0}, {-1, 0}, {0, 1}, {0,-1}}

• n :=कमरों का आकार

• m :=(यदि n गैर-शून्य है, तो स्तंभ गणना, अन्यथा 0)

• जोड़े की एक कतार q परिभाषित करें

• इनिशियलाइज़ i :=0 के लिए, जब i

  • इनिशियलाइज़ j :=0 के लिए, जब j

    • अगर कमरे [i, j] 0 के समान है, तो -

      • q में { i, j } डालें

• lvl को इनिशियलाइज़ करने के लिए:=1, जब q खाली न हो, तो अपडेट करें (lvl को 1 से बढ़ाएँ), करें -

  • sz :=q का आकार

  • जबकि sz गैर-शून्य है, प्रत्येक पुनरावृत्ति में sz को 1 से घटाएं, करें -

    • एक जोड़ी वक्र परिभाषित करें :=q का पहला तत्व

    • q से तत्व हटाएं

    • x :=curr.first

    • y :=curr.second

    • इनिशियलाइज़ करने के लिए मैं :=0, जब i <4, अपडेट (i 1 से बढ़ाएँ), करें -

      • एनएक्स:=एक्स + डीआईआर [i, 0]

      • ny :=y + dir[i, 1]

      • यदि nx <0 या ny <0 या nx>=n या ny>=m या कमरे[nx, ny]

        • निम्नलिखित भाग पर ध्यान न दें, अगले पुनरावृत्ति पर जाएं

      • कमरे [एनएक्स, एनवाई]:=एलवीएल

      • q में { nx, ny } डालें

उदाहरण

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

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<vector<auto< > v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << "[";
      for(int j = 0; j <v[i].size(); j++){
         cout << v[i][j] << ", ";
      }
      cout << "],";
   }
   cout << "]"<<endl;
}
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
class Solution {
public:
   void wallsAndGates(vector<vector<int<>& rooms) {
      int n = rooms.size();
      int m = n ? rooms[0].size() : 0;
      queue<pair<int, int> > q;
      for (int i = 0; i < n; i++) {
         for (int j = 0; j < m; j++) {
            if (rooms[i][j] == 0)
               q.push({ i, j });
         }
      }
      for (int lvl = 1; !q.empty(); lvl++) {
         int sz = q.size();
         while (sz--) {
            pair<int, int> curr = q.front();
            q.pop();
            int x = curr.first;
            int y = curr.second;
            for (int i = 0; i < 4; i++) {
               int nx = x + dir[i][0];
               int ny = y + dir[i][1];
               if (nx < 0 || ny < 0 || nx >= n || ny >= m || rooms[nx][ny] < lvl)
                  continue;
               rooms[nx][ny] = lvl;
               q.push({ nx, ny });
            }
         }
      }
   }
};
main(){
   vector<vector<int<> v = {{2147483647,-1,0,2147483647}, {2147483647,2147483647,2147483647,-1}, {2147483647,-1,2147483647,-1}, {0,-1,2147483647,2147483647}};
   Solution ob;
   ob.wallsAndGates(v);
   print_vector(v);
}

इनपुट

{{2147483647,-1,0,2147483647},{2147483647,2147483647,2147483647,-1}, {2147483647,-1,2147483647,-1},{0,-1,2147483647,2147483647}}

आउटपुट

[[3, -1, 0, 1, ],[2, 2, 1, -1, ],[1, -1, 2, -1, ],[0, -1, 3, 4, ],]