C++ में बाइनरी ट्री के दो पत्तों के बीच न्यूनतम सम पथ

समस्या कथन

एक बाइनरी ट्री दिया गया है जिसमें प्रत्येक नोड एलिमेंट में एक संख्या होती है। कार्य एक लीफ नोड से दूसरे लीफ नोड तक न्यूनतम संभव योग ढूंढना है।

उदाहरण

उपरोक्त ट्री में न्यूनतम सब पथ -6 है जैसा कि नीचे दिया गया है: (-4) + 3 + 2 + (-8) + 1

एल्गोरिदम

विचार रिकर्सिव कॉल में दो मान बनाए रखने का है -

• वर्तमान नोड के तहत रूटेड सबट्री के लिए न्यूनतम रूट-टू-लीफ पथ योग
• पत्तियों के बीच न्यूनतम पथ योग
• प्रत्येक विजिटेड नोड X के लिए, हमें X के बाएं और दाएं सबट्री में न्यूनतम रूट-टू-लीफ योग ढूंढना होगा। फिर दोनों मानों को X के डेटा के साथ जोड़ें, और योग की तुलना वर्तमान न्यूनतम पथ योग से करें

उदाहरण

#include 
using namespace std;

typedef struct node {
    int data;
    struct node *left;
    struct node *right;
} node;

node *newNode(int data) {
    node *n = new node;
    n->data = data;
    n->left = NULL;
    n->right = NULL;
    return n;
}

int getMinPath(node *root, int &result) {
    if (root == NULL) {
        return 0;
    }
    if (root->left == NULL && root->right == NULL) {
        return root->data;
    }
    int leftSum = getMinPath(root->left, result);
    int rightSum = getMinPath(root->right, result);
    if (root->left && root->right) {
        result = min(result, root->data + leftSum + rightSum);
        return min(root->data + leftSum, root->data + rightSum);
    }
    if (root->left == NULL) {
        return root->data + rightSum;
    } else {
        return root->data + leftSum;
    }
}

int getMinPath(node *root) {
    int result = INT_MAX;
    getMinPath(root, result);
    return result;
}

node *createTree() {
    node *root = newNode(2);
    root->left = newNode(3);
    root->right = newNode(-8);
    root->left->left = newNode(5);
    root->left->right = newNode(-4);
    root->right->left = newNode(1);
    root->right->right = newNode(10);
    return root;
}

int main() {
    node *root = createTree();
    cout << "Minimum sum path = " << getMinPath(root) << endl;
    return 0;
}

जब आप उपरोक्त प्रोग्राम को कंपाइल और 실행 करते हैं। यह निम्नलिखित आउटपुट उत्पन्न करता है -

आउटपुट

Minimum sum path = -6