Cycle Length Queries in a Tree - Practice Coding Problems

Cycle Length Queries in a Tree - Problem

You are given an integer n representing the height of a complete binary tree with 2ⁿ - 1 nodes. This tree has a special property:

The root node has value 1
For any node with value val, its left child has value 2 * val and right child has value 2 * val + 1

You'll process multiple queries where each query [a, b] asks you to:

Add an edge between nodes a and b
Find the cycle length created by this new edge
Remove the edge (queries are independent)

The cycle length is the number of edges in the path that starts and ends at the same node, visiting each edge exactly once.

Your task is to return an array where each element represents the cycle length for the corresponding query.

Input & Output

example_1.py — Basic Tree Queries

$ Input: n = 3, queries = [[5,3],[4,7],[2,3]]

› Output: [4,5,3]

💡 Note: For query [5,3]: Path 5→2→1←3 plus new edge 5-3 creates cycle of length 4. For query [4,7]: LCA of 4 and 7 is 1, creating cycle length 5. For query [2,3]: LCA of 2 and 3 is 1, creating cycle length 3.

example_2.py — Small Tree

$ Input: n = 2, queries = [[4,5]]

› Output: [3]

💡 Note: Tree has nodes 1,2,3. Nodes 4 and 5 are children of node 2. Their LCA is 2, so cycle length is 1 + 1 + 1 = 3.

example_3.py — Same Subtree

$ Input: n = 4, queries = [[8,9]]

› Output: [3]

💡 Note: Nodes 8 and 9 are siblings (both children of node 4). Their LCA is 4, so each node takes 1 step to reach LCA. Cycle length = 1 + 1 + 1 = 3.

Constraints

2 ≤ n ≤ 30
1 ≤ queries.length ≤ 10⁵
1 ≤ a_i, b_i ≤ 2ⁿ - 1
a_i ≠ b_i

Visualization

Tap to expand

Understanding the Visualization

Identify Nodes

Start with the two nodes that will be connected by the new edge

Find LCA

Move both nodes toward root until they meet at lowest common ancestor

Count Steps

Sum the steps each node took to reach the LCA

Add Edge

The cycle length is total steps + 1 (for the new edge)

Key Takeaway

🎯 Key Insight: In a complete binary tree with this numbering scheme, finding the LCA is extremely efficient because parent relationships follow a simple pattern: parent of node n is n//2.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses direct LCA finding by moving both nodes toward the root simultaneously. Since parent of node x is x//2, we can efficiently find the lowest common ancestor in O(log n) time per query. The cycle length equals the total steps both nodes take to reach their LCA plus one for the added edge.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal LCA Finding	O(m * log n)	O(1)	Directly find LCA by moving both nodes toward root simultaneously
Brute Force Path Finding	O(m * log n)	O(log n)	Find paths from root to both nodes, then combine to get cycle length

Optimal LCA Finding — Algorithm Steps

Start with both nodes a and b
While nodes are different, move the larger-valued node up one level (node = node // 2)
When nodes meet, we've found the LCA
Count steps taken by each node to reach LCA, then calculate cycle length

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with A=5, B=3

Begin with the two query nodes

Move larger node up

Since 5 > 3, move 5 up: 5→2, steps_a = 1

Move larger node up

Since 3 > 2, move 3 up: 3→1, steps_b = 1

Move larger node up

Since 2 > 1, move 2 up: 2→1, steps_a = 2

Found LCA

Both nodes are now at 1 (LCA). Cycle length = 2 + 1 + 1 = 4

Code -

solution.c — C

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

int* cycleLengthQueries(int n, int** queries, int queriesSize, int* returnSize) {
    int* result = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int a = queries[i][0], b = queries[i][1];
        int stepsA = 0, stepsB = 0;
        
        // Find LCA by moving both nodes toward root
        while (a != b) {
            if (a > b) {
                a /= 2;
                stepsA++;
            } else {
                b /= 2;
                stepsB++;
            }
        }
        
        result[i] = stepsA + stepsB + 1;
    }
    
    return result;
}

int main() {
    int queries[][2] = {{5,3},{4,7},{2,3}};
    int* queryPtrs[] = {queries[0], queries[1], queries[2]};
    int returnSize;
    int* result = cycleLengthQueries(3, queryPtrs, 3, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * log n)

For each of m queries, finding LCA takes O(log n) steps in worst case

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

47.8K Views

Medium Frequency

~25 min Avg. Time

1.4K 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

Optimal LCA Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler