सी ++ में भूलभुलैया

मान लीजिए कि एक भूलभुलैया में खाली जगह और दीवारों के साथ एक गेंद है। अब गेंद ऊपर, नीचे, बाएँ या दाएँ किसी भी दिशा में लुढ़क कर खाली रास्तों से जा सकती है, लेकिन दीवार से टकराने तक यह लुढ़कना बंद नहीं करेगी। जब गेंद रुकती है, तो वह अगली दिशा चुन सकती है।

हमें गेंद की स्थिति, गंतव्य और भूलभुलैया शुरू करनी होगी, हमें यह जांचना होगा कि गेंद गंतव्य पर रुक सकती है या नहीं। भूलभुलैया को एक 2डी सरणी द्वारा दर्शाया जाता है। यहां 1 दीवार को इंगित करता है और 0 खाली स्थान को इंगित करता है। भूलभुलैया की सीमाएँ सभी दीवारें हैं। प्रारंभ और गंतव्य निर्देशांक पंक्ति और स्तंभ सूचकांकों द्वारा दर्शाए जाते हैं।

इसलिए, यदि इनपुट एक 2D सरणी द्वारा दर्शाए गए भूलभुलैया की तरह है

प्रारंभ स्थिति है (0, 4) गंतव्य स्थिति है (4, 4), तो आउटपुट सत्य होगा, एक संभावित तरीका है − बाएं नीचे . तक से दाएं ।

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

उदाहरण

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

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   bool hasPath(vector<vector<int<>& grid, vector<int<& start, vector<int<& destination) {
      int n = grid.size();
      int m = grid[0].size();
      queue<vector<int< > q;
      q.push(start);
      set<vector<int< > visited;
      visited.insert(start);
      while (!q.empty()) {
         vector<int< curr = q.front();
         q.pop();
         int x = curr[0];
         int y = curr[1];
         if (destination[0] == x && destination[1] == y)
            return true;
         int i = x;
         while (i + 1 < n && !grid[i + 1][y])
            i++;
         if (!visited.count({ i, y })) {
            visited.insert({ i, y });
            q.push({ i, y });
         }
         i = x;
         while (i - 1 >= 0 && !grid[i - 1][y])
            i--;
         if (!visited.count({ i, y })) {
            visited.insert({ i, y });
            q.push({ i, y });
         }
         i = y;
         while (i + 1 < m && !grid[x][i + 1])
            i++;
         if (!visited.count({ x, i })) {
            visited.insert({ x, i });
            q.push({ x, i });
         }
         i = y;
         while (i - 1 >= 0 && !grid[x][i - 1])
            i--;
         if (!visited.count({ x, i })) {
            visited.insert({ x, i });
            q.push({ x, i });
         }
      }
      return false;
   }
};
main(){
   Solution ob;
   vector<vector<int<> v = {{0,0,1,0,0},{0,0,0,0,0},{0,0,0,1,0},{1,1,0,1,1},{0,0,0,0,0}};
   vector<int< v1 = {0,4}, v2 = {4,4};
   cout << (ob.hasPath(v, v1, v2));
}

इनपुट

{{0,0,1,0,0},{0,0,0,0,0},{0,0,0,1,0},{1,1,0,1,1},{0,0,0,0,0}},{0,4},{4,4}

आउटपुट

1