2577। एक ग्रिड में एक सेल पर जाने के लिए न्यूनतम समय

] ] ] ] आपके द्वारा किए गए प्रत्येक कदम 1 सेकंड लेता है।

] यदि आप नीचे -दाहिने सेल पर नहीं जा सकते हैं, तो वापस -1-1 ।

उदाहरण 1:

]

आउटपुट:

7 ] t = 0 पर, हम सेल (0,0) पर हैं। t = 1 पर, हम सेल (0,1) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [0] [1]

t = 2 पर, हम सेल (1,1) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [1] [1] t = 3 पर, हम सेल (1,2) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [1] [2] t = 4 पर, हम सेल (1,1) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [1] [1]

t = 5 पर, हम सेल (1,2) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [1] [2]

t = 6 पर, हम सेल (1,3) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [1] [3]

t = 7 पर, हम सेल (2,3) में चले जाते हैं। यह संभव है क्योंकि ग्रिड [2] [3]

अंतिम समय 7 है। यह दिखाया जा सकता है कि यह न्यूनतम समय संभव है।

• उदाहरण २:
• ]
  आउटपुट:
  • -1
  • ]
  • प्रतिबंध:
  m == grid.length
  n == ग्रिड [i] .length
  2 ] ]
ग्रिड [०] [०] == ०

संकेत देना:

]

उस मामले पर विचार करें जहां आपको कुछ अन्य कोशिकाओं को अनलॉक करने के लिए मैट्रिक्स की दो कोशिकाओं के बीच आगे और पीछे जाना होगा।

समाधान:
• ] यह समस्या अनिवार्य रूप से हमें शीर्ष-बाएं सेल से नीचे-दाएं सेल की यात्रा करने के लिए आवश्यक सबसे कम समय खोजने के लिए कहती है, जहां प्रत्येक चाल में ग्रिड में मूल्यों के आधार पर एक समय की कमी होती है।
दृष्टिकोण:
• ] किनारों आसन्न कोशिकाएं हैं (ऊपर, नीचे, बाएं, दाएं) जिसे आप स्थानांतरित कर सकते हैं।
] यह सुनिश्चित करता है कि हम कोशिकाओं को जल्द से जल्द हम उन तक पहुंच सकते हैं।
• ] यदि एक सेल को वर्तमान की तुलना में बाद के समय में देखा जाता है, तो हम इसे नए समय के साथ कतार में वापस जोड़ते हैं।
] यदि हम उस तक पहुँचने के बिना कतार को समाप्त कर देते हैं, तो वापसी -1।

चलो इस समाधान को php में लागू करते हैं:

2577 एक ग्रिड में एक सेल पर जाने के लिए न्यूनतम समय

• php /** * @param पूर्णांक [] [] $ ग्रिड * @return पूर्णांक * फ़ंक्शन न्यूनतम समय ($ ग्रिड) { ... ... ... /** * पर जाएं ./solution.php * } // उदाहरण 1 $ ग्रिड 1 = [ [०, १, ३, २], [५, १, २, ५], [४, ३, ६, ६] ]; इको न्यूनतम समय ($ GRID1)। Php_eol; // आउटपुट: 7 // उदाहरण 2 $ ग्रिड 2 = [ [०, २, ४], [३, २, १], [१, ०, ४] ]; इको न्यूनतम समय ($ GRID2)। Php_eol; // आउटपुट: -1 ?>
• स्पष्टीकरण:
• प्राथमिकता कतार
• :

Splpriorityqueue का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि न्यूनतम समय वाली कोशिकाओं को पहले संसाधित किया जाता है। प्राथमिकता -समय के रूप में संग्रहीत की जाती है क्योंकि php का splpriorityqueue डिफ़ॉल्ट रूप से एक अधिकतम -ढेर है।

] शीर्ष -बाएं सेल (0, 0) से शुरू होकर, एल्गोरिथ्म सभी उपलब्ध कोशिकाओं को संसाधित करता है, प्रत्येक के शुरुआती समय पर विचार करते हुए प्रत्येक का दौरा किया जा सकता है (अधिकतम (0, ग्रिड [newrow] [newCol] - (समय 1))।

] एक विज़िटेड सरणी कोशिकाओं का ट्रैक रखता है जो पहले से ही निरर्थक संगणना और अनंत छोरों से बचने के लिए संसाधित किया गया है।

1. ] एल्गोरिथ्म यह सुनिश्चित करता है कि हम ग्रिड की सीमा के भीतर रहें और केवल मान्य पड़ोसियों की प्रक्रियाएं।
2. ] प्रत्येक चाल में एक सेकंड लगता है, और यदि सेल को प्रतीक्षा की आवश्यकता होती है (यानी, ग्रिड [newrow] [newCol]> समय 1), एल्गोरिथ्म आवश्यक समय तक इंतजार करता है।

] यदि कतार समाप्त हो गई है और नीचे -दाएं सेल तक नहीं पहुंचा है, तो फ़ंक्शन -1 रिटर्न -1।

जटिलता विश्लेषण

समय जटिलता

:

]

1. अंतरिक्ष जटिलता
:

2. ]

3. उदाहरण चलता है

   इनपुट:

   $ ग्रिड = [ [०, १, ३, २], [५, १, २, ५], [४, ३, ६, ६] ]; इको न्यूनतम समय ($ ग्रिड); // आउटपुट: 7
4. इनपुट:

   $ ग्रिड = [ [०, २, ४], [३, २, १], [१, ०, ४] ]; इको न्यूनतम समय ($ ग्रिड); // आउटपुट: -1

   यह समाधान कुशल है और बाधाओं के भीतर अच्छी तरह से काम करता है।

संपर्क लिंक ] आपका समर्थन मेरे लिए बहुत मायने रखता है!
]

लिंक्डइन

1. github