Minimum Cost Tree From Leaf Values

Minimum Cost Tree From Leaf Values - Problem

Given an array arr of positive integers, consider all binary trees such that:

Each node has either 0 or 2 children
The values of arr correspond to the values of each leaf in an in-order traversal of the tree
The value of each non-leaf node is equal to the product of the largest leaf value in its left and right subtree

Among all possible binary trees considered, return the smallest possible sum of the values of each non-leaf node. It is guaranteed this sum fits into a 32-bit integer.

A node is a leaf if and only if it has zero children.

Input & Output

Example 1 — Basic Case

$ Input: arr = [6,2,4]

› Output: 32

💡 Note: There are two possible trees. The first has non-leaf node sum 36, the second has non-leaf node sum 32. Tree 1: ((6,2),4) → cost = 6*2 + max(6,2)*4 = 12 + 24 = 36. Tree 2: (6,(2,4)) → cost = 2*4 + 6*max(2,4) = 8 + 24 = 32.

Example 2 — Minimum Size

$ Input: arr = [4,11]

› Output: 44

💡 Note: Only one possible tree with root having value 4*11 = 44.

Example 3 — Multiple Elements

$ Input: arr = [1,2,3,4]

› Output: 28

💡 Note: Optimal grouping: (1,(2,(3,4))) → costs: 3*4=12, 2*4=8, 1*4=4, total=28.

Constraints

2 ≤ arr.length ≤ 40
1 ≤ arr[i] ≤ 15
It is guaranteed that the answer fits in a 32-bit signed integer (i.e., it is less than 2³¹)

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a greedy approach with a monotonic stack. Always remove smaller elements first to minimize the total cost. The optimal approach uses a stack in O(n) time, achieving much better performance than the O(n³) recursive solution. Time: O(n), Space: O(n)

Common Approaches

✓ Greedy with Stack

⏱️ Time: O(n) Space: O(n)

Use a monotonic decreasing stack. When we encounter a smaller element, we can 'remove' larger elements by combining them, which minimizes the total cost.

Recursive with Memoization

⏱️ Time: O(n³) Space: O(n²)

For each possible split point, recursively calculate the cost of left and right subtrees, then add the cost of combining them (max of left × max of right).

Greedy with Stack — Algorithm Steps

Iterate through array with a monotonic decreasing stack
When current element is larger than stack top, we found a removal opportunity
Remove elements from stack and add cost = removed × min(left, right)
This greedy choice always leads to optimal solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Elements

Use stack to track elements in decreasing order

Remove When Possible

When we find larger element, remove smaller ones

Calculate Cost

Cost = removed × min(left_neighbor, right_neighbor)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int* arr, int n) {
    int* stack = (int*)malloc(n * sizeof(int));
    int top = -1;
    int result = 0;
    
    for (int i = 0; i < n; i++) {
        while (top >= 0 && stack[top] <= arr[i]) {
            int removed = stack[top--];
            if (top >= 0) {
                result += removed * min(stack[top], arr[i]);
            } else {
                result += removed * arr[i];
            }
        }
        stack[++top] = arr[i];
    }
    
    // Handle remaining elements in stack
    while (top > 0) {
        int removed = stack[top--];
        result += removed * stack[top];
    }
    
    free(stack);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[20], n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each element pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack stores at most n elements in worst case

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.1K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler