संतरे को C++ में सड़ना

मान लीजिए हमारे पास एक ग्रिड है, यहां प्रत्येक सेल में तीन में से एक मान हो सकता है -

एक खाली सेल के लिए मान 0;
एक ताजे संतरे के लिए मान 1;
सड़े हुए संतरे के लिए मान 2.

हर मिनट में कोई भी ताजा संतरा जो सड़े हुए संतरे के पास होता है वह सड़ जाता है।

हमें उस न्यूनतम संख्या का पता लगाना होगा जो तब तक समाप्त हो जाए जब तक कि किसी भी सेल में ताजा नारंगी न हो। यदि यह संभव नहीं है, तो -1 लौटें।

इसलिए, यदि इनपुट [[2,1,1], [1,1,0], [0,1,1]] जैसा है, तो आउटपुट 4

होगा।

संतरे को C++ में सड़ना

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

मिनट :=0
RowMax :=ग्रिड की पंक्ति का आकार
colMax :=ग्रिड का कॉलम आकार
फ्रेश लेफ्ट :=असत्य
न्यूग्रिड :=ग्रिड
जबकि सत्य गैर-शून्य है, करें -
- न्यूग्रिड :=ग्रिड
- झंडा :=झूठा
- फ्रेश लेफ्ट :=असत्य
- इनिशियलाइज़ i :=0 के लिए, जब i
  - इनिशियलाइज़ j :=0 के लिए, जब j
    - अगर newGrid[i, j] 1 के समान है, तो -
      - अगर (i-1>=0 और newGrid[i-1,j] 2 है) या (i+1 =0 और newGrid[ i,j-1] 2 है) या (j+1>=0 और newGrid[i,j+1] 2 है), तो
        
        ग्रिड[i, j] :=2
        
        झंडा :=सच
      - फ्रेश लेफ्ट :=सच
- अगर झंडा गैर-शून्य है, तो -
  - (मिनटों को 1 से बढ़ाएँ)
- अन्यथा
  - लूप से बाहर आएं
वापसी (यदि फ्रेशलेफ्ट सत्य के बराबर नहीं है, तो मिनट, अन्यथा -1)

उदाहरण (C++)

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

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   int orangesRotting(vector<vector<int>> &grid) {
      int minutes = 0;
      int rowMax = grid.size();
      int colMax = grid[0].size();
      bool freshLeft = false;
      auto newGrid = grid;
      while (true) {
         newGrid = grid;
         bool flag = false;
         freshLeft = false;
         for (int i = 0; i < rowMax; i++) {
            for (int j = 0; j < colMax; j++) {
               if (newGrid[i][j] == 1) {
                  if ((i - 1 >= 0 && newGrid[i - 1][j] == 2) or (i + 1 < rowMax && newGrid[i + 1][j] == 2) or (j - 1 >= 0 && newGrid[i][j - 1] == 2) or (j + 1 < colMax && newGrid[i][j + 1] == 2)) {
                     grid[i][j] = 2;
                     flag = true;
                  }
                  freshLeft = true;
               }
            }
         }
         if (flag)
            minutes++;
         else
            break;
      }
      return (freshLeft != true) ? minutes : -1;
   }
};
main() {
   Solution ob;
   vector<vector<int>> v = {{2, 1, 1}, {1, 1, 0}, {0, 1, 1}};
   cout << (ob.orangesRotting(v));
}

इनपुट

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