Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Count of BSTs with N nodes having height at least K

  • Last Updated : 20 Jul, 2021

Given two positive integers N and K, the task is to find the number of binary search trees (BST) with N nodes of height greater than or equal to K.

Note: Here height refers to the maximum depth of the BST.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:



Input: N = 3, K = 3
Output: 4
Explanation:
There are 4 possible binary search trees with height greater than or equal to K.

1                   1                        3                      3                                     
 \                    \                       /                     /
  2                   3                   2                     1
   \                   |                   /                        \ 
    3               2                  1                          2

Input: N = 4, K = 2
Output: 14

Approach: This problem can be solved using recursion. Follow the steps below to solve the problem:

  • Base Case: if N is equal to 1 then return 1.
  • Initialize a variable countBsts as 0 to store the number of valid BSTs.
  • Iterate in the range [1, N] using the variable i:
    • If i-1 and N-i is greater than equal to K, then:
      • Recursively call the function for left subtree, with nodes as i – 1 and height as K – 1 which will find the number of ways to create left subtree.
      • Recursively call the function for right subtree with nodes as N – i and height as K – 1 which will find the number of ways to create right subtree.
    • Add the result in countBsts.
  • After completing the above steps, print the countBsts.

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the number of BST's
// with N nodes of height greater than
// or equal to K
int numOfBst(int n, int k)
{
 
    if (n <= 1) {
        return 1;
    }
 
    // Store number of valid BSTs
    int countBsts = 0;
 
    // Traverse from 1 to n
    for (int i = 1; i <= n; i++) {
        // If Binary Tree with height greater
        // than K exist
        if (i - 1 >= k or n - i >= k)
            countBsts
 += numOfBst(i - 1, k - 1)
 * numOfBst(n - i, k - 1);
    }
 
    // Finally, return the countBsts
    return countBsts;
}
// Driver Code
int main()
{
 
    // Given Input
    int n = 4;
    int k = 2;
 
    // Function call to find the number
    // of BSTs greater than k
    cout << numOfBst(n, k - 1) << endl;
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
 
class GFG
{
 
  // Function to find the number of BST's
  // with N nodes of height greater than
  // or equal to K
  static int numOfBst(int n, int k)
  {
 
    if (n <= 1) {
      return 1;
    }
 
    // Store number of valid BSTs
    int countBsts = 0;
 
    // Traverse from 1 to n
    for (int i = 1; i <= n; i++)
    {
 
      // If Binary Tree with height greater
      // than K exist
      if (i - 1 >= k || n - i >= k)
        countBsts += numOfBst(i - 1, k - 1)
        * numOfBst(n - i, k - 1);
    }
 
    // Finally, return the countBsts
    return countBsts;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    // Given Input
    int n = 4;
    int k = 2;
 
    // Function call to find the number
    // of BSTs greater than k
    System.out.println(numOfBst(n, k - 1));
 
  }
}
 
// This code is contributed by potta lokesh.

Python3




# python 3 program for the above approach
 
# Function to find the number of BST's
# with N nodes of height greater than
# or equal to K
def numOfBst(n, k):
    if (n <= 1):
        return 1
 
    # Store number of valid BSTs
    countBsts = 0
 
    # Traverse from 1 to n
    for i in range(1, n + 1, 1):
       
        # If Binary Tree with height greater
        # than K exist
        if (i - 1 >= k or n - i >= k):
            countBsts += numOfBst(i - 1, k - 1) * numOfBst(n - i, k - 1)
 
    # Finally, return the countBsts
    return countBsts
 
# Driver Code
if __name__ == '__main__':
    # Given Input
    n = 4
    k = 2
 
    # Function call to find the number
    # of BSTs greater than k
    print(numOfBst(n, k - 1))
 
    # This code is contributed by bgangwar59.

C#




// C# program for the above approach
using System;
class GFG {
     
  // Function to find the number of BST's
  // with N nodes of height greater than
  // or equal to K
  static int numOfBst(int n, int k)
  {
  
    if (n <= 1) {
      return 1;
    }
  
    // Store number of valid BSTs
    int countBsts = 0;
  
    // Traverse from 1 to n
    for (int i = 1; i <= n; i++)
    {
  
      // If Binary Tree with height greater
      // than K exist
      if (i - 1 >= k || n - i >= k)
        countBsts += numOfBst(i - 1, k - 1)
        * numOfBst(n - i, k - 1);
    }
  
    // Finally, return the countBsts
    return countBsts;
  }
   
  // Driver code
  static void Main()
  {
     
    // Given Input
    int n = 4;
    int k = 2;
  
    // Function call to find the number
    // of BSTs greater than k
    Console.WriteLine(numOfBst(n, k - 1));
  }
}
 
// This code is contributed by divyeshrabadiya07.

Javascript




<script>
        // JavaScript program for the above approach
 
 
        // Function to find the number of BST's
        // with N nodes of height greater than
        // or equal to K
        function numOfBst(n, k) {
 
            if (n <= 1) {
                return 1;
            }
 
            // Store number of valid BSTs
            let countBsts = 0;
 
            // Traverse from 1 to n
            for (let i = 1; i <= n; i++) {
                // If Binary Tree with height greater
                // than K exist
                if (i - 1 >= k || n - i >= k)
                    countBsts
                        += numOfBst(i - 1, k - 1)
                        * numOfBst(n - i, k - 1);
            }
 
            // Finally, return the countBsts
            return countBsts;
        }
        // Driver Code
 
 
        // Given Input
        let n = 4;
        let k = 2;
 
        // Function call to find the number
        // of BSTs greater than k
        document.write(numOfBst(n, k - 1) + "<br>");
 
    // This code is contributed by Potta Lokesh
 
    </script>
Output: 
14

 

Time Complexity: O(2n)
Auxiliary Space: O(1)




My Personal Notes arrow_drop_up
Recommended Articles
Page :