पायथन में दिए गए मैट्रिक्स से हम अधिकतम मात्रा में सिक्के एकत्र कर सकते हैं

मान लीजिए कि हमारे पास एक 2D मैट्रिक्स है जहां मैट्रिक्स [r, c] उस सेल में सिक्कों की संख्या का प्रतिनिधित्व करता है। हम किसी भी स्थिति से शुरू कर सकते हैं और चार दिशाओं (ऊपर, नीचे, बाएँ और दाएँ, तिरछे नहीं) में से किसी को भी घुमाकर सिक्के एकत्र करना चाहते हैं। जब हम किसी सेल में जाते हैं तो सिक्के एकत्र हो जाते हैं और उस सेल का मान 0 हो जाता है। हम 0 सिक्कों वाले सेल में नहीं जा सकते हैं, हमें सिक्कों की अधिकतम मात्रा का पता लगाना होगा।

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

तब आउटपुट 18 होगा, क्योंकि हम पथ 2 −> 3 −> 6 −> 4 −> 3

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

• अगर मैट्रिक्स खाली है, तो

  • वापसी 0

• n :=मैट्रिक्स की पंक्ति गणना, m :=चटाई की स्तंभ संख्या

• x :=एक सूची जैसे [−1, 1, 0, 0], y :=एक सूची जैसे [0, 0, −1, 1]

• उपयोग() फ़ंक्शन को परिभाषित करें। इसमें a, b

  . लगेगा

• रिट:=0

• के लिए 0 से 3 की सीमा में, करें

  • (t1, t2) :=(x[k] + a, y[k] + b)

  • अगर (t1, t2) वैध सेल है, तो

    • टी:=चटाई [टी 1, टी 2], चटाई [टी 1, टी 2]:=0

    • ret :=अधिकतम रिट और (उपयोग(t1, t2) + t)

    • मैट [t1, t2] :=t

• वापसी रिट

• मुख्य विधि से निम्न कार्य करें -

• रेस :=0

• 0 से n − 1 की सीमा में i के लिए, करें

  • j के लिए 0 से m − 1 की सीमा में, करें

    • अगर mat[i, j] गैर-शून्य है, तो

      • टी:=चटाई[i, j], चटाई[i, j]:=0

      • रेस :=अधिकतम रेस और (उपयोग(i, j) + अस्थायी)

• रिटर्न रेस

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

उदाहरण

class Solution:
   def solve(self, mat):
      if not mat:
         return 0
      n, m = len(mat), len(mat[0])
      x, y = [−1, 1, 0, 0], [0, 0, −1, 1]
      def ok(a, b):
         return 0 <= a < n and 0 <= b < m and mat[a][b]
      def util(a, b):
         ret = 0
         for k in range(4):
            t1, t2 = x[k] + a, y[k] + b
            if ok(t1, t2):
               t, mat[t1][t2] = mat[t1][t2], 0
               ret = max(ret, util(t1, t2) + t)
               mat[t1][t2] = t
            return ret
         res = 0
         for i in range(n):
            for j in range(m):
               if mat[i][j]:
                  temp, mat[i][j] = mat[i][j], 0
                  res = max(res, util(i, j) + temp)
         return res
ob = Solution()
matrix = [
   [2, 4, 3],
   [3, 6, 0],
   [2, 0, 12]
]
print(ob.solve(matrix))

इनपुट

[
[2, 4, 3],
[3, 6, 0],
[2, 0, 12] ]

आउटपुट

18