以非叶节点总和最小的方式生成完全二叉树

给定一个大小为N的数组arr[] ，任务是以非叶节点的总和最小的方式生成一个完整的二叉树，而叶节点的值对应于一个有序的数组元素树的遍历和每个非叶子节点的值对应左子树和右子树中最大的叶子值的乘积
例子：

Input: arr[] = {1, 2, 3, 4} 
Output: 20 
Explanation: 
Please refer below for explanation
Input: arr[] = {5, 2, 3} 
Output: 21 
 

方法：
要删除一个数字arr[i] ，它需要一个成本a * b ，其中b >= a以及数组的一个元素。为了最小化移除成本，想法是最小化b 。为了计算非叶节点，有两个候选，即左边的第一个最大数和右边的第一个最大数。删除arr[i]的成本是* min(left, right) 。它可以进一步分解为在数组中找到下一个更大的元素，在左边和右边。
参考：下一个更大的元素
下面是上述方法的实现：

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 st = { INT_MAX };
 
    // Loop to traverse the array elements
    for (int i = 0; i < n; i++) {
         
        // Keep array elements
        // in decreasing order by poping 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 poping 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 poping 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 st = new List();
    st.Add(int.MaxValue);
 
    // Loop to traverse the array elements
    for (int i = 0; i < n; i++) {
         
        // Keep array elements
        // in decreasing order by poping 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

// Javascript implementation to find the
// minimum cost tree
 
// Function to find minimum cost tree
function MinCostTree(arr, n)
{
    let ans = 0;
 
    // Stack
    let st = new Array()
    st.push(Number.MAX_SAFE_INTEGER);
 
    // Loop to traverse the array elements
    for (let i = 0; i < n; i++) {
         
        // Keep array elements
        // in decreasing order by poping out
        // the elements from stack till the top
        // element is less than current element
        while (st[st.length -1] <= arr[i]) {
             
            // Get top element
            let x = st[st.length-1];
 
            // Remove it
            st.pop();
 
            // Get the minimum cost to remove x
            ans += x * Math.min(st[st.length - 1], arr[i]);
        }
 
        // Push current element
        st.push(arr[i]);
    }
 
    // Find cost for all remaining elements
    for (let i = 2; i < st.length; i++)
        ans += st[i] * st[i - 1];
 
    return ans;
}
 
// Driver Code
 
    let arr = [ 5, 2, 3 ];
 
    let n = arr.length;
 
    // Function call
    document.write(MinCostTree(arr, n));
 
    // This code is contributed by gfgking

输出：

21

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live