Kth Ancestor of a Tree Node - Practice Coding Problems

Kth Ancestor of a Tree Node - Problem

Binary Search Dynamic Programming Bit Manipulation Tree Depth-First Search Breadth-First Search Design Hard

You're building a family tree navigation system that can quickly find any ancestor at a specific generation level. Given a tree with n nodes numbered from 0 to n-1 and a parent array where parent[i] represents the parent of node i, you need to efficiently answer queries about the kth ancestor of any node.

The kth ancestor of a node is the node that appears k steps up in the path from that node to the root. For example, if we trace the path from a node to the root, the 1st ancestor is its parent, the 2nd ancestor is its grandparent, and so on.

Your task: Implement a TreeAncestor class that can handle multiple queries efficiently:

TreeAncestor(int n, int[] parent) - Initialize with the tree structure
int getKthAncestor(int node, int k) - Return the kth ancestor of the given node, or -1 if no such ancestor exists

Since there can be up to 50,000 queries, a naive approach of traversing up the tree each time will be too slow. You'll need to use preprocessing techniques like binary lifting or dynamic programming to achieve optimal performance.

Input & Output

example_1.py — Basic Tree

$ Input: n = 7, parent = [-1, 0, 0, 1, 1, 2, 2] getKthAncestor(3, 1) = ? getKthAncestor(5, 2) = ? getKthAncestor(6, 3) = ?

› Output: 1 0 -1

💡 Note: Tree structure: 0 is root, 1&2 are children of 0, 3&4 are children of 1, 5&6 are children of 2. getKthAncestor(3,1) finds 1st ancestor of node 3, which is node 1. getKthAncestor(5,2) finds 2nd ancestor of node 5: 5→2→0. getKthAncestor(6,3) tries to find 3rd ancestor of node 6: 6→2→0→(no parent), returns -1.

example_2.py — Linear Chain

$ Input: n = 5, parent = [-1, 0, 1, 2, 3] getKthAncestor(4, 2) = ? getKthAncestor(4, 4) = ? getKthAncestor(2, 3) = ?

› Output: 2 0 -1

💡 Note: Linear chain: 0→1→2→3→4. getKthAncestor(4,2) traces back 2 steps: 4→3→2. getKthAncestor(4,4) traces back 4 steps: 4→3→2→1→0. getKthAncestor(2,3) tries to go back 3 steps but only root's parent is null: 2→1→0→null, returns -1.

example_3.py — Edge Cases

$ Input: n = 1, parent = [-1] getKthAncestor(0, 1) = ? n = 3, parent = [-1, 0, 0] getKthAncestor(1, 0) = ?

› Output: -1 1

💡 Note: Single node tree: Only root exists, asking for its parent returns -1. When k=0, we want the node itself (0th ancestor), so getKthAncestor(1,0) returns node 1.

Constraints

1 ≤ n ≤ 5 × 10⁴
parent[0] == -1 indicating that 0 is the root
0 ≤ parent[i] < n for all 0 < i < n
0 ≤ node < n
1 ≤ k ≤ n
At most 5 × 10⁴ queries will be made

Visualization

Tap to expand

Understanding the Visualization

Build Elevator System

Pre-compute where each 'elevator' (power-of-2 jump) takes you from every node

Convert Distance to Binary

For k=13, convert to binary: 1101₂ = 8+4+1

Make Combined Jumps

Take elevator of size 1, then 4, then 8 to reach 13 floors up

Arrive at Destination

Reach the kth ancestor in O(log k) time instead of O(k)

Key Takeaway

🎯 Key Insight: Binary lifting transforms O(k) linear traversal into O(log k) by pre-computing power-of-2 jumps and using binary decomposition

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 15

The optimal solution uses binary lifting to pre-compute ancestors at powers-of-2 distances. This allows any kth ancestor query to be answered in O(log k) time by decomposing k into binary representation and making corresponding jumps. The key insight is trading space for time: use O(n log n) space to achieve lightning-fast queries.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Lifting (Optimal)	O(log k) per query	O(n log n)	Pre-compute ancestors at powers of 2 distances for O(log k) queries
Brute Force (Direct Traversal)	O(k) per query	O(n)	Store parent array and traverse k steps up for each query

Binary Lifting (Optimal) — Algorithm Steps

Pre-compute dp[i][j] = 2^j-th ancestor of node i during initialization
For each query, decompose k into binary representation
Make jumps corresponding to set bits in k's binary form
Return the final node after all jumps, or -1 if path is invalid

Visualization

Tap to expand

Step-by-Step Walkthrough

Pre-process

Build DP table with 2^j ancestors for each node

Binary Decomposition

Convert k to binary: k=5 → 101₂ → jumps of 4+1

Make Jumps

Jump by powers of 2 corresponding to set bits

Result

Arrive at kth ancestor in O(log k) time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

typedef struct {
    int** dp;
    int LOG;
    int n;
} TreeAncestor;

TreeAncestor* treeAncestorCreate(int n, int* parent) {
    TreeAncestor* ta = (TreeAncestor*)malloc(sizeof(TreeAncestor));
    ta->LOG = (int)log2(n) + 1;
    ta->n = n;
    
    // Allocate dp array
    ta->dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        ta->dp[i] = (int*)malloc(ta->LOG * sizeof(int));
        for (int j = 0; j < ta->LOG; j++) {
            ta->dp[i][j] = -1;
        }
    }
    
    // Initialize direct parents
    for (int i = 0; i < n; i++) {
        ta->dp[i][0] = parent[i];
    }
    
    // Fill dp table
    for (int j = 1; j < ta->LOG; j++) {
        for (int i = 0; i < n; i++) {
            if (ta->dp[i][j-1] != -1) {
                ta->dp[i][j] = ta->dp[ta->dp[i][j-1]][j-1];
            }
        }
    }
    
    return ta;
}

int treeAncestorGetKthAncestor(TreeAncestor* obj, int node, int k) {
    int current = node;
    int power = 0;
    
    while (k > 0 && current != -1) {
        if (k & 1) {
            current = obj->dp[current][power];
        }
        k >>= 1;
        power++;
    }
    
    return current;
}

int main() {
    int n;
    scanf("%d", &n);
    int* parent = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &parent[i]);
    }
    TreeAncestor* ta = treeAncestorCreate(n, parent);
    int queries;
    scanf("%d", &queries);
    for (int i = 0; i < queries; i++) {
        int node, k;
        scanf("%d %d", &node, &k);
        printf("%d\n", treeAncestorGetKthAncestor(ta, node, k));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log k) per query

We decompose k into at most log k bits and make jumps accordingly, initialization takes O(n log n)

⚡ Linearithmic

Space Complexity

O(n log n)

We store ancestors at powers of 2 distances for all nodes, requiring n * log(n) space

⚡ Linearithmic Space

38.2K Views

Medium-High Frequency

~35 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Lifting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler