C/C++ Program for nth Catalan Number

Catalan numbers are defined as a mathematical sequence that consists of positive integers, which can be used to find the number of possibilities of various combinations. 

The nth term in the sequence denoted C_n, is found in the following formula: 

The first few Catalan numbers for n = 0, 1, 2, 3, … are : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, … 

Catalan numbers occur in many interesting counting problems like the following.

1. Count the number of expressions containing n pairs of parentheses that are correctly matched. For n = 3, possible expressions are ((())), ()(()), ()()(), (())(), (()()).
2. Count the number of possible Binary Search Trees with n keys (See this)
3. Count the number of full binary trees (A rooted binary tree is full if every vertex has either two children or no children) with n+1 leaves.
4. Given a number n, return the number of ways you can draw n chords in a circle with 2 x n points such that no 2 chords intersect.

Examples:

Input: n = 6
Output: 132

Input: n = 8
Output: 1430

C/C++ Program for nth Catalan Number using Recursive Solution:

Catalan numbers satisfy the following recursive formula: 

Follow the steps below to implement the above recursive formula

• Base condition for the recursive approach, when n <= 1, return 1
• Iterate from i = 0 to i < n
  • Make a recursive call catalan(i) and catalan(n – i – 1) and keep adding the product of both into res.
• Return the res.

Below is the implementation of the above approach:

C++

#include <iostream>
using namespace std;

// A recursive function to find nth catalan number
unsigned long int catalan(unsigned int n)
{
    // Base case
    if (n <= 1)
        return 1;

    // catalan(n) is sum of
    // catalan(i)*catalan(n-i-1)
    unsigned long int res = 0;
    for (int i = 0; i < n; i++)
        res += catalan(i) * catalan(n - i - 1);

    return res;
}

// Driver code
int main()
{
    for (int i = 0; i < 10; i++)
        cout << catalan(i) << " ";
    return 0;
}

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: The above implementation is equivalent to nth Catalan number. 

The value of nth Catalan number is exponential which makes the time complexity exponential.
Auxiliary Space: O(n)

C/C++ Program for nth Catalan Number using Dynamic Programming:

We can observe that the above recursive implementation does a lot of repeated work. Since there are overlapping subproblems, we can use dynamic programming for this.

Below is the implementation of the above idea:

• Create an array catalan[] for storing ith Catalan number.
• Initialize, catalan[0] and catalan[1] = 1
• Loop through i = 2 to the given Catalan number n.
  • Loop through j = 0 to j < i and Keep adding value of catalan[j] * catalan[i – j – 1] into catalan[i].
• Finally, return catalan[n]

Below is the implementation of the above approach:

C++

#include <iostream>
using namespace std;

// A dynamic programming based function to find nth
// Catalan number
unsigned long int catalanDP(unsigned int n)
{
    // Table to store results of subproblems
    unsigned long int catalan[n + 1];

    // Initialize first two values in table
    catalan[0] = catalan[1] = 1;

    // Fill entries in catalan[] using recursive formula
    for (int i = 2; i <= n; i++) {
        catalan[i] = 0;
        for (int j = 0; j < i; j++)
            catalan[i] += catalan[j] * catalan[i - j - 1];
    }

    // Return last entry
    return catalan[n];
}

// Driver code
int main()
{
    for (int i = 0; i < 10; i++)
        cout << catalanDP(i) << " ";
    return 0;
}

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: O(n²)
Auxiliary Space: O(n)

C/C++ Program for nth Catalan Number using Binomial Coefficient:

We can also use the below formula to find nth Catalan number in O(n) time.

Below are the steps for calculating nC_r.

• Create a variable to store the answer and change r to n – r if r is greater than n – r because we know that C(n, r) = C(n, n-r) if r > n – r 
• Run a loop from 0 to r-1
  • In every iteration update ans as (ans*(n-i))/(i+1), where i is the loop counter.
• So the answer will be equal to ((n/1)*((n-1)/2)*…*((n-r+1)/r), which is equal to nC_r.

Below are steps to calculate Catalan numbers using the formula: 2nC_n/(n+1)

• Calculate 2nC_n using the similar steps that we use to calculate nC_r
• Return the value 2nC_n/ (n + 1)

Below is the implementation of the above approach:

C++

// C++ program for nth Catalan Number
#include <iostream>
using namespace std;

// Returns value of Binomial Coefficient C(n, k)
unsigned long int binomialCoeff(unsigned int n,
                                unsigned int k)
{
    unsigned long int res = 1;

    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;

    // Calculate value of [n*(n-1)*---*(n-k+1)] /
    // [k*(k-1)*---*1]
    for (int i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }

    return res;
}

// A Binomial coefficient based function to find nth catalan
// number in O(n) time
unsigned long int catalan(unsigned int n)
{
    // Calculate value of 2nCn
    unsigned long int c = binomialCoeff(2 * n, n);

    // return 2nCn/(n+1)
    return c / (n + 1);
}

// Driver code
int main()
{
    for (int i = 0; i < 10; i++)
        cout << catalan(i) << " ";
    return 0;
}

Output

1 1 2 5 14 42 132 429 1430 4862 

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

We can also use the below formulas to find nth Catalan number in O(n) time. 

C/C++ Program for nth Catalan Number using the previous Catalan Number:

Below are steps to calculate Catalan numbers using the above formula:

• Initialize a variable res = 1
• Print 1 as the first Catalan Number
• Iterate from i = 1 to i < n
  • Update res with res = (res * (4 * i – 2)) / (i + 1)
  • print res

Below is the implementation for the above approach:

C++

#include <bits/stdc++.h>
using namespace std;

// Function to print first n Catalan numbers
void catalan(int n)
{
    int res = 1;
    cout << res << " ";
    // Iterate till n
    for (int i = 1; i < n; i++) {
        // Calculate the ith Catalan number
        res = (res * (4 * i - 2)) / (i + 1);
           cout << res << " ";
    }
}

// Driver code
int main()
{
    int n = 10;

    // Function call
    catalan(n);
    return 0;
}

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.

Please refer complete article on Program for nth Catalan Number for more details!