शहर के क्षितिज को पायथन में रखने के लिए अधिकतम वृद्धि

मान लीजिए कि हमारे पास ग्रिड नामक एक 2-आयामी सरणी है, जहां ग्रिड का प्रत्येक मान [i] [j] वहां स्थित एक इमारत की ऊंचाई का प्रतिनिधित्व करता है। हम किसी भी भवन की ऊंचाई को किसी भी राशि से बढ़ा सकते हैं। ऊँचाई 0 को भवन भी माना जाता है। अंत में, ग्रिड के चारों दिशाओं से देखे जाने पर "स्काईलाइन", मूल ग्रिड के क्षितिज के समान होना चाहिए। क्योंकि एक शहर का क्षितिज दूर से देखने पर सभी इमारतों द्वारा निर्मित आयतों का बाहरी समोच्च होता है। इसलिए हमें अधिकतम कुल योग ज्ञात करना होगा जिससे इमारतों की ऊंचाई बढ़ाई जा सके।

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

3	0	8	4
2	4	5	7
9	2	3	6
0	3	1	0

तो आउटपुट 35 होगा, ऐसा इसलिए है क्योंकि ऊपर या नीचे से देखा जाने वाला स्काईलाइन है:[9, 4, 8, 7], बाएँ या दाएँ से देखा जाने वाला स्काईलाइन है:[8, 7, 9, 3], तो अंतिम मैट्रिक्स इस तरह हो सकता है -

8	4	8	7
7	4	7	7
9	4	8	7
3	3	3	3

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

max_row_wise :=एक नई सूची
max_column_wise :=एक नई सूची
काउंटर :=0
ग्रिड में प्रत्येक i के लिए, करें
- max_row_wise के अंत में अधिकतम i डालें
- काउंटर :=काउंटर + 1
काउंटर:=0, मैं:=0, जे:=0
temp_list :=एक नई सूची
निम्नलिखित को असीम रूप से करें -
- ग्रिड [i, j] को temp_list में डालें
- मैं :=मैं + 1
- अगर j ग्रिड के आकार के समान है [0] -1 और i>=len(grid), तो
  - max_column_wise के अंत में अधिकतम temp_list डालें
  - लूप से बाहर आएं
- अन्यथा जब i>=ग्रिड का आकार, तब
  - मैं:=0, जे:=जे + 1
  - max_column_wise के अंत में अधिकतम temp_list डालें
  - काउंटर :=काउंटर + 1
  - temp_list:=एक नई सूची
top_bottom, left_right:=max_row_wise,max_column_wise
मैं, जे, मान:=0,0,0
निम्नलिखित को असीम रूप से करें, करें
- अस्थायी:=न्यूनतम [top_bottom[i], left_right[j]]
- जे:=जे + 1
- यदि j ग्रिड के कॉलम की लंबाई के समान है और i ग्रिड -1 की पंक्ति गणना के समान है, तो
  - लूप से बाहर आएं
- अन्यथा जब j ग्रिड कॉलम के आकार के समान हो, तब
  - मैं :=मैं+1
  - जे:=0
वापसी मूल्य

उदाहरण

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

class Solution:
   def maxIncreaseKeepingSkyline(self, grid):
      max_row_wise = []
      max_column_wise = []
      counter = 0
      for i in grid:
         max_row_wise.append(max(i))
         counter+=1
      counter = 0
      i = 0
      j = 0
      temp_list = []
      while True:
         temp_list.append(grid[i][j])
         i+=1
         if j ==len(grid[0])-1 and i>=len(grid):
            max_column_wise.append(max(temp_list))
            break
         elif i >= len(grid):
            i = 0
            j = j + 1
            max_column_wise.append(max(temp_list))
            counter +=1
            temp_list=[]
      top_bottom, left_right = max_row_wise,max_column_wise
      i, j, value = 0,0,0
      while True:
         temp = min([top_bottom[i], left_right[j]])
         value+= abs(grid[i][j] - temp)
         j+=1
         if j == len(grid[0]) and i==len(grid)-1:
            break
         elif j == len(grid[0]):
            i = i+1
            j = 0
      return value

ob = Solution()
print(ob.maxIncreaseKeepingSkyline([[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,
3,1,0]]))

इनपुट

[[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]