Related Articles
Number of Unique BST with a given key | Dynamic Programming
• Difficulty Level : Medium
• Last Updated : 05 Mar, 2019

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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ``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 = 1;``    ``dp = 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``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 = 1;``    ``dp = 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

 ``
Output:
```Number of structurally Unique BST with 3 keys are : 5
```

Time Complexity: O(n2)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up