Minimum Cost Tree From Leaf Values - Practice Coding Problems

Minimum Cost Tree From Leaf Values - Problem

Imagine you're a tree architect tasked with building the most cost-effective binary tree from a given arrangement of leaf values! 🌳

Given an array arr of positive integers, you need to construct a binary tree where:

Each node has either 0 or 2 children (no single-child nodes)
The leaf values correspond to an in-order traversal of your array
Each non-leaf node's value equals the product of the maximum leaf value in its left subtree and the maximum leaf value in its right subtree

Your mission: minimize the sum of all non-leaf node values across all possible tree configurations!

Example: For [6, 2, 4], you could build different trees, but the optimal one gives you the smallest sum of internal node costs.

Input & Output

example_1.py — Basic Case

$ Input: [6, 2, 4]

› Output: 32

💡 Note: We can build different trees, but the optimal one has structure where 2 and 4 are merged first (cost = 2×4=8), then combined with 6 (cost = 6×4=24). Total cost = 8 + 24 = 32.

example_2.py — Already Optimal

$ Input: [4, 11]

› Output: 44

💡 Note: With only two leaves, we must merge them directly. The cost is simply 4 × 11 = 44.

example_3.py — Decreasing Sequence

$ Input: [15, 13, 5, 3, 1]

› Output: 500

💡 Note: In a decreasing sequence, we merge from right to left: (3×1=3) + (5×3=15) + (13×5=65) + (15×13=195) = 278. Actually, optimal is different - we need to be more careful about the tree structure.

Constraints

2 ≤ arr.length ≤ 40
1 ≤ arr[i] ≤ 15
It is guaranteed this sum fits into a 32-bit integer
Each node has either 0 or 2 children (binary tree property)

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Smaller teams should meet larger teams as late as possible

Use Stack

Maintain decreasing order - when disrupted, resolve conflicts

Calculate Costs

Each merge costs the product of the maximum values from each side

Greedy Choice

Always make locally optimal decisions for globally optimal result

Key Takeaway

🎯 Key Insight: Use a monotonic stack to greedily process elements, always merging smaller values first to minimize the total cost. This transforms an exponential problem into a linear one!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a monotonic stack with greedy approach. The key insight is to always merge smaller values first to minimize the impact in subsequent operations. We maintain a decreasing stack and remove elements when a larger value arrives, calculating costs as removed_value × min(left_neighbor, current). This achieves O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoization)	O(n³)	O(n²)	Optimize recursion by caching subproblem results
Greedy with Monotonic Stack (Optimal)	O(n)	O(n)	Use a monotonic stack to greedily remove smaller elements when larger ones arrive
Recursive Tree Construction	O(4^n)	O(n²)	Try all possible ways to split the array and build trees recursively

Dynamic Programming (Memoization) — Algorithm Steps

Create a memoization table to store results for each range
Before solving a subproblem, check if it's already computed
If cached, return the stored result
Otherwise, compute recursively and store the result
This eliminates redundant calculations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Cache

Create memoization table for storing subproblem results

First Calculation

Calculate result for range [1,2] and cache it

Cache Hit

When same range appears again, return cached result instantly

Final Result

Build solution using cached subproblems

Code -

solution.c — C

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

int memo[40][40];

int getMax(int* arr, int start, int end) {
    int max = arr[start];
    for (int i = start + 1; i <= end; i++) {
        if (arr[i] > max) max = arr[i];
    }
    return max;
}

int helper(int* arr, int left, int right) {
    if (left == right) return 0;
    
    if (memo[left][right] != -1) {
        return memo[left][right];
    }
    
    int minCost = INT_MAX;
    for (int i = left; i < right; i++) {
        int leftCost = helper(arr, left, i);
        int rightCost = helper(arr, i + 1, right);
        
        int leftMax = getMax(arr, left, i);
        int rightMax = getMax(arr, i + 1, right);
        
        int totalCost = leftCost + rightCost + leftMax * rightMax;
        if (totalCost < minCost) {
            minCost = totalCost;
        }
    }
    
    return memo[left][right] = minCost;
}

int mctFromLeafValues(int* arr, int arrSize) {
    memset(memo, -1, sizeof(memo));
    return helper(arr, 0, arrSize - 1);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[40];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", mctFromLeafValues(arr, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subproblems, each taking O(n) time to compute max values

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for all possible ranges

⚠ Quadratic Space

45.7K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Dynamic Programming (Memoization) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler