Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

एक मैट्रिक्स से सबमैट्रिस की संख्या का पता लगाने के लिए कार्यक्रम जहां तत्वों का योग सी ++ में एक विशिष्ट मूल्य के बराबर है

मान लीजिए कि हमें एक मैट्रिक्स दिया गया है जिसमें पूर्णांक मान हैं। हमें मैट्रिक्स से सबमैट्रिस का पता लगाना है जहां मैट्रिक्स के तत्वों का योग दिए गए लक्ष्य योग मान के बराबर है। हम सबमैट्रिस की संख्या लौटाते हैं।

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

0 0 1 0
0 1 0 0
0 1 0 1
1 1 0 1

और लक्ष्य =5, तो आउटपुट 3 होगा।

सबमैट्रिस की संख्या जिनके तत्वों का योग 6 के बराबर है, 2 है।

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

  • n :=चटाई का आकार
  • m :=(यदि n 0 के समान है, तो 0, अन्यथा चटाई का आकार[0])
  • यदि m> n, तो −
    • m x n आयामों के एक 2D सरणी स्थानान्तरण को परिभाषित करें
    • इनिशियलाइज़ i :=0 के लिए, जब i करें
    • इनिशियलाइज़ j :=0 के लिए, जब j करें
    • स्थानांतरित करें[j, i] :=mat[i, j]
  • रिटर्न सॉल्व (ट्रांसपोज़, सम टार्गेट)
  • उत्तर:=0
  • इनिशियलाइज़ p :=0 के लिए, जब p करें
  • एक सरणी गिरफ्तारी परिभाषित करें
  • इनिशियलाइज़ q :=p के लिए, जब q
  • इनिशियलाइज़ i :=0 के लिए, जब i करें
  • arr[i] :=arr[i] + mat[i, q]
  • कुंजी-मान युग्म वाले एक मानचित्र pcnt को परिभाषित करें {0, 1}
  • प्रीफ़:=0
  • इनिशियलाइज़ i :=0 के लिए, जब i करें
  • pref :=Pref + arr[i]
  • tmp :=वह स्थान जहाँ(pref - sumTarget) pcnt में है
  • यदि tmp pcnt की अंतिम स्थिति के बराबर नहीं है, तो −
    • (पीसीएनटी [pref] 1 से बढ़ाएं)
  • वापसी उत्तर
  • उदाहरण

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

    #include<bits/stdc++.h>
    
    using namespace std;
    
    int solve(vector<vector<int>>& mat, int sumTarget) {
       int n = mat.size();
       int m = n == 0 ? 0 : mat[0].size();
    
       if (m > n) {
          vector<vector<int>> transpose(m, vector<int>(n));
          for (int i = 0; i < n; i++) {
             for (int j = 0; j < m; j++) {
                transpose[j][i] = mat[i][j];
             }
          }
          return solve(transpose, sumTarget);
       }
    
       int ans = 0;
       for (int p = 0; p < m; p++) {
          vector<int> arr(n);
          for (int q = p; q < m; q++) {
             for (int i = 0; i < n; i++) {
                arr[i] += mat[i][q];
             }
    
             unordered_map<int, int> pcnt = {{0, 1}};
             int pref = 0;
             for (int i = 0; i < n; i++) {
                pref += arr[i];
                auto tmp = pcnt.find(pref - sumTarget);
                if (tmp != end(pcnt)) ans += tmp->second;
                pcnt[pref]++;
             }
          }
       }
       return ans;
    }
    
    int main() {
       vector<vector<int>> mat = {{0, 0, 1, 0}, {0, 1, 0, 0}, {0, 1, 0, 1}, {1, 1, 0, 1}};
    cout<< solve(mat, 5) <<endl;
    return 0;
    }

    इनपुट

    {{0, 0, 1, 0}, {0, 1, 0, 0}, {0, 1, 0, 1}, {1, 1, 0, 1}}, 5

    आउटपुट

    3

    1. C++ प्रोग्राम एक ग्रिड में प्रबुद्ध कोशिकाओं की संख्या का पता लगाने के लिए

      मान लीजिए, हमें h * w आयामों का एक ग्रिड दिया गया है। ग्रिड में कोशिकाओं में या तो बल्ब या बाधाएं हो सकती हैं। एक लाइट बल्ब सेल स्वयं को और उसके दाएं, बाएं, ऊपर और नीचे की कोशिकाओं को रोशन करता है और प्रकाश कोशिकाओं के माध्यम से चमक सकता है जब तक कि कोई बाधा सेल प्रकाश को अवरुद्ध न करे। एक बाधा सेल

    1. पथ बनाने के लिए ग्रिड में ब्लॉक करने के लिए कोशिकाओं की संख्या का पता लगाने के लिए सी ++ प्रोग्राम

      मान लीजिए, h * w आयामों का एक ग्रिड है। सेल स्थिति (0, 0) में एक रोबोट है और उसे स्थिति (h-1, w-1) पर जाना है। एक ग्रिड में दो प्रकार के सेल होते हैं, ब्लॉक और अनब्लॉक। रोबोट अनब्लॉक की गई कोशिकाओं से गुजर सकता है लेकिन अवरुद्ध कोशिकाओं से नहीं गुजर सकता। रोबोट चार दिशाओं में जा सकता है; यह बाएँ, दा

    1. पायथन में उप-पेड़ों के नोड मानों के योग से न्यूनतम मान ज्ञात करने का कार्यक्रम

      मान लीजिए, हमारे पास एक पेड़ है जिसके सभी नोड्स 1 से n तक गिने गए हैं। प्रत्येक नोड में एक पूर्णांक मान होता है। अब यदि हम पेड़ से एक किनारा हटाते हैं, तो दो उप-वृक्षों के नोड मानों के योग में अंतर न्यूनतम होना चाहिए। हमें ऐसे उप-वृक्षों के बीच न्यूनतम अंतर का पता लगाना और वापस करना होगा। पेड़ हमें