Question

3. [5 marks] Suppose T is a binary tree that stores an integer key value in each node. Assume the following notation/operations on a binary tree. » the key T.key is the root node's integer key value . the left child T.left is T's left subtree, which is possibly an empty tree (or null) the right child T.right is T's right subtree, which is possibly an empty tree (or null) (a) Write an efficient algorithm FINDMAxPrODuCT(T) in pseudocode that returns the max- imum product of the key values on all possible paths in the tree T, which is passed as the input to the function. For the tree below, your algorithm should return a value of 240 (from the path with key values 5×-2 × 3 × 4 x -2) -2 4 0 -2 You must include appropriate comments in your pseudocode. (b) Trace the output of your algorithm 'running' using the binary tree shown above. You may wish to include a table of node values and corresponding temp' values generated at each n ode as your algorithm proceeds

Answer 1

1)

Given a binary tree, find the maximum path product. The path may start and end at any node in the tree.

Here I have taken simple Example:

Input: Root of below tree
       1
      / \
     2   3
Output: 6 (1*2*3)

See below diagram for Given example.

-2 4 5 0-2 2

For each node there can be four ways that the max path goes through the node:
1. Node only
2. Max path through Left Child * Node
3. Max path through Right Child * Node
4. Max path through Left Child * Node * Max path through Right Child

The idea is to keep trace of four paths and pick up the max one in the end. An important thing to note is, root of every subtree need to return maximum path product such that at most one child of root is involved. This is needed for parent function call. In below code, this product is stored in ‘max_single’ and returned by the recursive function.

CODE:- (I provided you the code with comments for better understanding. Please follow below code..)

// This function returns overall maximum path product in 'res'

// And returns max path product going through root.

int findMaxUtil(Node* root, int &res)

{

    //Base Case

    if (root == NULL)

        return 0;

    // l and r store maximum path product going through left and

    // right child of root respectively

    int l = findMaxUtil(root->left,res);

    int r = findMaxUtil(root->right,res);

    // Max path for parent call of root. This path must

    // include at-most one child of root

    int max_single = max(max(l, r) * root->data, root->data);

    // Max Top represents the product when the Node under

    // consideration is the root of the maxproduct path and no

    // ancestors of root are there in max product path

    int max_top = max(max_single, l * r * root->data);

    res = max(res, max_top); // Store the Maximum Result.

    return max_single;

}

// Returns maximum path product in tree with given root

int findMaxProduct(Node *root)

{

    // Initialize result

    int res = INT_MIN;

    // Compute and return result

    findMaxUtil(root, res);

    return res;

}

(b)

After I tracing the output using binary tree shown above, it becomes like

Output:

Max path product is 240.

Here I have taken one more tree let's see the output

2. 25 20 4000

Output:

Max path product is 4000.