# Kth ancestor of a node in an N-ary tree using Binary Lifting Technique

Given a vertex V of an N-ary tree and an integer K, the task is to print the Kth ancestor of the given vertex in the tree. If there does not exist any such ancestor then print -1.

Examples:

Input: K = 2, V = 4 Output: 1
2nd parent of vertex 4 is 1.

Input: K = 3, V = 4 Output: -1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to use Binary Lifting Technique. This technique is based on the fact that every integer can be represented in binary form. Through pre-processing, a sparse table table[v][i] can be calculated which stores the 2ith parent of the vertex v where 0 ≤ i ≤ log2N. This pre-processing takes O(NlogN) time.
To find the Kth parent of the vertex V, let K = b0b1b2…bn be an n bit number in the binary representation, let p1, p2, p3, …, pj be the indices where bit value is 1 then K can be represented as K = 2p1 + 2p2 + 2p3 + … + 2pj. Thus to reach Kth parent of V, we have to make jumps to 2pth1, 2pth2, 2pth3 upto 2pthj parent in any order. This can be done efficiently through the sparse table calculated earlier in O(logN).

Below is the implementation of the above approach:

## C++

 `// CPP implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Table for storing 2^ith parent ` `int` `**table; ` ` `  `// To store the height of the tree ` `int` `height; ` ` `  `// initializing the table and ` `// the height of the tree ` `void` `initialize(``int` `n) ` `{ ` `    ``height = (``int``)``ceil``(log2(n)); ` `    ``table = ``new` `int` `*[n + 1]; ` `} ` ` `  `// Filling with -1 as initial ` `void` `preprocessing(``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n + 1; i++) ` `    ``{ ` `        ``table[i] = ``new` `int``[height + 1]; ` `        ``memset``(table[i], -1, ``sizeof` `table[i]); ` `    ``} ` `} ` ` `  `// Calculating sparse table[][] dynamically ` `void` `calculateSparse(``int` `u, ``int` `v) ` `{ ` `    ``// Using the recurrence relation to ` `    ``// calculate the values of table[][] ` `    ``table[v] = u; ` `    ``for` `(``int` `i = 1; i <= height; i++) ` `    ``{ ` `        ``table[v][i] = table[table[v][i - 1]][i - 1]; ` ` `  `        ``// If we go out of bounds of the tree ` `        ``if` `(table[v][i] == -1) ` `            ``break``; ` `    ``} ` `} ` ` `  `// Function to return the Kth ancestor of V ` `int` `kthancestor(``int` `V, ``int` `k) ` `{ ` `    ``// Doing bitwise operation to ` `    ``// check the set bit ` `    ``for` `(``int` `i = 0; i <= height; i++) ` `    ``{ ` `        ``if` `(k & (1 << i)) ` `        ``{ ` `            ``V = table[V][i]; ` `            ``if` `(V == -1) ` `                ``break``; ` `        ``} ` `    ``} ` `    ``return` `V; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Number of vertices ` `    ``int` `n = 6; ` ` `  `    ``// initializing ` `    ``initialize(n); ` ` `  `    ``// Pre-processing ` `    ``preprocessing(n); ` ` `  `    ``// Calculating ancestors of v ` `    ``calculateSparse(1, 2); ` `    ``calculateSparse(1, 3); ` `    ``calculateSparse(2, 4); ` `    ``calculateSparse(2, 5); ` `    ``calculateSparse(3, 6); ` ` `  `    ``int` `K = 2, V = 5; ` `    ``cout << kthancestor(V, K) << endl; ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Java

 `// Java implementation of the approach ` `import` `java.util.Arrays; ` ` `  `class` `GfG { ` ` `  `    ``// Table for storing 2^ith parent ` `    ``private` `static` `int` `table[][]; ` ` `  `    ``// To store the height of the tree ` `    ``private` `static` `int` `height; ` ` `  `    ``// Private constructor for initializing ` `    ``// the table and the height of the tree ` `    ``private` `GfG(``int` `n) ` `    ``{ ` ` `  `        ``// log(n) with base 2 ` `        ``height = (``int``)Math.ceil(Math.log10(n) / Math.log10(``2``)); ` `        ``table = ``new` `int``[n + ``1``][height + ``1``]; ` `    ``} ` ` `  `    ``// Filling with -1 as initial ` `    ``private` `static` `void` `preprocessing() ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < table.length; i++) { ` `            ``Arrays.fill(table[i], -``1``); ` `        ``} ` `    ``} ` ` `  `    ``// Calculating sparse table[][] dynamically ` `    ``private` `static` `void` `calculateSparse(``int` `u, ``int` `v) ` `    ``{ ` ` `  `        ``// Using the recurrence relation to ` `        ``// calculate the values of table[][] ` `        ``table[v][``0``] = u; ` `        ``for` `(``int` `i = ``1``; i <= height; i++) { ` `            ``table[v][i] = table[table[v][i - ``1``]][i - ``1``]; ` ` `  `            ``// If we go out of bounds of the tree ` `            ``if` `(table[v][i] == -``1``) ` `                ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Function to return the Kth ancestor of V ` `    ``private` `static` `int` `kthancestor(``int` `V, ``int` `k) ` `    ``{ ` ` `  `        ``// Doing bitwise operation to ` `        ``// check the set bit ` `        ``for` `(``int` `i = ``0``; i <= height; i++) { ` `            ``if` `((k & (``1` `<< i)) != ``0``) { ` `                ``V = table[V][i]; ` `                ``if` `(V == -``1``) ` `                    ``break``; ` `            ``} ` `        ``} ` `        ``return` `V; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// Number of vertices ` `        ``int` `n = ``6``; ` ` `  `        ``// Calling the constructor ` `        ``GfG obj = ``new` `GfG(n); ` ` `  `        ``// Pre-processing ` `        ``preprocessing(); ` ` `  `        ``// Calculating ancestors of v ` `        ``calculateSparse(``1``, ``2``); ` `        ``calculateSparse(``1``, ``3``); ` `        ``calculateSparse(``2``, ``4``); ` `        ``calculateSparse(``2``, ``5``); ` `        ``calculateSparse(``3``, ``6``); ` ` `  `        ``int` `K = ``2``, V = ``5``; ` `        ``System.out.print(kthancestor(V, K)); ` `    ``} ` `} `

## Python3

 `# Python3 implementation of the approach ` `import` `math ` ` `  `class` `GfG : ` ` `  `    ``# Private constructor for initializing ` `    ``# the table and the height of the tree ` `    ``def` `__init__(``self``, n): ` `     `  `        ``# log(n) with base 2 ` `        ``# To store the height of the tree ` `        ``self``.height ``=` `int``(math.ceil(math.log10(n) ``/` `math.log10(``2``))) ` `         `  `        ``# Table for storing 2^ith parent ` `        ``self``.table ``=` `[``0``] ``*` `(n ``+` `1``) ` `     `  `    ``# Filling with -1 as initial ` `    ``def` `preprocessing(``self``): ` `        ``i ``=` `0` `        ``while` `( i < ``len``(``self``.table)) : ` `            ``self``.table[i] ``=` `[``-``1``]``*``(``self``.height ``+` `1``) ` `            ``i ``=` `i ``+` `1` `         `  `    ``# Calculating sparse table[][] dynamically ` `    ``def` `calculateSparse(``self``, u, v): ` `     `  `        ``# Using the recurrence relation to ` `        ``# calculate the values of table[][] ` `        ``self``.table[v][``0``] ``=` `u ` `        ``i ``=` `1` `        ``while` `( i <``=` `self``.height) : ` `            ``self``.table[v][i] ``=` `self``.table[``self``.table[v][i ``-` `1``]][i ``-` `1``] ` ` `  `            ``# If we go out of bounds of the tree ` `            ``if` `(``self``.table[v][i] ``=``=` `-``1``): ` `                ``break` `            ``i ``=` `i ``+` `1` `         `  `    ``# Function to return the Kth ancestor of V ` `    ``def` `kthancestor(``self``, V, k): ` `        ``i ``=` `0` ` `  `        ``# Doing bitwise operation to ` `        ``# check the set bit ` `        ``while` `( i <``=` `self``.height) : ` `            ``if` `((k & (``1` `<< i)) !``=` `0``) : ` `                ``V ``=` `self``.table[V][i] ` `                ``if` `(V ``=``=` `-``1``): ` `                    ``break` `            ``i ``=` `i ``+` `1` `         `  `        ``return` `V ` `     `  `# Driver code ` ` `  `# Number of vertices ` `n ``=` `6` ` `  `# Calling the constructor ` `obj ``=` `GfG(n) ` ` `  `# Pre-processing ` `obj.preprocessing() ` ` `  `# Calculating ancestors of v ` `obj.calculateSparse(``1``, ``2``) ` `obj.calculateSparse(``1``, ``3``) ` `obj.calculateSparse(``2``, ``4``) ` `obj.calculateSparse(``2``, ``5``) ` `obj.calculateSparse(``3``, ``6``) ` ` `  `K ``=` `2` `V ``=` `5` `print``(obj.kthancestor(V, K)) ` `     `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``class` `GfG  ` `    ``{  ` `     `  `        ``// Table for storing 2^ith parent  ` `        ``private` `static` `int` `[,]table ;  ` `     `  `        ``// To store the height of the tree  ` `        ``private` `static` `int` `height;  ` `     `  `        ``// Private constructor for initializing  ` `        ``// the table and the height of the tree  ` `        ``private` `GfG(``int` `n)  ` `        ``{  ` `     `  `            ``// log(n) with base 2  ` `            ``height = (``int``)Math.Ceiling(Math.Log10(n) / Math.Log10(2));  ` `            ``table = ``new` `int``[n + 1, height + 1];  ` `        ``}  ` `     `  `        ``// Filling with -1 as initial  ` `        ``private` `static` `void` `preprocessing()  ` `        ``{  ` `            ``for` `(``int` `i = 0; i < table.GetLength(0); i++) ` `            ``{  ` `                ``for` `(``int` `j = 0; j < table.GetLength(1); j++) ` `                ``{ ` `                    ``table[i, j] = -1;  ` `                ``} ` `            ``}  ` `        ``}  ` `     `  `        ``// Calculating sparse table[,] dynamically  ` `        ``private` `static` `void` `calculateSparse(``int` `u, ``int` `v)  ` `        ``{  ` `     `  `            ``// Using the recurrence relation to  ` `            ``// calculate the values of table[,]  ` `            ``table[v, 0] = u;  ` `            ``for` `(``int` `i = 1; i <= height; i++) ` `            ``{  ` `                ``table[v, i] = table[table[v, i - 1], i - 1];  ` `     `  `                ``// If we go out of bounds of the tree  ` `                ``if` `(table[v, i] == -1)  ` `                    ``break``;  ` `            ``}  ` `        ``}  ` `     `  `        ``// Function to return the Kth ancestor of V  ` `        ``private` `static` `int` `kthancestor(``int` `V, ``int` `k)  ` `        ``{  ` `     `  `            ``// Doing bitwise operation to  ` `            ``// check the set bit  ` `            ``for` `(``int` `i = 0; i <= height; i++)  ` `            ``{  ` `                ``if` `((k & (1 << i)) != 0) ` `                ``{  ` `                    ``V = table[V, i];  ` `                    ``if` `(V == -1)  ` `                        ``break``;  ` `                ``}  ` `            ``}  ` `            ``return` `V;  ` `        ``}  ` `     `  `        ``// Driver code  ` `        ``public` `static` `void` `Main()  ` `        ``{  ` `            ``// Number of vertices  ` `            ``int` `n = 6;  ` `     `  `            ``// Calling the constructor  ` `            ``GfG obj = ``new` `GfG(n);  ` `     `  `            ``// Pre-processing  ` `            ``preprocessing();  ` `     `  `            ``// Calculating ancestors of v  ` `            ``calculateSparse(1, 2);  ` `            ``calculateSparse(1, 3);  ` `            ``calculateSparse(2, 4);  ` `            ``calculateSparse(2, 5);  ` `            ``calculateSparse(3, 6);  ` `     `  `            ``int` `K = 2, V = 5;  ` `            ``Console.Write(kthancestor(V, K));  ` `        ``}  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```1
```

Time Complexity: O(NlogN) for pre-processing and logN for finding the ancestor.

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.