Number of ways to traverse an N-ary tree - GeeksforGeeks

27 Apr, 2022
Given an n-ary tree, count number of ways to traverse an n-ary (or a Directed Acyclic Graph) tree starting from the root vertex.Suppose we have a given N-ary tree as shown below. 
Now we have to find the number of ways of traversing the whole tree starting from the root vertex. There can be many such ways. Some of them are listed below.1) N->M->K->J->B->F->D->E->C->H->I->L->A (kind-of depth first traversal). 2) A->B->F->D->E->K->J->G->C->H->I->N->M->L (level order traversal) 3) ......... 4) ......... . . . and so on....We strongly recommend you to minimize your browser and try this yourself first.The count of all ways to traverse is the product of factorials of the number of children of each node. Refer to the below figure for clear understanding- 
Here,‘A’ has four children, so 4! permutations possible ‘B’ has two children, so 2! permutations possible ‘F’ has no children, so 0! permutations possible ..... And so onHence all such ways are- 4 ! * 2 ! * 0 ! * 1 ! * 3 ! * 2 ! * 0 ! * 0 ! * 0 ! * 0 ! * 1 ! * 0 ! * 0 ! = 576 wayThat’s a huge number of ways and among them only few proves to be useful, like- inorder, level-order, preorder, postorder (arranged according to the popularity of these traversals) 
C++
Python3
Javascript
// C++ program to find the number of ways to traverse a// n-ary tree starting from the root node#include <bits/stdc++.h>using namespace std; // Structure of a node of an n-ary treestruct Node{   char key;   vector<Node *> child;}; // Utility function to create a new tree nodeNode *newNode(int key){   Node *temp = new Node;   temp->key = key;   return temp;} // Utility Function to find factorial of given numberint factorial(int n){   if (n == 0)     return 1;   return n*factorial(n-1);} // Function to calculate the number of ways of traversing// the n-ary starting from root.// This function is just a modified breadth-first search.// We can use a depth-first search too.int calculateWays(Node * root){   int ways = 1;  // Initialize result    // If the tree is empty there is no way of traversing   // the tree.   if (root == NULL)      return 0;    // Create a queue and enqueue root to it.   queue<Node *>q;   q.push(root);    // Level order traversal.   while (!q.empty())   {         // Dequeue an item from queue and print it         Node * p = q.front();         q.pop();          // The number of ways is the product of         // factorials of number of children of each node.         ways = ways*(factorial(p->child.size()));          // Enqueue all childrent of the dequeued item         for (int i=0; i<p->child.size(); i++)            q.push(p->child[i]);    }    return(ways);} // Driver programint main(){   /*   Let us create below tree   *           A   *         / /  \  \   *       B  F   D  E   *      / \     |  /|\   *     K  J    G  C H I   *      /\            \   *    N   M            L   */    Node *root = newNode('A');   (root->child).push_back(newNode('B'));   (root->child).push_back(newNode('F'));   (root->child).push_back(newNode('D'));   (root->child).push_back(newNode('E'));   (root->child[0]->child).push_back(newNode('K'));   (root->child[0]->child).push_back(newNode('J'));   (root->child[2]->child).push_back(newNode('G'));   (root->child[3]->child).push_back(newNode('C'));   (root->child[3]->child).push_back(newNode('H'));   (root->child[3]->child).push_back(newNode('I'));   (root->child[0]->child[0]->child).push_back(newNode('N'));   (root->child[0]->child[0]->child).push_back(newNode('M'));   (root->child[3]->child[2]->child).push_back(newNode('L'));    cout << calculateWays(root); ;    return 0;}
# Python program to find the# number of ways to traverse a# n-ary tree starting from the root node class Node:    def __init__(self,key):        self.child = []        self.key = key     # Utility function to create a new tree nodedef newNode(key):    temp = Node(key)    return temp # Utility Function to find factorial of given numberdef factorial(n):     if (n == 0):        return 1     return n*factorial(n-1) # Function to calculate the number of ways of traversing# the n-ary starting from root.# self function is just a modified breadth-first search.# We can use a depth-first search too.def calculateWays(root):     ways = 1 # Initialize result     # If the tree is empty there is no way of traversing    # the tree.    if (root == None):        return 0     # Create a queue and enqueue root to it.    q = []    q.append(root)     # Level order traversal.    while (len(q) > 0):        # Dequeue an item from queue and print it        p = q[0]        q = q[1:]         # The number of ways is the product of        # factorials of number of children of each node.        ways = ways*(factorial(len(p.child)))         # Enqueue all childrent of the dequeued item        for i in range(len(p.child)):            q.append(p.child[i])     return(ways)     #  Let us create below tree# *         A# *         / / \ \# *     B F D E# *     / \     | /|\# *     K J G C H I# *     /\         \# * N M         L root = newNode('A');(root.child).append(newNode('B'));(root.child).append(newNode('F'));(root.child).append(newNode('D'));(root.child).append(newNode('E'));(root.child[0].child).append(newNode('K'));(root.child[0].child).append(newNode('J'));(root.child[2].child).append(newNode('G'));(root.child[3].child).append(newNode('C'));(root.child[3].child).append(newNode('H'));(root.child[3].child).append(newNode('I'));(root.child[0].child[0].child).append(newNode('N'));(root.child[0].child[0].child).append(newNode('M'));(root.child[3].child[2].child).append(newNode('L')); print(calculateWays(root))
<script>     // JavaScript program to find the    // number of ways to traverse a    // n-ary tree starting from the root node         class Node    {        constructor(key) {           this.child = [];           this.key = key;        }    }         // Utility function to create a new tree node    function newNode(key)    {       let temp = new Node(key);       return temp;    }     // Utility Function to find factorial of given number    function factorial(n)    {       if (n == 0)         return 1;       return n*factorial(n-1);    }     // Function to calculate the number of ways of traversing    // the n-ary starting from root.    // This function is just a modified breadth-first search.    // We can use a depth-first search too.    function calculateWays(root)    {       let ways = 1;  // Initialize result        // If the tree is empty there is no way of traversing       // the tree.       if (root == null)          return 0;        // Create a queue and enqueue root to it.       let q = [];       q.push(root);        // Level order traversal.       while (q.length > 0)       {             // Dequeue an item from queue and print it             let p = q[0];             q.shift();              // The number of ways is the product of             // factorials of number of children of each node.             ways = ways*(factorial(p.child.length));              // Enqueue all childrent of the dequeued item             for (let i=0; i< p.child.length; i++)                q.push(p.child[i]);        }        return(ways);    }         /*   Let us create below tree   *           A   *         / /  \  \   *       B  F   D  E   *      / \     |  /|\   *     K  J    G  C H I   *      /\            \   *    N   M            L   */      let root = newNode('A');   (root.child).push(newNode('B'));   (root.child).push(newNode('F'));   (root.child).push(newNode('D'));   (root.child).push(newNode('E'));   (root.child[0].child).push(newNode('K'));   (root.child[0].child).push(newNode('J'));   (root.child[2].child).push(newNode('G'));   (root.child[3].child).push(newNode('C'));   (root.child[3].child).push(newNode('H'));   (root.child[3].child).push(newNode('I'));   (root.child[0].child[0].child).push(newNode('N'));   (root.child[0].child[0].child).push(newNode('M'));   (root.child[3].child[2].child).push(newNode('L'));      document.write(calculateWays(root));     </script>
Output: 
576
Time Complexity: We visit each node once during the level order traversal and take O(n) time to compute factorial for every node. Total time taken is O(Nn) where N = number of nodes in the n-ary tree. We can optimize the solution to work in O(N) time by per-computing factorials of all numbers from 1 to n.Auxiliary Space : Since we are only using a queue and a structure for every node, so overall space complexity is also O(N).Common Pitfalls: Since, products of factorials can tend to grow very huge, so it may overflow. It is preferable to use data types like- unsigned long long int in C/C++, as the number of ways can never be a negative number. In Java and Python there are Big Integer to take care of overflows. 
YouTubeGeeksforGeeks507K subscribersNumber of ways to traverse an N-ary tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 7:08•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=Uv1W80vMVC4" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Rachit Belwariar. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@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 
suresh07
sagartomar9927
simmytarika5
shinjanpatra
n-ary-tree
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Expression Tree
BFS vs DFS for Binary Tree
Deletion in a Binary Tree