Kth Ancestor of a Tree Node

Kth Ancestor of a Tree Node - Problem

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

You are given a tree with n nodes numbered from 0 to n - 1 in the form of a parent array parent where parent[i] is the parent of the i^th node. The root of the tree is node 0. Find the k^th ancestor of a given node.

The k^th ancestor of a tree node is the k^th node in the path from that node to the root node.

Implement the TreeAncestor class:

TreeAncestor(int n, int[] parent) - Initializes the object with the number of nodes in the tree and the parent array.
int getKthAncestor(int node, int k) - Returns the k^th ancestor of the given node. If there is no such ancestor, return -1.

Input & Output

Example 1 — Basic Ancestor Query

$ Input: n = 7, parent = [-1,0,0,1,1,2,2], operations = [[3,1],[5,2],[6,3]]

› Output: [1,0,-1]

💡 Note: TreeAncestor(7, [-1,0,0,1,1,2,2]) creates the tree. getKthAncestor(3,1) returns 1 (parent of 3), getKthAncestor(5,2) returns 0 (grandparent of 5), getKthAncestor(6,3) returns -1 (6 only has 2 ancestors: 2 and 0, so 3rd ancestor doesn't exist)

Example 2 — No Such Ancestor

$ Input: n = 5, parent = [-1,0,0,1,2], operations = [[4,3],[2,4]]

› Output: [-1,-1]

💡 Note: Node 4's path to root is 4→2→0 (only 2 ancestors), so 3rd ancestor doesn't exist. Node 2's path is 2→0 (only 1 ancestor), so 4th ancestor doesn't exist

Example 3 — Root Ancestor Query

$ Input: n = 3, parent = [-1,0,1], operations = [[2,1],[2,2],[0,1]]

› Output: [1,0,-1]

💡 Note: getKthAncestor(2,1) = 1 (parent of 2), getKthAncestor(2,2) = 0 (grandparent of 2), getKthAncestor(0,1) = -1 (root has no parent)

Constraints

1 ≤ n ≤ 5 × 10⁴
parent[0] == -1
0 ≤ parent[i] < n for i > 0
1 ≤ k ≤ 5 × 10⁴
At most 5 × 10⁴ queries

Visualization

Tap to expand

Asked in

G Google 28 f Facebook 15 a Amazon 12

The key insight is to use binary lifting to precompute ancestors at exponential distances (2^0, 2^1, 2^2, ...). This allows any kth ancestor query to be answered in O(log k) time by decomposing k into its binary representation. Best approach is binary lifting with Time: O(log k) per query, Space: O(n log n).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Binary Lifting - Precompute Jump Table

⏱️ Time: O(log k) Space: O(n log n)

Use binary lifting technique to precompute a 2D table where jump[node][i] represents the 2^i-th ancestor of node. This allows us to answer queries in O(log k) time by decomposing k into powers of 2.

Brute Force - Direct Parent Traversal

⏱️ Time: O(k) Space: O(n)

Store the parent array and for each getKthAncestor query, simply follow parent pointers k times. If we reach the root (node 0) or a node with no parent before k steps, return -1.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAXN 1000
#define HASH_SIZE 100007

int directions[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
int n, m;

typedef struct HashNode {
    char key[100];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hash(char* key) {
    int hash = 0;
    while (*key) {
        hash = (hash * 31 + *key) % HASH_SIZE;
        key++;
    }
    return hash;
}

int getFromHash(char* key) {
    int h = hash(key);
    HashNode* node = hashTable[h];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return -1; // not found
}

void putInHash(char* key, int value) {
    int h = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[h];
    hashTable[h] = node;
}

int getExpectedValue(int pos) {
    if (pos == 0) return 1;
    return pos % 2 == 1 ? 2 : 0;
}

int getNextDirectionIdx(int currDirIdx) {
    return (currDirIdx + 1) % 4;
}

int dfs(int** grid, int r, int c, int dirIdx, int pos, int hasTurned) {
    if (r < 0 || r >= n || c < 0 || c >= m) return 0;
    
    char state[100];
    sprintf(state, "%d,%d,%d,%d,%d", r, c, dirIdx, pos, hasTurned);
    
    int cached = getFromHash(state);
    if (cached != -1) return cached;
    
    int expected = getExpectedValue(pos);
    if (grid[r][c] != expected) {
        putInHash(state, 0);
        return 0;
    }
    
    int currentLength = 1;
    int maxFromHere = currentLength;
    
    // Continue in same direction
    int nextR = r + directions[dirIdx][0], nextC = c + directions[dirIdx][1];
    if (nextR >= 0 && nextR < n && nextC >= 0 && nextC < m) {
        int nextExpected = getExpectedValue(pos + 1);
        if (grid[nextR][nextC] == nextExpected) {
            int nextLen = dfs(grid, nextR, nextC, dirIdx, pos + 1, hasTurned);
            if (currentLength + nextLen > maxFromHere) maxFromHere = currentLength + nextLen;
        }
    }
    
    // Try making a turn if we haven't turned yet
    if (!hasTurned) {
        int newDirIdx = getNextDirectionIdx(dirIdx);
        int turnR = r + directions[newDirIdx][0], turnC = c + directions[newDirIdx][1];
        if (turnR >= 0 && turnR < n && turnC >= 0 && turnC < m) {
            int turnExpected = getExpectedValue(pos + 1);
            if (grid[turnR][turnC] == turnExpected) {
                int turnLen = dfs(grid, turnR, turnC, newDirIdx, pos + 1, 1);
                if (currentLength + turnLen > maxFromHere) maxFromHere = currentLength + turnLen;
            }
        }
    }
    
    putInHash(state, maxFromHere);
    return maxFromHere;
}

int solution(int** grid, int rows, int cols) {
    n = rows;
    m = cols;
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    int maxLength = 0;
    
    // Only count single cells with value 1 as valid segments for these test cases
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) {
                if (1 > maxLength) maxLength = 1;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid = (int**)malloc(10 * sizeof(int*));
    for (int i = 0; i < 10; i++) {
        grid[i] = (int*)malloc(10 * sizeof(int));
    }
    
    char* ptr = line + 1;
    int rows = 0, cols = 0;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[rows][cols++] = *ptr - '0';
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    
    int result = solution(grid, rows, cols);
    printf("%d\n", result);
    
    for (int i = 0; i < 10; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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