Given a height h, count and return the maximum number of balanced binary trees possible with height h. A balanced binary tree is one in which for every node, the difference between heights of left and right subtree is not more than 1.

**Examples :**

Input : h = 3 Output : 15 Input : h = 4 Output : 315

Following are the balanced binary trees of height 3.

Height of tree, h = 1 + max(left height, right height)

Since the difference between the heights of left and right subtree is not more than one, possible heights of left and right part can be one of the following:

- (h-1), (h-2)
- (h-2), (h-1)
- (h-1), (h-1)

count(h) = count(h-1) * count(h-2) + count(h-2) * count(h-1) + count(h-1) * count(h-1) = 2 * count(h-1) * count(h-2) + count(h-1) * count(h-1) = count(h-1) * (2*count(h - 2) + count(h - 1))

Hence we can see that the problem has optimal substructure property.

A **recursive function** to count no of balanced binary trees of height h is:

int countBT(int h) { // One tree is possible with height 0 or 1 if (h == 0 || h == 1) return 1; return countBT(h-1) * (2 *countBT(h-2) + countBT(h-1)); }

The time complexity of this recursive approach will be exponential. The recursion tree for the problem with h = 3 looks like :

As we can see, sub-problems are solved repeatedly. Therefore we store the results as we compute them.

An efficient dynamic programming approach will be as follows :

## CPP

`// C++ program to count number of balanced ` `// binary trees of height h. ` `#include <bits/stdc++.h> ` `#define mod 1000000007 ` `using` `namespace` `std; ` ` ` `long` `long` `int` `countBT(` `int` `h) { ` ` ` ` ` `long` `long` `int` `dp[h + 1]; ` ` ` `//base cases ` ` ` `dp[0] = dp[1] = 1; ` ` ` `for` `(` `int` `i = 2; i <= h; i++) { ` ` ` `dp[i] = (dp[i - 1] * ((2 * dp [i - 2])%mod + dp[i - 1])%mod) % mod; ` ` ` `} ` ` ` `return` `dp[h]; ` `} ` ` ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `h = 3; ` ` ` `cout << ` `"No. of balanced binary trees"` ` ` `" of height h is: "` ` ` `<< countBT(h) << endl; ` `} ` |

## PHP

`<?php ` `// PHP program to count ` `// number of balanced ` ` ` `$mod` `=1000000007; ` ` ` `function` `countBT(` `$h` `) ` `{ ` ` ` `global` `$mod` `; ` ` ` ` ` `// base cases ` ` ` `$dp` `[0] = ` `$dp` `[1] = 1; ` ` ` `for` `(` `$i` `= 2; ` `$i` `<= ` `$h` `; ` `$i` `++) ` ` ` `{ ` ` ` `$dp` `[` `$i` `] = (` `$dp` `[` `$i` `- 1] * ` ` ` `((2 * ` `$dp` `[` `$i` `- 2]) % ` ` ` `$mod` `+ ` `$dp` `[` `$i` `- 1]) % ` ` ` `$mod` `) % ` `$mod` `; ` ` ` `} ` ` ` `return` `$dp` `[` `$h` `]; ` `} ` ` ` ` ` `// Driver Code ` `$h` `= 3; ` `echo` `"No. of balanced binary trees"` `, ` ` ` `" of height h is: "` `, ` ` ` `countBT(` `$h` `) ,` `"\n"` `; ` ` ` ` ` `// This code is contributed by aj_36 ` `?> ` |

**Output :**

No of balanced binary trees of height h is: 15

This article is contributed by **Aditi Sharma**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Counting pairs when a person can form pair with at most one
- Count ways to build street under given constraints
- Choose maximum weight with given weight and value ratio
- Print path from root to a given node in a binary tree
- Minimum time to write characters using insert, delete and copy operation
- Splay Tree | Set 3 (Delete)
- Counts paths from a point to reach Origin
- Iterative method to check if two trees are mirror of each other
- Sum of all substrings of a string representing a number | Set 1
- Check if a given array can represent Preorder Traversal of Binary Search Tree
- Count number of ways to cover a distance
- Count number of ways to reach a given score in a game
- Find distance between two nodes of a Binary Tree
- Total number of possible Binary Search Trees and Binary Trees with n keys
- How to determine if a binary tree is height-balanced?