# Optimal binary search tree in DSA

### Implementation

```
// A simple way of the recursive implementation of the optimal search that we will perform on the binary tree.
#include <bits/stdc++.h>
using namespace std;
// we have to create a basic utility function to help us get the sum of both the frequencies present.
int sm(int frequency[], int g, int k);
// creating a function that is recursive and also a function that will help us in estimating the cost of the optimal binary search tree.
int optimal__Cost(int frequency[], int g, int k)
{
if (k < g)
// this subarray is empty, which implies it doesn't contain any elements in them.
return 0;
if (k == g) // this subarray contains one type of element.
return frequency[g];
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int fsm = sm(frequency, g, k);
// we have to initialize the latest minimal value and see where it goes:-
int minimum= INT__MAX;
// start considering all the elements present but one by one
// then we have to find the cost of the root and recursive
// present in the BST and then compare this cost with the
// minimum val and then update if required.
for (int r = g; r <= k; ++r)
{
int cost = optimal__Cost(frequency, i, r - 1) +
optimal__Cost(frequency, r + 1, j);
if (cost < min)
minimum= cost;
}
// Return minimum value
return minimum+ fsm;
}
// now create the main function that will calculate the minimum cost of a particular binary tree, and it will possibly only use the optimal__Cost() function to find the optimal cost of the binary search tree.
int optimal search tree(int kys[],
int frequency[], int n)
{
// given the array keys here are presumed to be aligned, which will be in increasing order. If the keys are not aligned, then we have to technically add a code to solve and arrange the keys and refigure the frequency of the same accordingly.
return optimal__Cost(frequency, 0, n - 1);
}
//creating a utility function that will help us get the sum of the elements of the array and the frequency of the gth and kth elements.
int sm(int frequency[], int g, int k)
{
int s = 0;
for (int k = g; k <= h; k++)
s += frequency[k];
return s;
}
// writing the main code.
int main()
{
int kys[] = {10, 12, 20};
int frequency[] = {34, 8, 50};
int n = sizeof(kys) / sizeof(kys[0]);
cout << "Cost of Optimal BST is "
<< optimalSearchTree(kys, frequency, n);
return 0;
}
```

**Output:**

**Example 2)**

```
// A simple way of the recursive implementation of the optimal search that we will perform on the binary tree.
#include <bits/stdc++.h>
using namespace std;
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int sm(int frequency[], int g, int k);
// creating a function that is recursive and also a function that will help us in estimating the cost of the optimal binary search tree.
int optimalSearchTree(int kys[], int frequency[], int n)
{
int cost[n][n];
/* cost[i][j] = Optimal cost of binary search tree
that can be formed from kys[i] to kys[j].
cost[0][n-1] will store the resultant cost */
// if we are calculating the cost for a single key, then the frequency can be calculated by: -
for (int g = 0; g < n; g++)
cost[g][g] = frequency[g];
// we will now see whether we can see the chains of the length or not, which is 2, 3…
for (int L = 2; L <= n; L++)
{
// g is considered as the row number in cost[][]
for (int g = 0; i <= n-L+1; i++)
{
// we have to get the column number h from the row number g
// chain length L
int k = g+L-1;
cost[g][h] = INT__MAX;
int off_set_sm = sm(frequency, i, j);
// we have to try and convert all the keys present as root.
for (int r = i; r <= j; r++)
{
// c is generally the cost of the tree when keys are the root of this subtree.
int c = ((r > i)? cost[i][r-1]:0) +
((r < j)? cost[r+1][j]:0) +
off_set_sm;
if (c < cost[i][j])
cost[i][j] = c;
}
}
}
return cost[0][n-1];
}
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int sm(int frequency[], int g, int k)
{
int s = 0;
for (int k = i; k <= j; k++)
s += frequency[k];
return s;
}
// writing the main code.
int main()
{
int kys[] = {10, 12, 20};
int frequency[] = {34, 8, 50};
int n = sizeof(kys)/sizeof(kys[0]);
cout << "Cost of Optimal BST is " << optimalSearchTree(kys, frequency, n);
return 0;
}
```

**Output:**

**Example 3)**

```
//creating a utility function that will help us get the sum of the elements of the array and the frequency of the gth and kth elements.
int sm(int frequency[], int g, int k);
// creating a function that is recursive and also a function that will help us in estimating the cost of the optimal binary search tree.
int optimal search tree(int kys[], int frequency[], int n)
#include <stdio.h>
#include <limits.h>
//creating a 2D matrix will help us store all the essential problems.
int cost[n][n];
/* cost[i][j] = Optimal cost of binary search tree
that can be formed from kys[i] to kys[j].
cost[0][n-1] will store the resultant cost */
// if we are calculating the cost for a single key, then the frequency can be calculated by: -
for (int g = 0; i < n; i++)
cost[i][i] = frequency[i];
// we will now see whether we can see the chains of the length or not, which is 2, 3…
// L is chain length.
for (int L=2; L<=n; L++)
{
// g is row number in cost[][]
for (int g=0; i<=n-L+1; i++)
{
// we have to get the column number h from the row number g
// chain length L
int k = i+L-1;
int off_set_sm = sm(frequency, i, j);
cost[i][j] = INT__MAX;
// we have to try and convert all the keys present as root.
for (int r=i; r<=j; r++)
{
// c is generally the cost of the tree when keys are the root of this subtree.
int c = ((r > i)? cost[i][r-1]:0) +
((r < j)? cost[r+1][j]:0) +
off_set_sm;
if (c < cost[i][j])
cost[i][j] = c;
}
}
}
return cost[0][n-1];
}
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int sm(int frequency[], int g, int k)
{
int s = 0;
for (int k = i; k <=j; k++)
s += frequency[k];
return s;
}
// Driver program to test the above functions
int main()
{
int kys[] = {10, 12, 20};
int frequency[] = {34, 8, 50};
int n = sizeof(kys)/sizeof(kys[0]);
printf("Cost of Optimal BST is %d ",
optimalSearchTree(kys, frequency, n));
return 0;
}
```

**Output:**

**Example 4)**

```
// A simple way of the recursive implementation of the optimal search that we will perform on the binary tree.
#include <stdio.h>
#include <limits.h>
// creating a function that is recursive and also a function that will help us in estimating the cost of the optimal binary search tree.
int sm(int frequency[], int g, int k);
int optimal__Cost(int frequency[], int g, int k)
{
If (j < i) //, this subarray is empty, which implies it doesn't contain any elements in them.
return 0;
if (j == i) // this subarray contains one type of element.
return frequency[i];
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int fsm = sm(frequency, i, j);
// Initialize minimum value
int minimum= INT__MAX;
// we have to initialize the latest minimal value and see where it goes:-
// start considering all the elements present but one by one
// then we have to find the cost of the root and recursive
// present in the BST and then compare this cost with the
// minimum val and then update if required.
for (int r = i; r <= j; ++r)
{
int cost = optimal__Cost(frequency, i, r-1) +
optimal__Cost(frequency, r+1, j);
if (cost < min)
minimum= cost;
}
// Return minimum value
return minimum+ fsm;
}
// now create the main function that will calculate the minimum cost of a particular binary tree, and it will possibly only use the optimal__Cost() function to find the optimal cost of the binary search tree.
int optimalSearchTree(int kys[], int frequency[], int n)
{
// given the array keys here are presumed to be aligned, which will be in increasing order. If the keys are not aligned, then we have to technically add a code to solve and arrange the keys and refigure the frequency of the same accordingly.
return optimal__Cost(frequency, 0, n-1);
}
//creating a utility function that will help us get the sum of the elements of the array and the frequency of the gth and kth elements.
int sm(int frequency[], int g, int k)
{
int s = 0;
for (int k = i; k <=j; k++)
s += frequency[k];
return s;
}
// Driver program to test the above functions
int main()
{
int kys[] = {10, 12, 20};
int frequency[] = {34, 8, 50};
int n = sizeof(kys)/sizeof(kys[0]);
printf("Cost of Optimal BST is %d ",
optimalSearchTree(kys, frequency, n));
return 0;
}
```

**Output:**

**Example 5)**

```
// A simple way of the recursive implementation of the optimal search that we will perform on the binary tree.
public class TFM
{
// creating a function that is recursive and also a function that will help us in estimating the cost of the optimal binary search tree.
static int optimal__Cost(int frequency[], int g, int k)
{
If (j < i) //, this subarray is empty, which implies it doesn't contain any elements in them.
return 0;
if (j == i) // this subarray contains one type of element.
return frequency[i];
// in this subarray we have to get the sum of the following frequencies:- frequency[g], frequency [g+1], frequency[k].
int fsm = sm(frequency, i, j);
// we have to initialize the latest minimal value and see where it goes:-
int minimum= Integer.MAX_VALUE;
// start considering all the elements present but one by one
// then we have to find the cost of the root and recursive
// present in the BST and then compare this cost with the
// minimum val and then update if required.
for (int r = i; r <= j; ++r)
{
int cost = optimal__Cost(frequency, i, r-1) +
optimal__Cost(frequency, r+1, j);
if (cost < min)
minimum= cost;
}
// Return minimum value
return minimum+ fsm;
}
// now create the main function that will calculate the minimum cost of a particular binary tree, and it will possibly only use the optimal__Cost() function to find the optimal cost of the binary search tree.
static int optimalSearchTree(int kys[], int frequency[], int n)
{
// given the array keys here are presumed to be aligned, which will be in increasing order. If the keys are not aligned, then we have to technically add a code to solve and arrange the keys and refigure the frequency of the same accordingly.
return optimal__Cost(frequency, 0, n-1);
}
//creating a utility function that will help us get the sum of the elements of the array and the frequency of the gth and kth elements.
static int sm(int frequency[], int g, int k)
{
int s = 0;
for (int k = i; k <=j; k++)
s += frequency[k];
return s;
}
// writing the main code.
public static void main(String[] args) {
int kys[] = {10, 12, 20};
int frequency[] = {34, 8, 50};
int n = kys.length;
System.out.println("Cost of Optimal BST is " +
optimalSearchTree(kys, frequency, n));
}
}
```

**Output:**