Combinatorics on ordered trees - GeeksforGeeks

26 May, 2021
An ordered tree is an oriented tree in which the children of a node are somehow ordered. It is a rooted tree in which an ordering is specified for the children of each vertex. This is called a “plane tree” because the ordering of the children is equivalent to an embedding of the tree in the plane, with the root at the top and the children of each vertex lower than that vertex. The ordered trees can be further specified as labelled ordered trees and unlabelled ordered trees.
Prerequisite: Catalan Numbers | Binomial Coefficient.
Labelled ordered trees: A labeled tree is a tree where each vertex is assigned a unique number from 1 to n.
If T1 and T2 are ordered trees. Then, T1 != T2 else T1 = T2.
Unlabelled ordered trees: An unlabelled tree is a tree where every vertex is unlabelled. Given below are the possible unlabelled ordered tree having 3 vertices. 
The total number of unlabelled ordered trees having n nodes is equal to the (n – 1)-th Catalan Number.Given below are the possible unlabelled ordered trees having 4 nodes. This diagram will work as a reference example for the next few results.
1. Number of trees with exactly k leaves. Let us consider that we have ‘n’ edges. Then, the solution for the total possible ordered trees having ‘k’ leaves is given by : 
2. Total number of nodes of degree d in these trees. Let us consider that we have ‘n’ edges. Then, the solution for the total number of nodes having a degree ‘d’ is given by :  
3. Number of trees in which the root has degree r. Let us consider that we have ‘n’ edges. Then, the solution for the total possible ordered trees whose root has degree ‘r’ is given by :  
Below is the implementation of the above combinatorics functions using Binomial Coefficient : 
C++
Java
Python3
C#
PHP
Javascript
// C++ code to find the number of ordered trees// with given number of edges and leaves#include <bits/stdc++.h>using namespace std; // Function returns value of// Binomial Coefficient C(n, k)int binomialCoeff(int n, int k){    int C[n + 1][k + 1] = { 0 };    int i, j;     // Calculate value of Binomial    // Coefficient in bottom up manner    for (i = 0; i <= n; i++) {        for (j = 0; j <= min(i, k); j++) {             // Base Cases            if (j == 0 || j == i)                C[i][j] = 1;             // Calculate value using            // previously stored values            else                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];        }    }     return C[n][k];} // Function to calculate the number// of trees with exactly k leaves.int k_Leaves(int n, int k){    int ans = (binomialCoeff(n, k) * binomialCoeff(n, k - 1)) / n;    cout << "Number of trees having 4 edges"         << " and exactly 2 leaves : " << ans << endl;    return 0;} // Function to calculate total number of// nodes of degree d in these trees.int numberOfNodes(int n, int d){    int ans = binomialCoeff(2 * n - 1 - d, n - 1);    cout << "Number of nodes of degree 1 in"         << " a tree having 4 edges : " << ans << endl;    return 0;} // Function to calculate the number of// trees in which the root has degree r.int rootDegreeR(int n, int r){    int ans = r * binomialCoeff(2 * n - 1 - r, n - 1);    ans = ans / n;    cout << "Number of trees having 4 edges"         << " where root has degree 2 : " << ans << endl;    return 0;} // Driver program to test above functionsint main(){    // Number of trees having 3    // edges and exactly 2 leaves    k_Leaves(3, 2);     // Number of nodes of degree    // 3 in a tree having 4 edges    numberOfNodes(3, 1);     // Number of trees having 3    // edges where root has degree 2    rootDegreeR(3, 2);     return 0;}
// java code to find the number of ordered// trees with given number of edges and// leavesimport java.io.*; class GFG {             // Function returns value of    // Binomial Coefficient C(n, k)    static int binomialCoeff(int n, int k)    {        int [][]C = new int[n+1][k+1];        int i, j;             // Calculate value of Binomial        // Coefficient in bottom up manner        for (i = 0; i <= n; i++) {            for (j = 0; j <= Math.min(i, k); j++)            {                     // Base Cases                if (j == 0 || j == i)                    C[i][j] = 1;                     // Calculate value using                // previously stored values                else                    C[i][j] = C[i - 1][j - 1]                               + C[i - 1][j];            }        }             return C[n][k];    }         // Function to calculate the number    // of trees with exactly k leaves.    static int k_Leaves(int n, int k)    {        int ans = (binomialCoeff(n, k) *                binomialCoeff(n, k - 1)) / n;        System.out.println( "Number of trees "             + "having 4 edges and exactly 2 "                        + "leaves : " + ans) ;        return 0;    }         // Function to calculate total number of    // nodes of degree d in these trees.    static int numberOfNodes(int n, int d)    {        int ans = binomialCoeff(2 * n - 1 - d,                                       n - 1);        System.out.println("Number of nodes "           +"of degree 1 in a tree having 4 "                          + "edges : " + ans);        return 0;    }         // Function to calculate the number of    // trees in which the root has degree r.    static int rootDegreeR(int n, int r)    {        int ans = r * binomialCoeff(2 * n                              - 1 - r, n - 1);        ans = ans / n;        System.out.println("Number of trees "            + "having 4 edges where root has"                      + " degree 2 : " + ans);        return 0;    }         // Driver program to test above functions     public static void main (String[] args)    {                     // Number of trees having 3        // edges and exactly 2 leaves        k_Leaves(3, 2);             // Number of nodes of degree        // 3 in a tree having 4 edges        numberOfNodes(3, 1);             // Number of trees having 3        // edges where root has degree 2        rootDegreeR(3, 2);    }} // This code is contributed by anuj_67.
# Python3 code to find the number of ordered# trees with given number of edges and# leaves # Function returns value of# Binomial Coefficient C(n, k)def binomialCoeff(n, k):         C = [[0 for i in range(k + 1)]            for j in range(n + 1)]         # Calculate value of Binomial    # Coefficient in bottom up manner    for i in range(n + 1):        for j in range(min(i, k) + 1):                         # Base Cases            if (j == 0 or j == i):                C[i][j] = 1             # Calculate value using            # previously stored values            else:                C[i][j] = (C[i - 1][j - 1] +                           C[i - 1][j])                                return C[n][k] # Function to calculate the number# of trees with exactly k leaves.def k_Leaves(n, k):         ans = ((binomialCoeff(n, k) *            binomialCoeff(n, k - 1)) // n)    print("Number of trees ",          "having 4 edges and exactly 2 ",          "leaves : ", ans)     # Function to calculate total number of# Nodes of degree d in these trees.def numberOfNodes(n, d):         ans = binomialCoeff(2 * n - 1 - d, n - 1)    print("Number of Nodes ",          "of degree 1 in a tree having 4 ",          "edges : ", ans)     # Function to calculate the number of# trees in which the root has degree r.def rootDegreeR(n, r):         ans = r * binomialCoeff(2 * n - 1 - r, n - 1)    ans = ans // n         print("Number of trees ",          "having 4 edges where root has ",          "degree 2 : ", ans)     # Driver codeif __name__ == '__main__':         # Number of trees having 3    # edges and exactly 2 leaves    k_Leaves(3, 2)     # Number of Nodes of degree    # 3 in a tree having 4 edges    numberOfNodes(3, 1)     # Number of trees having 3    # edges where root has degree 2    rootDegreeR(3, 2) # This code is contributed by aashish1995
// C# code to find the number of ordered// trees with given number of edges and// leavesusing System; class GFG {             // Function returns value of    // Binomial Coefficient C(n, k)    static int binomialCoeff(int n, int k)    {        int [,]C = new int[n+1,k+1];        int i, j;             // Calculate value of Binomial        // Coefficient in bottom up manner        for (i = 0; i <= n; i++) {            for (j = 0; j <= Math.Min(i, k); j++)            {                     // Base Cases                if (j == 0 || j == i)                    C[i,j] = 1;                     // Calculate value using                // previously stored values                else                    C[i,j] = C[i - 1,j - 1]                            + C[i - 1,j];            }        }             return C[n,k];    }         // Function to calculate the number    // of trees with exactly k leaves.    static int k_Leaves(int n, int k)    {        int ans = (binomialCoeff(n, k) *                binomialCoeff(n, k - 1)) / n;        Console.WriteLine( "Number of trees "            + "having 4 edges and exactly 2 "                        + "leaves : " + ans) ;        return 0;    }         // Function to calculate total number of    // nodes of degree d in these trees.    static int numberOfNodes(int n, int d)    {        int ans = binomialCoeff(2 * n - 1 - d,                                    n - 1);        Console.WriteLine("Number of nodes "        +"of degree 1 in a tree having 4 "                        + "edges : " + ans);        return 0;    }         // Function to calculate the number of    // trees in which the root has degree r.    static int rootDegreeR(int n, int r)    {        int ans = r * binomialCoeff(2 * n                            - 1 - r, n - 1);        ans = ans / n;        Console.WriteLine("Number of trees "            + "having 4 edges where root has"                    + " degree 2 : " + ans);        return 0;    }         // Driver program to test above functions     public static void Main ()    {                     // Number of trees having 3        // edges and exactly 2 leaves        k_Leaves(3, 2);             // Number of nodes of degree        // 3 in a tree having 4 edges        numberOfNodes(3, 1);             // Number of trees having 3        // edges where root has degree 2        rootDegreeR(3, 2);    }} // This code is contributed by anuj_67.
<?php// PHP code to find the number of ordered// trees with given number of edges and// leaves // Function returns value of Binomial// Coefficient C(n, k)function binomialCoeff($n, $k){    $C = array(array());    $i; $j;     // Calculate value of Binomial    // Coefficient in bottom up manner    for ($i = 0; $i <= $n; $i++) {        for ($j = 0; $j <= min($i, $k); $j++)        {             // Base Cases            if ($j == 0 or $j == $i)                $C[$i][$j] = 1;             // Calculate value using            // previously stored values            else                $C[$i][$j] = $C[$i - 1][$j - 1]                              + $C[$i - 1][$j];        }    }     return $C[$n][$k];} // Function to calculate the number// of trees with exactly k leaves.function k_Leaves( $n, $k){    $ans = (binomialCoeff($n, $k) *               binomialCoeff($n, $k - 1)) / $n;                    echo "Number of trees having 4 edges and ",          "exactly 2 leaves : " , $ans ,"\n";              return 0;} // Function to calculate total number of// nodes of degree d in these trees.function numberOfNodes( $n, $d){    $ans = binomialCoeff(2 * $n - 1 - $d, $n - 1);    echo "Number of nodes of degree 1 in"        , " a tree having 4 edges : " , $ans,"\n" ;    return 0;} // Function to calculate the number of// trees in which the root has degree r.function rootDegreeR( $n, $r){    $ans = $r * binomialCoeff(2 * $n - 1 - $r,                                         $n - 1);    $ans = $ans / $n;    echo "Number of trees having 4 edges"        , " where root has degree 2 : " , $ans ;    return 0;} // Driver program to test above functions    // Number of trees having 3    // edges and exactly 2 leaves    k_Leaves(3, 2);     // Number of nodes of degree    // 3 in a tree having 4 edges    numberOfNodes(3, 1);     // Number of trees having 3    // edges where root has degree 2    rootDegreeR(3, 2); // This code is contributed by anuj_67.?>
<script>    // javascript code to find the number of ordered    // trees with given number of edges and leaves         // Function returns value of    // Binomial Coefficient C(n, k)    function binomialCoeff(n, k)    {        let C = new Array(n+1);        let i, j;        for (i = 0; i <= n; i++)        {            C[i] = new Array(k + 1);            for (j = 0; j <= k; j++)            {                C[i][j] = 0;            }        }                           // Calculate value of Binomial        // Coefficient in bottom up manner        for (i = 0; i <= n; i++) {            for (j = 0; j <= Math.min(i, k); j++)            {                      // Base Cases                if (j == 0 || j == i)                    C[i][j] = 1;                      // Calculate value using                // previously stored values                else                    C[i][j] = C[i - 1][j - 1]                               + C[i - 1][j];            }        }              return C[n][k];    }          // Function to calculate the number    // of trees with exactly k leaves.    function k_Leaves(n, k)    {        let ans = parseInt((binomialCoeff(n, k) * binomialCoeff(n, k - 1)) / n, 10);        document.write( "Number of trees "             + "having 4 edges and exactly 2 "                        + "leaves : " + ans + "</br>");        return 0;    }          // Function to calculate total number of    // nodes of degree d in these trees.    function numberOfNodes(n, d)    {        let ans = binomialCoeff(2 * n - 1 - d,                                       n - 1);        document.write("Number of nodes "           +"of degree 1 in a tree having 4 "                          + "edges : " + ans + "</br>");        return 0;    }          // Function to calculate the number of    // trees in which the root has degree r.    function rootDegreeR(n, r)    {        let ans = r * binomialCoeff(2 * n - 1 - r, n - 1);        ans = parseInt(ans / n, 10);        document.write("Number of trees "            + "having 4 edges where root has"                      + " degree 2 : " + ans + "</br>");        return 0;    }         // Number of trees having 3    // edges and exactly 2 leaves    k_Leaves(3, 2);     // Number of nodes of degree    // 3 in a tree having 4 edges    numberOfNodes(3, 1);     // Number of trees having 3    // edges where root has degree 2    rootDegreeR(3, 2); </script>
Number of trees having 4 edges and exactly 2 leaves : 3
Number of nodes of degree 1 in a tree having 4 edges : 6
Number of trees having 4 edges where root has degree 2 : 2
 
Time Complexity : O(n*k). Auxiliary Space : O(n*k). 
vt_m
nidhi_biet
aashish1995
suresh07
Trees
Combinatorial
Competitive Programming
Mathematical
Technical Scripter
Tree
Mathematical
Combinatorial
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Python program to get all subsets of given size of a set
Print all distinct permutations of a given string with duplicates
Heap's Algorithm for generating permutations
Distinct permutations of the string | Set 2
Make all combinations of size k
Competitive Programming - A Complete Guide
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Prefix Sum Array - Implementation and Applications in Competitive Programming
Top 10 Algorithms and Data Structures for Competitive Programming