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

C++ में सभी समान तत्वों वाले अधिकतम वर्ग उप-मैट्रिक्स खोजना

समस्या विवरण

इस समस्या में, हमें एक N×N मैट्रिक्स mat[][] दिया गया है। हमारा कार्य सभी समान तत्वों वाले अधिकतम वर्ग उप-मैट्रिक्स को खोजना है।

इस समस्या में, हमें दिए गए मैट्रिक्स से अधिकतम आकार के उप-मैट्रिक्स को खोजने की आवश्यकता है जिसके सभी तत्व समान हों।

उदाहरण

इनपुट: mat[][] = {{1, 2, 1},
                   {1, 2, 2},
                   {2, 2, 2}}
आउटपुट: 2

व्याख्या

मैट्रिक्स a₁₁, a₁₂, a₂₁, a₂₂ आकार 2×2 का है और सभी समान तत्वों वाला उप-मैट्रिक्स बनाता है।

हल का दृष्टिकोण

समस्या का एक सरल समाधान मैट्रिक्स के सभी तत्वों को पार करना और फिर उन सभी उप-मैट्रिक्स की जांच करना है जिनके सभी तत्व समान हैं। एल्गोरिदम की समय जटिलता O(N³) है और प्रत्येक उप-मैट्रिक्स O(N²) समय जटिलता के साथ बनाया जाता है।

वैकल्पिक विधि डायनामिक प्रोग्रामिंग का उपयोग करके समस्या को हल करना है जहां हम उस स्थिति तक की शर्त को संतुष्ट करने वाले सबसे बड़े उप-मैट्रिक्स का आकार संग्रहीत करेंगे। इसके लिए हम पड़ोसी तत्वों पर विचार करेंगे और फिर दी गई शर्त को संतुष्ट करने वाले सबसे लंबे मैट्रिक्स पर विचार करेंगे।

DP मैट्रिक्स के किसी भी सेल के आकार को सूत्रबद्ध करें:

यदि तत्व के सभी पड़ोसी समान हैं, तो हम सबसे लंबे उप-मैट्रिक्स के मान बढ़ाएंगे। इस मामले में,

DP[i][j] = min(DP[i-1][j], DP[i][j-1], DP[i-1][j-1]) + 1

यदि ऐसा नहीं है,

DP[i][j] = 1

C++ कार्यान्वयन

#include <bits/stdc++.h> 
#define N 4
#define M 4
using namespace std; 

int findMaxSqMatSize(int mat[][M]) {
    int DP[N][M];
    memset(DP, 0, sizeof(DP));
    int maxSqMatSize = 0;
    
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (i == 0 || j == 0) {
                DP[i][j] = 1;
            } else {
                if (mat[i][j] == mat[i-1][j] && 
                    mat[i][j] == mat[i][j-1] && 
                    mat[i][j] == mat[i-1][j-1]) {
                    DP[i][j] = min({DP[i-1][j], DP[i][j-1], DP[i-1][j-1]}) + 1;
                } else {
                    DP[i][j] = 1;
                }
            }
            maxSqMatSize = max(maxSqMatSize, DP[i][j]);
        }
    }
    return maxSqMatSize;
}

int main() {
    int mat[N][M] = {
        {2, 1, 4, 3},
        {5, 1, 1, 7},
        {1, 1, 1, 4},
        {9, 4, 6, 0}
    };
    cout << "सभी समान तत्वों वाला अधिकतम वर्ग उप-मैट्रिक्स है " << findMaxSqMatSize(mat);
    return 0;
}

आउटपुट

सभी समान तत्वों वाला अधिकतम वर्ग उप-मैट्रिक्स है 2

जटिलता विश्लेषण

  • समय जटिलता: O(N × M)
  • स्पेस जटिलता: O(N × M) - DP टेबल के लिए

DP अंतर्ज्ञान

DP[i][j] मैट्रिक्स के निचले-दाएं कोने (i, j) पर समाप्त होने वाले सभी समान तत्वों वाले सबसे बड़े वर्ग का आकार दर्शाता है। यह तभी बढ़ सकता है जब ऊपर, बाएं, और विकर्ण-ऊपर-बाएं सभी का मान समान हो और स्वयं वर्ग बना सकें।

  1. C++ में सभी सबसे गहरे नोड्स वाला सबसे छोटा सबट्री C++ में सभी सबसे गहरे नोड्स वाला सबसे छोटा सबट्री

    मान लीजिए हमारे पास रूट पर रूटेड एक बाइनरी ट्री है, प्रत्येक नोड की गहराई रूट से सबसे छोटी दूरी है। यहां एक नोड सबसे गहरा है यदि इसकी गहराई पूरे ट्री में किसी भी नोड के बीच सबसे बड़ी संभव है। एक नोड का सबट्री वह नोड है, साथ ही उस नोड के सभी वंशजों का सेट। हमें सबसे बड़ी गहराई वाला नोड ढूंढना है जैसे

  1. - C++ में न्यूनतम और अधिकतम तत्वों को छोड़कर आकार K के सभी उपअनुक्रमों का गुणनफल

    एक सरणी arr[n] दी गई है, जिसमें n संख्या में पूर्णांक हैं और आकार को परिभाषित करने के लिए एक पूर्णांक k; कार्य आकार k के सभी उपअनुक्रमों का गुणनफल प्रिंट करना है, जिसमें न्यूनतम और अधिकतम तत्वों को छोड़कर।मान लें हमारे पास 4 तत्वों का एक समुच्चय {1, 2, 3, 4} है और k 2 है तो इसके उपसमुच्चय होंगे &min

  1. - C++ में सरणी के सभी तत्वों को बराबर बनाने के लिए न्यूनतम ऑपरेशन

    समस्या कथनn धनात्मक पूर्णांकों वाली एक सरणी दी गई है। हमें सभी तत्वों को बराबर बनाने के लिए न्यूनतम ऑपरेशन की संख्या ज्ञात करनी है। हम सरणी तत्व पर किसी भी तत्व के साथ जोड़, गुणा, घटाव या भाग कर सकते हैं।उदाहरणयदि इनपुट सरणी = {1, 2, 3, 4} है तो हमें सभी तत्वों को बराबर बनाने के लिए न्यूनतम 3 ऑपरेशन