Optimal BST Construction - Problem

Advanced DP DP BST Hard

Given an array of keys and their corresponding search frequencies, construct a Binary Search Tree that minimizes the total search cost.

The search cost for a key is defined as: frequency * (depth + 1), where depth is the level of the node in the BST (root has depth 0).

Your task is to return the minimum possible total search cost for the optimal BST.

Note: Keys are given in sorted order, and all frequencies are positive integers.

Input & Output

Example 1 — Basic Case

$ Input: keys = [10, 12, 20], frequencies = [34, 8, 50]

› Output: 168

💡 Note: Optimal BST has key 20 as root (cost: 50×1=50), key 12 as left child (cost: 8×2=16), and key 10 as left child of 12 (cost: 34×3=102). Total: 50+16+102=168.

Example 2 — Two Keys

$ Input: keys = [10, 20], frequencies = [34, 50]

› Output: 118

💡 Note: With two keys, optimal BST has key 20 as root (cost: 50×1=50) and key 10 as left child (cost: 34×2=68). Total: 50+68=118.

Example 3 — Equal Frequencies

$ Input: keys = [1, 2, 3], frequencies = [10, 10, 10]

› Output: 40

💡 Note: With equal frequencies, optimal BST has key 2 as root (cost: 10×1=10), keys 1 and 3 as children (cost: 10×2 + 10×2=40). Total: 10+40=50.

Constraints

1 ≤ keys.length ≤ 100
keys are sorted in ascending order
1 ≤ frequencies[i] ≤ 100
keys.length == frequencies.length

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is that optimal BST construction follows optimal substructure: the optimal BST for a range can be built from optimal BSTs of its left and right subranges. Best approach uses bottom-up dynamic programming to systematically build solutions from smaller to larger subproblems. Time: O(n³), Space: O(n²)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use a 2D DP table where dp[i][j] represents the minimum cost for keys from index i to j. Fill the table systematically from smaller ranges to larger ranges.

Brute Force - Try All BST Structures

⏱️ Time: O(4ⁿ/n^(3/2)) Space: O(n)

Generate all possible BST structures for the given keys, calculate the search cost for each structure, and return the minimum cost found.

Memoization - Top-Down DP

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

Apply the same recursive approach as brute force, but cache the results of subproblems to avoid redundant calculations using memoization.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create 2D DP table and prefix sum array
Step 2: Fill diagonal elements (single keys)
Step 3: Fill table for increasing range lengths
Step 4: Try each possible root within range and take minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Fill diagonal with single key costs

Build Up

Fill table for increasing range lengths

Final Answer

dp[0][n-1] contains minimum cost

Code -

solution.c — C

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

int solution(int* keys, int keysSize, int* frequencies, int freqSize) {
    int n = keysSize;
    
    // Create DP table where dp[i][j] = min cost for keys[i:j+1]
    int dp[100][100];
    memset(dp, 0, sizeof(dp));
    
    // Prefix sum for quick frequency sum calculation
    int prefixSum[101] = {0};
    for (int i = 0; i < n; i++) {
        prefixSum[i + 1] = prefixSum[i] + frequencies[i];
    }
    
    // Fill DP table bottom-up
    for (int length = 1; length <= n; length++) { // length of subarray
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            if (i == j) { // Single element
                dp[i][j] = frequencies[i];
            } else {
                int freqSum = prefixSum[j + 1] - prefixSum[i];
                dp[i][j] = INT_MAX;
                
                // Try each key as root
                for (int r = i; r <= j; r++) {
                    int leftCost = (r > i) ? dp[i][r-1] : 0;
                    int rightCost = (r < j) ? dp[r+1][j] : 0;
                    int totalCost = freqSum + leftCost + rightCost;
                    if (totalCost < dp[i][j]) {
                        dp[i][j] = totalCost;
                    }
                }
            }
        }
    }
    
    return dp[0][n-1];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse keys array
    int keys[100];
    int keysSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        keys[keysSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    
    // Parse frequencies array
    int frequencies[100];
    int freqSize = 0;
    token = strtok(line + 1, ",]");
    while (token != NULL) {
        frequencies[freqSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(keys, keysSize, frequencies, freqSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: range length (n), starting position (n), root selection (n)

✓ Linear Growth

Space Complexity

O(n²)

2D DP table of size n×n to store all subproblem results

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Optimal BST Construction - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler