सी++ में न्यूनतम गिरने वाला पथ योग II

मान लीजिए कि हमारे पास ग्रिड एरर है, यह एक स्क्वायर ग्रिड है, गैर-शून्य शिफ्ट के साथ गिरने वाला पथ गिरफ्तारी की प्रत्येक पंक्ति से बिल्कुल एक तत्व का विकल्प है, जैसे कि आसन्न पंक्तियों में चुने गए दो तत्व एक ही कॉलम में मौजूद नहीं होते हैं। हमें शून्येतर पारियों के साथ गिरने वाले पथ का न्यूनतम योग ज्ञात करना होगा।

इसलिए, यदि इनपुट गिरफ्तारी की तरह है [[1,2,3], [4,5,6], [7,8,9]], तो आउटपुट 13 होगा, क्योंकि अलग-अलग गिरने वाले रास्ते हैं, ये [1,5,9], [1,5,7], [1,6,7], [1,6,8], [2,4,8], [2,4,9] जैसे हैं। , [2,6,7], [2,6,8], [3,4,8], [3,4,9], [3,5,7], [3,5,9]। अब सबसे छोटी राशि के साथ गिरने वाला पथ [1,5,7] है, तो उत्तर 13 है।

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

• n :=पंक्तियों की संख्या, m :=स्तंभों की संख्या

• इनिशियलाइज़ करने के लिए मैं :=1, जब i

  • सरणियों को बाएँ और दाएँ न्यूनतम आकार m

    . परिभाषित करें

  • लेफ्टमिन [0] :=arr[i - 1, 0]

  • इनिशियलाइज़ j :=1 के लिए, जब j

    • लेफ्टमिन [जे] :=कम से कम लेफ्टमिन [जे - 1] और एआर [i - 1, जे]

  • राइटमिन [एम - 1] =एआर [i - 1, एम -1]

  • इनिशियलाइज़ j :=m - 2 के लिए, जब j>=0, अपडेट करें (j को 1 से घटाएं), −

    करें

    • राइटमिन [जे]:=न्यूनतम गिरफ्तारी [i - 1, जे] और राइटमिन [जे + 1]

  • इनिशियलाइज़ j :=0 के लिए, जब j

    • लेफ्टवैल:=(यदि (जे -1)> =0, फिर लेफ्टमिन [जे -1], अन्यथा 1000000)

    • राइटवैल:=(अगर (जे + 1) <एम, फिर राइटमिन [जे + 1], अन्यथा 1000000)

    • arr[i, j] :=arr[i, j] + min(leftVal, rightVal)

• Ans :=inf

• इनिशियलाइज़ करने के लिए मैं :=0, जब i

  • उत्तर:=न्यूनतम उत्तर और गिरफ्तारी [n - 1, i]

• वापसी उत्तर

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
int dp[10005][205];
class Solution {
   public:
   void pre(){
      for(int i = 0; i <= 10000; i++){
         for(int j = 0; j <=204; j++){
            dp[i][j] = -1;
         }
      }
   }
   int minFallingPathSum(vector<vector<int>>& arr) {
      int n = arr.size();
      int m = arr[0].size();
      for (int i = 1; i < n; i++) {
         vector<int> leftMin(m);
         vector<int> rightMin(m);
         leftMin[0] = arr[i - 1][0];
         for (int j = 1; j < m; j++) {
            leftMin[j] = min(leftMin[j - 1], arr[i - 1][j]);
         }
         rightMin[m - 1] = arr[i - 1][m - 1];
         for (int j = m - 2; j >= 0; j--) {
            rightMin[j] = min(arr[i - 1][j], rightMin[j + 1]);
         }
         for (int j = 0; j < m; j++) {
            int leftVal = (j - 1) >= 0 ? leftMin[j - 1] :
            1000000;
            int rightVal = (j + 1) < m ? rightMin[j + 1] :
            1000000;
            arr[i][j] += min(leftVal, rightVal);
         }
      }
      int ans = INT_MAX;
      for (int i = 0; i < m; i++)
      ans = min(ans, arr[n - 1][i]);
      return ans;
   }
};
main(){
   Solution ob;
   vector<vector<int>> v = {{1,2,3},{4,5,6},{7,8,9}};
   cout << (ob.minFallingPathSum(v));
}

इनपुट

{{1,2,3},{4,5,6},{7,8,9}}

आउटपुट

13