Optimal Binary Search Tree

Last Updated : 22 Dec, 2025

Given a sorted array keys[0.. n-1] of search keys and an array freq[0.. n-1] of frequency counts, where freq[i] is the number of searches for keys[i]. Construct a binary search tree of all keys such that the total cost of all the searches is as small as possible.

The cost of a BST node is the level of that node multiplied by its frequency. The level of the root is 1.

Examples:  

Input: keys[] = [10, 12], freq[]= [34, 50]
Output: 118
Explanation: There can be following two possible BSTs
The cost of tree I is 34*1 + 50*2 = 134
The cost of tree II is 50*1 + 34*2 = 118

Optimal-Binary-Search-Tree


Input: keys[] = [10, 12, 20], freq[]= [34, 8, 50]
Output: 142
Explanation: There can be many possible BSTs. Among all possible BSTs, cost of the fifth BST is 1*50 + 2*34 + 3*8 = 142 which is the minimum.

Optimal-Binary-Search-Tree-2
Try It Yourself
redirect icon

Table of Content

Intuition:

We would multiply each frequency by its tree level, but keeping track of levels makes the solution complicated.

Instead of that, we use a smarter approach. Whenever we choose a node as the root, we add the sum of the frequencies of all the nodes between the start and end index (i to j). After choosing the root, every node in that group (both left and right subtree) automatically shifts one level deeper. When recursion goes deeper and solves the smaller subtrees, their frequency sum is added again automatically, which has the exact same effect as multiplying each node by its level.

[Naive Approach] Using Recursion - O(2^n) Time and O(n) Space

As discussed in our intuition, we try each key as the root of the tree. For every root choice, we recursively compute the cost of its left and right subtrees. At each step, we add the sum of freq in that range to account for all keys moving one level deeper. We repeat this process for all possible roots and finally pick the configuration that gives the minimum total cost.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
using namespace std;

//Driver Code Ends

//function to get sum of
// array elements freq[i] to freq[j]
int sum(vector<int> &freq, int i, int j) {
    int s = 0;
    for (int k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// A recursive function to calculate
// cost of optimal binary search tree
int optCost(vector<int> &freq, int i, int j) {

    // no elements in this subarray
    if (j < i)
        return 0;

    // one element in this subarray
    if (j == i)
        return freq[i];

    // Get sum of freq[i], freq[i+1], ... freq[j]
    int fsum = sum(freq, i, j);

    int minCost = INT_MAX;

    // One by one consider all elements
    // as root and recursively find cost
    // of the BST
    for (int r = i; r <= j; ++r) {
        int cost = optCost(freq, i, r - 1) + optCost(freq, r + 1, j);
        if (cost < minCost)
            minCost = cost;
    }

    // Return minimum value
    return minCost + fsum;
}

int minCost(vector<int> &keys, vector<int> &freq) {

    int n = keys.size();
    return optCost(freq, 0, n - 1);
}

//Driver Code Starts

int main() {

    vector<int> keys = {10, 12, 20};
    vector<int> freq = {34, 8, 50};
    cout << minCost(keys, freq);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
import java.util.Arrays;

public class GFG {

//Driver Code Ends

    // function to get sum of
    // array elements freq[i] to freq[j]
    static int sum(int[] freq, int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // A recursive function to calculate
    // cost of optimal binary search tree
    static int optCost(int[] freq, int i, int j) {

        // no elements in this subarray
        if (j < i)
            return 0;

        // one element in this subarray
        if (j == i)
            return freq[i];

        // Get sum of freq[i], freq[i+1], ... freq[j]
        int fsum = sum(freq, i, j);

        int minCost = Integer.MAX_VALUE;

        // One by one consider all elements
        // as root and recursively find cost
        // of the BST
        for (int r = i; r <= j; r++) {
            int cost = optCost(freq, i, r - 1) + optCost(freq, r + 1, j);
            if (cost < minCost)
                minCost = cost;
        }

        // Return minimum value
        return minCost + fsum;
    }

    static int minCost(int[] keys, int[] freq) {
        int n = keys.length;
        return optCost(freq, 0, n - 1);
    }

//Driver Code Starts

    public static void main(String[] args) {
        int[] keys = {10, 12, 20};
        int[] freq = {34, 8, 50};
        System.out.println(minCost(keys, freq));
    }
}

//Driver Code Ends
Python 
# function to get sum of
# array elements freq[i] to freq[j]
def sum(freq, i, j):
    s = 0
    for k in range(i, j + 1):
        s += freq[k]
    return s

# A recursive function to calculate
# cost of optimal binary search tree
def optCost(freq, i, j):

    # no elements in this subarray
    if j < i:
        return 0

    # one element in this subarray
    if j == i:
        return freq[i]

    # Get sum of freq[i], freq[i+1], ... freq[j]
    fsum = sum(freq, i, j)

    minCost = float('inf')

    # One by one consider all elements
    # as root and recursively find cost
    # of the BST
    for r in range(i, j + 1):
        cost = optCost(freq, i, r - 1) + optCost(freq, r + 1, j)
        if cost < minCost:
            minCost = cost

    # Return minimum value
    return minCost + fsum

def minCost(keys, freq):
    n = len(keys)
    return optCost(freq, 0, n - 1)


#Driver Code Starts

if __name__ == '__main__':
    keys = [10, 12, 20]
    freq = [34, 8, 50]
    print(minCost(keys, freq))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {

//Driver Code Ends

    // function to get sum of
    // array elements freq[i] to freq[j]
    static int sum(int[] freq, int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // A recursive function to calculate
    // cost of optimal binary search tree
    static int optCost(int[] freq, int i, int j) {

        // no elements in this subarray
        if (j < i)
            return 0;

        // one element in this subarray
        if (j == i)
            return freq[i];

        // Get sum of freq[i], freq[i+1], ... freq[j]
        int fsum = sum(freq, i, j);

        int minCost = int.MaxValue;

        // One by one consider all elements
        // as root and recursively find cost
        // of the BST
        for (int r = i; r <= j; r++) {
            int cost = optCost(freq, i, r - 1) + optCost(freq, r + 1, j);
            if (cost < minCost)
                minCost = cost;
        }

        // Return minimum value
        return minCost + fsum;
    }

    static int minCost(int[] keys, int[] freq) {
        int n = keys.Length;
        return optCost(freq, 0, n - 1);
    }

//Driver Code Starts

    static void Main() {
        int[] keys = {10, 12, 20};
        int[] freq = {34, 8, 50};
        Console.WriteLine(minCost(keys, freq));
    }
}

//Driver Code Ends
JavaScript 
// function to get sum of
// array elements freq[i] to freq[j]
function sum(freq, i, j) {
    let s = 0;
    for (let k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// A recursive function to calculate
// cost of optimal binary search tree
function optCost(freq, i, j) {

    // no elements in this subarray
    if (j < i) return 0;

    // one element in this subarray
    if (j === i) return freq[i];

    // Get sum of freq[i], freq[i+1], ... freq[j]
    let fsum = sum(freq, i, j);

    let minCost = Number.MAX_SAFE_INTEGER;

    // One by one consider all elements
    // as root and recursively find cost
    // of the BST
    for (let r = i; r <= j; r++) {
        let cost = optCost(freq, i, r - 1) + optCost(freq, r + 1, j);
        if (cost < minCost) minCost = cost;
    }

    // Return minimum value
    return minCost + fsum;
}

function minCostKeys(keys, freq) {
    let n = keys.length;
    return optCost(freq, 0, n - 1);
}


//Driver Code Starts

//Driver Code
let keys = [10, 12, 20];
let freq = [34, 8, 50];
console.log(minCostKeys(keys, freq));

//Driver Code Ends

Output
142

[Expected Approach 1] Using Top - Down Dp (Memoization) - O(n^3) Time and O(n^2) Space

If we look at the recursive approach, we notice that many subproblems are solved repeatedly, which leads to exponential time complexity. To avoid this, we use memoization.

We create a 2D DP array of size n x n to store the results of already solved subproblems. Whenever we encounter a subproblem, If the answer is already computed, we simply return it instead of recalculating.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
using namespace std;

//Driver Code Ends

//function to get sum of
// array elements freq[i] to freq[j]
int sum(vector<int> &freq, int i, int j) {

    int s = 0;
    for (int k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// A recursive function to calculate
// cost of optimal binary search tree
int optCost(vector<int> &freq, int i, int j, vector<vector<int>> &dp) {

    // Base cases
    if (j < i)
        return 0;
    if (j == i)
        return freq[i];

    if (dp[i][j] != -1)
        return dp[i][j];

    // Get sum of freq[i], freq[i+1], ... freq[j]
    int fsum = sum(freq, i, j);
    int minCost = INT_MAX;

    // One by one consider all elements
    // as root and recursively find cost
    // of the BST
    for (int r = i; r <= j; ++r) {
        int cost = optCost(freq, i, r - 1, dp) + optCost(freq, r + 1, j, dp);
        if (cost < minCost)
            minCost = cost;
    }

    // Return minimum value
    return dp[i][j] = minCost + fsum;
}

// The main function that calculates
// minimum cost of a Binary Search Tree.
int minCost(vector<int> &keys, vector<int> &freq) {
    int n = keys.size();
    vector<vector<int>> dp(n, vector<int>(n, -1));
    return optCost(freq, 0, n - 1, dp);
}

//Driver Code Starts

int main() {

    vector<int> keys = {10, 12, 20};
    vector<int> freq = {34, 8, 50};
    cout << minCost(keys, freq);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
import java.util.Arrays;

public class GFG {

//Driver Code Ends

    //function to get sum of
    // array elements freq[i] to freq[j]
    static int sum(int[] freq, int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // A recursive function to calculate
    // cost of optimal binary search tree
    static int optCost(int[] freq, int i, int j, int[][] dp) {

        // Base cases
        if (j < i)
            return 0;
        if (j == i)
            return freq[i];

        if (dp[i][j] != -1)
            return dp[i][j];

        // Get sum of freq[i], freq[i+1], ... freq[j]
        int fsum = sum(freq, i, j);
        int minCost = Integer.MAX_VALUE;

        // One by one consider all elements
        // as root and recursively find cost
        // of the BST
        for (int r = i; r <= j; r++) {
            int cost = optCost(freq, i, r - 1, dp) + optCost(freq, r + 1, j, dp);
            if (cost < minCost)
                minCost = cost;
        }

        // Return minimum value
        return dp[i][j] = minCost + fsum;
    }

    // The main function that calculates
    // minimum cost of a Binary Search Tree.
    static int minCost(int[] keys, int[] freq) {
        int n = keys.length;
        int[][] dp = new int[n][n];
        for (int[] row : dp)
            Arrays.fill(row, -1);
        return optCost(freq, 0, n - 1, dp);
    }

//Driver Code Starts

    public static void main(String[] args) {
        int[] keys = {10, 12, 20};
        int[] freq = {34, 8, 50};
        System.out.println(minCost(keys, freq));
    }
}

//Driver Code Ends
Python 
#function to get sum of
# array elements freq[i] to freq[j]
def sum(freq, i, j):
    s = 0
    for k in range(i, j+1):
        s += freq[k]
    return s

# A recursive function to calculate
# cost of optimal binary search tree
def optCost(freq, i, j, dp):

    # Base cases
    if j < i:
        return 0
    if j == i:
        return freq[i]

    if dp[i][j] != -1:
        return dp[i][j]

    # Get sum of freq[i], freq[i+1], ... freq[j]
    fsum = sum(freq, i, j)
    minCost = float('inf')

    # One by one consider all elements
    # as root and recursively find cost
    # of the BST
    for r in range(i, j+1):
        cost = optCost(freq, i, r-1, dp) + optCost(freq, r+1, j, dp)
        if cost < minCost:
            minCost = cost

    # Return minimum value
    dp[i][j] = minCost + fsum
    return dp[i][j]

# The main function that calculates
# minimum cost of a Binary Search Tree.
def minCost(keys, freq):
    n = len(keys)
    dp = [[-1]*n for _ in range(n)]
    return optCost(freq, 0, n-1, dp)


#Driver Code Starts

if __name__ == '__main__':
    keys = [10, 12, 20]
    freq = [34, 8, 50]
    print(minCost(keys, freq))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {

//Driver Code Ends

    //function to get sum of
    // array elements freq[i] to freq[j]
    static int sum(int[] freq, int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // A recursive function to calculate
    // cost of optimal binary search tree
    static int optCost(int[] freq, int i, int j, int[,] dp) {

        // Base cases
        if (j < i)
            return 0;
        if (j == i)
            return freq[i];

        if (dp[i, j] != -1)
            return dp[i, j];

        // Get sum of freq[i], freq[i+1], ... freq[j]
        int fsum = sum(freq, i, j);
        int minCost = int.MaxValue;

        // One by one consider all elements
        // as root and recursively find cost
        // of the BST
        for (int r = i; r <= j; r++) {
            int cost = optCost(freq, i, r - 1, dp) + optCost(freq, r + 1, j, dp);
            if (cost < minCost)
                minCost = cost;
        }

        // Return minimum value
        return dp[i, j] = minCost + fsum;
    }

    // The main function that calculates
    // minimum cost of a Binary Search Tree.
    static int minCost(int[] keys, int[] freq) {
        int n = keys.Length;
        int[,] dp = new int[n, n];
        for (int x = 0; x < n; x++)
            for (int y = 0; y < n; y++)
                dp[x, y] = -1;
        return optCost(freq, 0, n - 1, dp);
    }

//Driver Code Starts

    static void Main() {
        int[] keys = {10, 12, 20};
        int[] freq = {34, 8, 50};
        Console.WriteLine(minCost(keys, freq));
    }
}

//Driver Code Ends
JavaScript 
// function to get sum of
// array elements freq[i] to freq[j]
function sum(freq, i, j) {
    let s = 0;
    for (let k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// A recursive function to calculate
// cost of optimal binary search tree
function optCost(freq, i, j, dp) {

    // Base cases
    if (j < i) return 0;
    if (j === i) return freq[i];

    if (dp[i][j] !== -1) return dp[i][j];

    // Get sum of freq[i], freq[i+1], ... freq[j]
    let fsum = sum(freq, i, j);
    let minCost = Number.MAX_SAFE_INTEGER;

    // One by one consider all elements
    // as root and recursively find cost
    // of the BST
    for (let r = i; r <= j; r++) {
        let cost = optCost(freq, i, r-1, dp) + optCost(freq, r+1, j, dp);
        if (cost < minCost)
            minCost = cost;
    }

    // Return minimum value
    dp[i][j] = minCost + fsum;
    return dp[i][j];
}

// The main function that calculates
// minimum cost of a Binary Search Tree.
function minCost(keys, freq) {
    const n = keys.length;
    const dp = Array.from({length: n}, () => Array(n).fill(-1));
    return optCost(freq, 0, n-1, dp);
}


//Driver Code Starts
//Driver Code
const keys = [10, 12, 20];
const freq = [34, 8, 50];
console.log(minCost(keys, freq));

//Driver Code Ends

Output
142

[Expected Approach 2] Using Bottom - Up Dp (Tabulation) - O(n^3) Time and O(n^2) Space

In the tabulation approach, we solve the problem step by step instead of recursion.

We make a table dp[i][j] where each cell stores the minimum cost of a BST for keys from index i to j. The base case is simple: if there is only one key, the cost is just its frequency. Then, we fill the table for bigger ranges of keys. For each range, we try every key as the root, calculate the cost of the left and right parts using the table, and add the sum of frequencies for that range. We keep the minimum cost in the table. At the end, dp[0][n-1] gives the minimum cost of the BST for all keys.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
using namespace std;

//Driver Code Ends

// Function to calculate sum of frequencies from index i to j
int sum(vector<int> &freq, int i, int j) {
    int s = 0;
    for (int k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// Function to calculate minimum cost of a Binary Search Tree using DP (tabulation)
int minCost(vector<int> &keys, vector<int> &freq) {

    int n = keys.size();

    // Create a 2D DP table to store minimum costs for subarrays of keys
    vector<vector<int>> dp(n, vector<int>(n, 0));

    // Base case: cost of a single key is its frequency
    for (int i = 0; i < n; i++) {
        dp[i][i] = freq[i];
    }

    // Consider chains of length 2 to n
    for (int l = 2; l <= n; l++) {

        for (int i = 0; i <= n - l; i++) {

            // j is the ending index of the chain
            int j = i + l - 1;
            dp[i][j] = INT_MAX;

            // Total frequency sum of keys in current range
            int fsum = sum(freq, i, j);

            // Try each key in range [i..j] as root
            for (int r = i; r <= j; r++) {

                // Cost when keys[r] is root:
                // cost of left subtree + cost of right subtree + sum of frequencies
                int c = ((r > i) ? dp[i][r - 1] : 0) + ((r < j) ? dp[r + 1][j] : 0) + fsum;

                // Update minimum cost
                if (c < dp[i][j]) {
                    dp[i][j] = c;
                }
            }
        }
    }

    // dp[0][n-1] stores minimum cost for all keys
    return dp[0][n - 1];
}

//Driver Code Starts

int main() {

    vector<int> keys = {10, 12, 20};
    vector<int> freq = {34, 8, 50};

    cout << minCost(keys, freq);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
import java.util.Arrays;

public class GFG {

//Driver Code Ends

    // Function to calculate sum of frequencies from index i to j
    static int sum(int freq[], int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // Function to calculate minimum cost of a Binary Search Tree using DP (tabulation)
    static int minCost(int keys[], int freq[]) {
        int n = keys.length;

        // Create a 2D DP table to store minimum costs for subarrays of keys
        int dp[][] = new int[n][n];

        // Base case: cost of a single key is its frequency
        for (int i = 0; i < n; i++)
            dp[i][i] = freq[i];

        // Consider chains of length 2 to n
        for (int l = 2; l <= n; l++) {
            for (int i = 0; i <= n - l; i++) {

                // j is the ending index of the chain
                int j = i + l - 1;
                dp[i][j] = Integer.MAX_VALUE;

                // Total frequency sum of keys in current range
                int fsum = sum(freq, i, j);

                // Try each key in range [i..j] as root
                for (int r = i; r <= j; r++) {

                    // Cost when keys[r] is root:
                    // cost of left subtree + cost of right subtree + sum of frequencies
                    int c = ((r > i) ? dp[i][r - 1] : 0) + ((r < j) ? dp[r + 1][j] : 0) + fsum;

                    // Update minimum cost
                    if (c < dp[i][j])
                        dp[i][j] = c;
                }
            }
        }

        // dp[0][n-1] stores minimum cost for all keys
        return dp[0][n - 1];
    }

//Driver Code Starts

    public static void main(String[] args) {
        int keys[] = {10, 12, 20};
        int freq[] = {34, 8, 50};

        System.out.println(minCost(keys, freq));
    }
}

//Driver Code Ends
Python 
# Function to calculate sum of frequencies from index i to j
def sum(freq, i, j):
    s = 0
    for k in range(i, j + 1):
        s += freq[k]
    return s

# Function to calculate minimum cost of a Binary Search Tree using DP (tabulation)
def minCost(keys, freq):
    n = len(keys)

    # Create a 2D DP table to store minimum costs for subarrays of keys
    dp = [[0 for _ in range(n)] for _ in range(n)]

    # Base case: cost of a single key is its frequency
    for i in range(n):
        dp[i][i] = freq[i]

    # Consider chains of length 2 to n
    for l in range(2, n + 1):
        for i in range(0, n - l + 1):

            # j is the ending index of the chain
            j = i + l - 1
            dp[i][j] = float('inf')

            # Total frequency sum of keys in current range
            fsum = sum(freq, i, j)

            # Try each key in range [i..j] as root
            for r in range(i, j + 1):

                # Cost when keys[r] is root:
                # cost of left subtree + cost of right subtree + sum of frequencies
                c = (dp[i][r - 1] if r > i else 0) + (dp[r + 1][j] if r < j else 0) + fsum

                # Update minimum cost
                if c < dp[i][j]:
                    dp[i][j] = c

    # dp[0][n-1] stores minimum cost for all keys
    return dp[0][n - 1]


#Driver Code Starts

if __name__ == '__main__':
    keys = [10, 12, 20]
    freq = [34, 8, 50]
    
    print(minCost(keys, freq))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {

//Driver Code Ends

    // Function to calculate sum of frequencies from index i to j
    static int sum(int[] freq, int i, int j) {
        int s = 0;
        for (int k = i; k <= j; k++)
            s += freq[k];
        return s;
    }

    // Function to calculate minimum cost of a Binary Search Tree using DP (tabulation)
    static int minCost(int[] keys, int[] freq) {
        int n = keys.Length;

        // Create a 2D DP table to store minimum costs for subarrays of keys
        int[,] dp = new int[n, n];

        // Base case: cost of a single key is its frequency
        for (int i = 0; i < n; i++)
            dp[i, i] = freq[i];

        // Consider chains of length 2 to n
        for (int l = 2; l <= n; l++) {
            for (int i = 0; i <= n - l; i++) {

                // j is the ending index of the chain
                int j = i + l - 1;
                dp[i, j] = int.MaxValue;

                // Total frequency sum of keys in current range
                int fsum = sum(freq, i, j);

                // Try each key in range [i..j] as root
                for (int r = i; r <= j; r++) {

                    // Cost when keys[r] is root:
                    // cost of left subtree + cost of right subtree + sum of frequencies
                    int c = ((r > i) ? dp[i, r - 1] : 0) + ((r < j) ? dp[r + 1, j] : 0) + fsum;

                    // Update minimum cost
                    if (c < dp[i, j])
                        dp[i, j] = c;
                }
            }
        }

        // dp[0,n-1] stores minimum cost for all keys
        return dp[0, n - 1];
    }

//Driver Code Starts

    static void Main() {
        int[] keys = {10, 12, 20};
        int[] freq = {34, 8, 50};

        Console.WriteLine(minCost(keys, freq));
    }
}

//Driver Code Ends
JavaScript 
// Function to calculate sum of frequencies from index i to j
function sum(freq, i, j) {
    let s = 0;
    for (let k = i; k <= j; k++)
        s += freq[k];
    return s;
}

// Function to calculate minimum cost of a Binary Search Tree using DP (tabulation)
function minCost(keys, freq) {
    const n = keys.length;

    // Create a 2D DP table to store minimum costs for subarrays of keys
    const dp = Array.from({length: n}, () => Array(n).fill(0));

    // Base case: cost of a single key is its frequency
    for (let i = 0; i < n; i++)
        dp[i][i] = freq[i];

    // Consider chains of length 2 to n
    for (let l = 2; l <= n; l++) {
        for (let i = 0; i <= n - l; i++) {

            // j is the ending index of the chain
            const j = i + l - 1;
            dp[i][j] = Number.MAX_SAFE_INTEGER;

            // Total frequency sum of keys in current range
            const fsum = sum(freq, i, j);

            // Try each key in range [i..j] as root
            for (let r = i; r <= j; r++) {

                // Cost when keys[r] is root:
                // cost of left subtree + cost of right subtree + sum of frequencies
                const c = (r > i ? dp[i][r - 1] : 0) + (r < j ? dp[r + 1][j] : 0) + fsum;

                // Update minimum cost
                if (c < dp[i][j])
                    dp[i][j] = c;
            }
        }
    }

    // dp[0][n-1] stores minimum cost for all keys
    return dp[0][n - 1];
}


//Driver Code Starts
// Driver code
const keys = [10, 12, 20];
const freq = [34, 8, 50];
console.log(minCost(keys, freq));

//Driver Code Ends

Output
142
Comment

Explore