Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Number of Unique BST with a given key | Dynamic Programming

  • Difficulty Level : Medium
  • Last Updated : 22 Jan, 2022

Given N, Find the total number of unique BSTs that can be made using values from 1 to N. 
Examples: 
 

Input: n = 3 
Output: 5
For n = 3, preorder traversal of Unique BSTs are:
1. 1 2 3
2. 1 3 2
3. 2 1 3
4. 3 1 2
5. 3 2 1

Input: 4 
Output: 14

 

In the previous post a O(n) solution has been discussed. In this post we will discuss a solution based on Dynamic Programming. For all possible values of i, consider i as root, then [1….i-1] numbers will fall in the left subtree and [i+1….n] numbers will fall in the right subtree. So, add (i-1)*(n-i) to the answer. The summation of the products will be the answer to the number of unique BST. 
Below is the implementation for above approach: 
 

C++




// C++ code to find number of unique BSTs
// Dynamic Programming solution
#include <bits/stdc++.h>
using namespace std;
 
// Function to find number of unique BST
int numberOfBST(int n)
{
 
    // DP to store the number of unique BST with key i
    int dp[n + 1];
    fill_n(dp, n + 1, 0);
 
    // Base case
    dp[0] = 1;
    dp[1] = 1;
 
    // fill the dp table in bottom-up approach.
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
 
            // n-i in right * i-1 in left
            dp[i] = dp[i] + (dp[i - j] * dp[j - 1]);
        }
    }
 
    return dp[n];
}
 
// Driver Code
int main()
{
    int n = 3;
    cout << "Number of structurally Unique BST with " <<
    n << " keys are : " << numberOfBST(n) << "\n";
 
    return 0;
}

Java




// Java code to find number
// of unique BSTs Dynamic
// Programming solution
import java.io.*;
import java.util.Arrays;
 
class GFG
{
    static int numberOfBST(int n)
    {
 
    // DP to store the number
    // of unique BST with key i
    int dp[] = new int[n + 1];
    Arrays.fill(dp, 0);
 
    // Base case
    dp[0] = 1;
    dp[1] = 1;
 
    // fill the dp table in
    // top-down approach.
    for (int i = 2; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
 
            // n-i in right * i-1 in left
            dp[i] = dp[i] + (dp[i - j] *
                             dp[j - 1]);
        }
    }
 
    return dp[n];
}
 
// Driver Code
public static void main (String[] args)
{
    int n = 3;
    System.out.println("Number of structurally " +
                           "Unique BST with "+ n +
                                  " keys are : " +
                                  numberOfBST(n));
}
}
 
// This code is contributed
// by shiv_bhakt.

Python3




# Python3 code to find number of unique
# BSTs Dynamic Programming solution
 
# Function to find number of unique BST
def numberOfBST(n):
 
    # DP to store the number of unique
    # BST with key i
    dp = [0] * (n + 1)
 
    # Base case
    dp[0], dp[1] = 1, 1
 
    # fill the dp table in top-down
    # approach.
    for i in range(2, n + 1):
        for j in range(1, i + 1):
 
            # n-i in right * i-1 in left
            dp[i] = dp[i] + (dp[i - j] *
                             dp[j - 1])
 
    return dp[n]
 
# Driver Code
if __name__ == "__main__":
 
    n = 3
    print("Number of structurally Unique BST with",
                   n, "keys are :", numberOfBST(n))
 
# This code is contributed
# by Rituraj Jain

C#




// C# code to find number
// of unique BSTs Dynamic
// Programming solution
using System;
 
class GFG
{
    static int numberOfBST(int n)
    {
 
    // DP to store the number
    // of unique BST with key i
    int []dp = new int[n + 1];
     
    // Base case
    dp[0] = 1;
    dp[1] = 1;
 
    // fill the dp table in
    // top-down approach.
    for (int i = 2; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
 
            // n-i in right * i-1 in left
            dp[i] = dp[i] + (dp[i - j] *
                             dp[j - 1]);
        }
    }
    return dp[n];
}
 
// Driver Code
public static void Main ()
{
    int n = 3;
    Console.Write("Number of structurally " +
                      "Unique BST with "+ n +
                             " keys are : " +
                             numberOfBST(n));
}
}
 
// This code is contributed
// by shiv_bhakt.

PHP




<?php
// PHP code to find number
// of unique BSTs Dynamic
// Programming solution
 
// Function to find number
// of unique BST
function numberOfBST($n)
{
 
    // DP to store the number
    // of unique BST with key i
    $dp = array($n + 1);
    for($i = 0; $i <= $n + 1; $i++)
    $dp[$i] = 0;
 
    // Base case
    $dp[0] = 1;
    $dp[1] = 1;
 
    // fill the dp table
    // in top-down approach.
    for ($i = 2; $i <= $n; $i++)
    {
        for ($j = 1; $j <= $i; $j++)
        {
 
            // n-i in right *
            // i-1 in left
            $dp[$i] += (($dp[$i - $j]) *
                        ($dp[$j - 1]));
        }
    }
 
    return $dp[$n];
}
 
// Driver Code
$n = 3;
echo "Number of structurally ".
           "Unique BST with " ,
          $n , " keys are : " ,
              numberOfBST($n) ;
 
// This code is contributed
// by shiv_bhakt.
?>
Output: 
Number of structurally Unique BST with 3 keys are : 5

 

Time Complexity: O(n2
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!