# Generate Complete Binary Tree in such a way that sum of non-leaf nodes is minimum

• Difficulty Level : Hard
• Last Updated : 22 Aug, 2022

Given an array arr[] of size N, the task is to generate a Complete Binary Tree in such a way that sum of the non-leaf nodes is minimum, whereas values of the leaf node corresponds to the array elements in an In-order Traversal of the tree and value of each non-leaf node corresponds to the product of the largest leaf value in the left sub-tree and right sub-tree
Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 20
Explanation:
Input: arr[] = {5, 2, 3}
Output: 21

Approach:
To remove a number arr[i], it needs a cost a * b, where b >= a and also an element of the array. To minimize the cost of removal, the idea is to minimize b. To compute the non-leaf node there are two candidates, that is the first largest number on the left and the first largest number on the right. The cost to remove arr[i] is a * min(left, right). It can be further decomposed as to find the next greater element in the array, on the left and one right.
Refer: Next greater element
Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// minimum cost tree` `#include ``using` `namespace` `std;` `// Function to find minimum cost tree``int` `MinCostTree(``int` `arr[], ``int` `n)``{``    ``int` `ans = 0;` `    ``// Stack``    ``vector<``int``> st = { INT_MAX };` `    ``// Loop to traverse the array elements``    ``for` `(``int` `i = 0; i < n; i++) {``        ` `        ``// Keep array elements``        ``// in decreasing order by popping out``        ``// the elements from stack till the top``        ``// element is less than current element``        ``while` `(st.back() <= arr[i]) {``            ` `            ``// Get top element``            ``int` `x = st.back();` `            ``// Remove it``            ``st.pop_back();` `            ``// Get the minimum cost to remove x``            ``ans += x * min(st.back(), arr[i]);``        ``}` `        ``// Push current element``        ``st.push_back(arr[i]);``    ``}` `    ``// Find cost for all remaining elements``    ``for` `(``int` `i = 2; i < st.size(); i++)``        ``ans += st[i] * st[i - 1];` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 2, 3 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``cout << MinCostTree(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum cost tree``import` `java.util.*;` `class` `GFG{` `// Function to find minimum cost tree``static` `int` `MinCostTree(``int` `arr[], ``int` `n)``{``    ``int` `ans = ``0``;` `    ``// Stack``    ``Vector st = ``new` `Vector();``    ``st.add(Integer.MAX_VALUE);` `    ``// Loop to traverse the array elements``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ` `        ``// Keep array elements``        ``// in decreasing order by popping out``        ``// the elements from stack till the top``        ``// element is less than current element``        ``while` `(st.get(st.size()-``1``) <= arr[i]) {``            ` `            ``// Get top element``            ``int` `x = st.get(st.size()-``1``);` `            ``// Remove it``            ``st.remove(st.size()-``1``);` `            ``// Get the minimum cost to remove x``            ``ans += x * Math.min(st.get(st.size()-``1``), arr[i]);``        ``}` `        ``// Push current element``        ``st.add(arr[i]);``    ``}` `    ``// Find cost for all remaining elements``    ``for` `(``int` `i = ``2``; i < st.size(); i++)``        ``ans += st.get(i) * st.get(i-``1``);` `    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``5``, ``2``, ``3` `};` `    ``int` `n = arr.length;` `    ``// Function call``    ``System.out.print(MinCostTree(arr, n));``}``}` `// This code is contributed by sapnasingh4991`

## Python3

 `# Python3 implementation to find the``# minimum cost tree` `# Function to find minimum cost tree``def` `MinCostTree(arr, n):``    ` `    ``ans ``=` `0``    ``st ``=` `[``2``*``*``32``]``    ` `    ``# Loop to traverse the array elements``    ``for` `i ``in` `range``(n):``        ` `        ``# Keep array elements``        ``# in decreasing order by popping out``        ``# the elements from stack till the top``        ``# element is less than current element``        ``while` `(st[``-``1``] <``=` `arr[i]):``            ` `            ``# Get top element``            ``x ``=` `st[``-``1``]``            ` `            ``# Remove it``            ``st.pop()``            ` `            ``# Get the minimum cost to remove x``            ``ans ``+``=` `x ``*` `min``(st[``-``1``], arr[i])``            ` `        ``# Push current element``        ``st.append(arr[i])``        ` `    ``# Find cost for all remaining elements``    ``for` `i ``in` `range``(``2``,``len``(st)):``        ``ans ``+``=` `st[i] ``*` `st[i ``-` `1``]``        ` `    ``return` `ans``    ` `# Driver Code``arr ``=` `[``5``, ``2``, ``3``]` `n ``=` `len``(arr)` `# Function call``print``(MinCostTree(arr, n))` `# This code is contributed by shubhamsingh10`

## C#

 `// C# implementation to find the``// minimum cost tree``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function to find minimum cost tree``static` `int` `MinCostTree(``int` `[]arr, ``int` `n)``{``    ``int` `ans = 0;` `    ``// Stack``    ``List<``int``> st = ``new` `List<``int``>();``    ``st.Add(``int``.MaxValue);` `    ``// Loop to traverse the array elements``    ``for` `(``int` `i = 0; i < n; i++) {``        ` `        ``// Keep array elements``        ``// in decreasing order by popping out``        ``// the elements from stack till the top``        ``// element is less than current element``        ``while` `(st[st.Count-1] <= arr[i]) {``            ` `            ``// Get top element``            ``int` `x = st[st.Count-1];` `            ``// Remove it``            ``st.RemoveAt(st.Count-1);` `            ``// Get the minimum cost to remove x``            ``ans += x * Math.Min(st[st.Count-1], arr[i]);``        ``}` `        ``// Push current element``        ``st.Add(arr[i]);``    ``}` `    ``// Find cost for all remaining elements``    ``for` `(``int` `i = 2; i < st.Count; i++)``        ``ans += st[i] * st[i-1];` `    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 5, 2, 3 };` `    ``int` `n = arr.Length;` `    ``// Function call``    ``Console.Write(MinCostTree(arr, n));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`21`

My Personal Notes arrow_drop_up