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

C++ में 3-D सरणी में न्यूनतम योग पथ

हमें एक घन दिया गया है जिसे 3-D सरणी के रूप में cube[length][breadth][height] का उपयोग करके बनाया जा सकता है। कार्य घन को ट्रैवर्स करके प्राप्त होने वाले न्यूनतम योग पथ की गणना करना है और परिणाम प्रिंट करना है।

विभिन्न इनपुट-आउटपुट परिदृश्य देखते हैं:

इनपुट: int cube[length][breadth][height] = { { {2, 4, 1}, {3, 4, 5}, {9, 8, 7}}, { {5, 3, 2}, {7, 6, 5}, {8, 7, 6}}, { {3, 2, 1}, {4, 3, 2}, {5, 4, 3}} }

आउटपुट: 3-D सरणी में न्यूनतम योग पथ: 15

व्याख्या: हमें लंबाई, चौड़ाई और ऊंचाई वाला एक घन दिया गया है। अब, हम 3-D सरणी में न्यूनतम योग पथ की गणना करेंगे। तो, यह 2 + 4 + 1 + 3 + 5 = 15 से शुरू होगा।

इनपुट: int cube[length][breadth][height] = { { {1, 2}, {7, 8}}, { {3, 5}, {9, 16}} }

आउटपुट: 3-D सरणी में न्यूनतम योग पथ: 24

व्याख्या: हमें लंबाई, चौड़ाई और ऊंचाई वाला एक घन दिया गया है। अब, हम 3-D सरणी में न्यूनतम योग पथ की गणना करेंगे। तो, यह 1 + 2 + 5 + 16 = 24 से शुरू होगा।

नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण:

  • पूर्णांक प्रकार के मानों के साथ 3-D सरणी इनपुट करें ताकि एक घन बने। डेटा को फंक्शन Minimum_SubPath(cube) में पास करें।
  • फंक्शन Minimum_SubPath(cube) के अंदर:
    • घन के समान आकार की एक सरणी बनाएं और arr[0][0][0] को cube[0][0][0] पर इनिशियलाइज़ करें।
    • i को 1 से घन की लंबाई तक लूप चलाएं और arr[i][0][0] को arr[i-1][0][0] + cube[i][0][0] पर सेट करें।
    • j को 1 से घन की चौड़ाई तक लूप चलाएं और arr[0][j][0] को arr[0][j-1][0] + cube[0][j][0] पर सेट करें।
    • k को 1 से घन की ऊंचाई तक लूप चलाएं और arr[0][0][k] को arr[0][0][k-1] + cube[0][0][k] पर सेट करें।
    • i को 1 से घन की लंबाई तक लूप चलाएं और j को 1 से सरणी की चौड़ाई तक एक और लूप शुरू करें और min_val को Minimum(arr[i-1][j][0], arr[i][j-1][0], INT_MAX) पर सेट करें और arr[i][j][0] को min_val + cube[i][j][0] पर सेट करें।
    • i को 1 से घन की लंबाई तक लूप चलाएं और k को 1 से सरणी की ऊंचाई तक एक और लूप शुरू करें और min_val को Minimum(arr[i-1][0][k], arr[i][0][k-1], INT_MAX) पर सेट करें और arr[i][0][k] = min_val + cube[i][0][k] सेट करें।
    • k को 1 से घन की ऊंचाई तक लूप चलाएं और j को 1 से सरणी की चौड़ाई तक एक और लूप शुरू करें और min_val को Minimum(arr[0][j][k-1], arr[0][j-1][k], INT_MAX) पर सेट करें और arr[0][j][k] = min_val + cube[0][j][k] सेट करें।
    • i को 1 से घन की लंबाई तक लूप चलाएं, j को 1 से सरणी की चौड़ाई तक एक और लूप शुरू करें, और k को 1 से घन की ऊंचाई तक एक और लूप शुरू करें और min_val को Minimum(arr[i-1][j][k], arr[i][j-1][k], arr[i][j][k-1]) पर सेट करें और arr[i][j][k] = min_val + cube[i][j][k] सेट करें।
    • arr[length-1][breadth-1][height-1] लौटाएं।
  • फंक्शन Minimum(int a, int b, int c) के अंदर:
    • जांचें यदि a, b से कम है और a, c से कम है तो a लौटाएं।
    • अन्यथा, c लौटाएं।
    • अन्यथा यदि, b, c से कम है तो b लौटाएं।
    • अन्यथा, c लौटाएं।

उदाहरण

#include<bits/stdc++.h>
using namespace std;

#define length 3
#define breadth 3
#define height 3

int Minimum(int a, int b, int c) {
    if (a < b) {
        if (a < c) {
            return a;
        } else {
            return c;
        }
    } else if (b < c) {
        return b;
    } else {
        return c;
    }
}

int Minimum_SubPath(int cube[][breadth][height]) {
    int i, j, k;
    int arr[length][breadth][height];
    arr[0][0][0] = cube[0][0][0];
    for (i = 1; i < length; i++) {
        arr[i][0][0] = arr[i-1][0][0] + cube[i][0][0];
    }
    for (j = 1; j < breadth; j++) {
        arr[0][j][0] = arr[0][j-1][0] + cube[0][j][0];
    }
    for (k = 1; k < height; k++) {
        arr[0][0][k] = arr[0][0][k-1] + cube[0][0][k];
    }
    for (i = 1; i < length; i++) {
        for (j = 1; j < breadth; j++) {
            int min_val = Minimum(arr[i-1][j][0], arr[i][j-1][0], INT_MAX);
            arr[i][j][0] = min_val + cube[i][j][0];
        }
    }
    for (i = 1; i < length; i++) {
        for (k = 1; k < height; k++) {
            int min_val = Minimum(arr[i-1][0][k], arr[i][0][k-1], INT_MAX);
            arr[i][0][k] = min_val + cube[i][0][k];
        }
    }
    for (k = 1; k < height; k++) {
        for (j = 1; j < breadth; j++) {
            int min_val = Minimum(arr[0][j][k-1], arr[0][j-1][k], INT_MAX);
            arr[0][j][k] = min_val + cube[0][j][k];
        }
    }
    for (i = 1; i < length; i++) {
        for (j = 1; j < breadth; j++) {
            for (k = 1; k < height; k++) {
                int min_val = Minimum(arr[i-1][j][k], arr[i][j-1][k], arr[i][j][k-1]);
                arr[i][j][k] = min_val + cube[i][j][k];
            }
        }
    }
    return arr[length-1][breadth-1][height-1];
}

int main() {
    int cube[length][breadth][height] = {
        { {2, 4, 1}, {3, 4, 5}, {9, 8, 7}},
        { {5, 3, 2}, {7, 6, 5}, {8, 7, 6}},
        { {3, 2, 1}, {4, 3, 2}, {5, 4, 3}}
    };
    cout << "Minimum Sum Path In 3-D Array are: " << Minimum_SubPath(cube);
    return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा:

Minimum Sum Path In 3-D Array are: 15
  1. C++ में पाथ सम III - रूट से लीफ तक दिए गए योग वाले पाथ ढूंढना C++ में पाथ सम III - रूट से लीफ तक दिए गए योग वाले पाथ ढूंढना

    मान लीजिए हमारे पास एक बाइनरी ट्री है जिसमें प्रत्येक नोड एक पूर्णांक मान रखता है। हमें उन पाथ को ढूंढना है जिनका योग दिए गए मान के बराबर हो। पाथ रूट से लीफ तक होना चाहिए। समस्या विवरण यदि ट्री है [5,4,8,11,null,13,4,7,2,null,null,5,1] और योग 22 है, तो परिणाम होगा - पाथ हैं: [[5,4,11,2],[5,8,4,5]

  1. - C++ में सम ऐरे पजल (बिना घटाव ऑपरेटर के)

    यहां हम ऐरे से संबंधित एक रोचक समस्या देखेंगे। n तत्वों वाला एक ऐरे है। हमें n तत्वों का एक और ऐरे बनाना है। लेकिन दूसरे ऐरे का i-th स्थान पहले ऐरे के i-th तत्व को छोड़कर सभी तत्वों का योग रखेगा। और एक प्रतिबंध है कि हम इस समस्या में घटाव ऑपरेटर का उपयोग नहीं कर सकते। यदि हम घटाव ऑपरेशन का उपयोग कर

  1. - पायथन में न्यूनतम पथ योग

    मान लीजिए हमारे पास एक m x n मैट्रिक्स है जो गैर-ऋणात्मक पूर्णांकों से भरा है, शीर्ष बाएं कोने से नीचे दाएं कोने तक एक पथ ढूंढें जो उसके पथ के साथ सभी संख्याओं के योग को न्यूनतम करता है। गतिविधियाँ किसी भी समय केवल नीचे या दाएं हो सकती हैं। इसलिए उदाहरण के लिए, यदि मैट्रिक्स नीचे जैसा है 131 151