पायथन में एक मैट्रिक्स में सबसे लंबा बढ़ता हुआ पथ

मान लीजिए हमारे पास एक मैट्रिक्स है; हमें सबसे लंबे बढ़ते हुए पथ की लंबाई ज्ञात करनी है। प्रत्येक कोशिका से, हम या तो चार दिशाओं में जा सकते हैं - बाएँ, दाएँ, ऊपर या नीचे। हम तिरछे नहीं जा सकते या सीमा से बाहर नहीं जा सकते।

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

तो आउटपुट 4 होगा क्योंकि सबसे लंबा बढ़ता हुआ पथ [3, 4, 5, 6] है।

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

• फ़ंक्शन को हल करें () को परिभाषित करें। यह ले जाएगा i,j,मैट्रिक्स

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

  • वापसी डीपी [i, जे]

• डीपी [आई, जे]:=1

• अस्थायी:=0

• i-1 से i+2 की श्रेणी में r के लिए, करें

  • j-1 से j+2 की श्रेणी में c के लिए, करें

    • यदि r, i के समान है और c, j के समान है या(|r-i| 1 के समान है और |c-j| 1 के समान है, तो

      • अगले पुनरावृत्ति के लिए जाएं

    • अगर c>=0 और r>=0 और r<मैट्रिक्स की पंक्ति गणना और c matrix[i, j], तब

      • अस्थायी:=अधिकतम अस्थायी, हल करें (आर, सी, मैट्रिक्स)

• डीपी [आई, जे]:=डीपी [i, जे] + अस्थायी

• वापसी डीपी [i, जे]

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

• यदि मैट्रिक्स गैर-शून्य नहीं है, तो

  • वापसी 0

• dp:=दिए गए मैट्रिक्स के समान आकार का एक मैट्रिक्स और 0 से भरें

• उत्तर:=0

• मैं के लिए 0 से लेकर आव्यूह के आकार तक के लिए, करें

  • j के लिए 0 से लेकर मैट्रिक्स के आकार तक[0], करें

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

      • हल करें (i, j, मैट्रिक्स)

• वापसी उत्तर

उदाहरण

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

class Solution(object):
   def solve(self,i,j,matrix):
      if self.dp[i][j]:
         return self.dp[i][j]
      self.dp[i][j] = 1
      temp = 0
      for r in range(i-1,i+2):
         for c in range(j-1,j+2):
            if r==i and c==j or (abs(r-i)==1 and abs(c-j)==1):
               continue
            if c>=0 and r>=0 and r<len(matrix) and c<len(matrix[0]) and matrix[r][c]>matrix[i][j]:
temp = max(temp,self.solve(r,c,matrix))
               self.dp[i][j]+=temp
               return self.dp[i][j]
   def longestIncreasingPath(self, matrix):
      if not matrix:
         return 0
      self.dp = [ [0 for i in range(len(matrix[0]))] for j in range(len(matrix))]
      self.ans = 0
      for i in range(len(matrix)):
         for j in range(len(matrix[0])):
            if self.dp[i][j]==0:
               self.solve(i,j,matrix)
            self.ans = max(self.ans,self.dp[i][j])
      return self.ans

ob = Solution()
print(ob.longestIncreasingPath([[9,9,4],[6,6,8],[2,1,1]]))

इनपुट

[[9,9,4],[6,6,8],[2,1,1]]

आउटपुट

4