Closest Node to Path in Tree - Practice Coding Problems

Closest Node to Path in Tree - Problem

Imagine you're building a GPS navigation system for a tree-structured network where locations are connected by bidirectional roads, forming a perfect tree (no cycles, exactly n-1 edges for n nodes).

You're given:

n nodes numbered from 0 to n-1
edges array defining the tree structure
Multiple queries, each asking: "On the path from point A to point B, which location is closest to point C?"

For each query [start, end, target], you need to find the node on the unique path from start to end that has the minimum distance to the target node.

Goal: Return an array where each element is the closest node on the respective query path.

Input & Output

example_1.py — Basic Tree

$ Input: n = 7, edges = [[0,1],[1,2],[3,1],[4,0],[5,0],[6,0]], queries = [[5,3,4],[5,3,6]]

› Output: [0, 0]

💡 Note: For query [5,3,4]: Path from 5 to 3 is [5,0,1,3]. Distances: 5→4 is 3, 0→4 is 1, 1→4 is 2, 3→4 is 2. Node 0 has minimum distance 1. For query [5,3,6]: Same path [5,0,1,3]. Distances: 5→6 is 2, 0→6 is 1, 1→6 is 2, 3→6 is 3. Node 0 has minimum distance 1.

example_2.py — Linear Tree

$ Input: n = 4, edges = [[0,1],[1,2],[2,3]], queries = [[0,3,1]]

› Output: [1]

💡 Note: For query [0,3,1]: Path from 0 to 3 is [0,1,2,3]. Distances: 0→1 is 1, 1→1 is 0, 2→1 is 1, 3→1 is 2. Node 1 has minimum distance 0.

example_3.py — Single Node Path

$ Input: n = 3, edges = [[0,1],[1,2]], queries = [[1,1,0]]

› Output: [1]

💡 Note: For query [1,1,0]: Path from 1 to 1 is just [1]. Distance 1→0 is 1. So node 1 is the answer.

Visualization

Tap to expand

Understanding the Visualization

Build Trail Map

Create the tree structure representing trail connections between lodges and camps

Query Processing

For each query 'find closest point to C on trail A→B', locate the unique path

Distance Calculation

Check every point on the A→B trail and measure hiking distance to destination C

Optimal Meeting Point

Return the trail point with minimum hiking distance to the target location

Key Takeaway

🎯 Key Insight: In a tree, there's exactly one path between any two nodes. We find this path and check the distance from each path node to our target, returning the node with minimum distance.

Time & Space Complexity

Time Complexity

⏱️

O(m * n²)

For m queries, each query requires O(n) to find path and O(n²) to calculate distances

⚠ Quadratic Growth

Space Complexity

O(n)

Space for BFS queue and storing paths

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ node1_i, node2_i ≤ n - 1
The input represents a valid tree
1 ≤ queries.length ≤ 10⁵
query[i].length == 3
0 ≤ start_i, end_i, node_i ≤ n - 1

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 28

The optimal approach uses LCA (Lowest Common Ancestor) preprocessing with binary lifting to efficiently find paths and calculate distances. After O(n log n) preprocessing, each query can be answered in O(n + log n) time by finding the path via LCA and checking distances from each path node to the target.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS for each query)	O(m * n²)	O(n)	For each query, find the path using BFS, then check distance from each path node to target
LCA with Distance Preprocessing	O(n log n + m * n)	O(n log n)	Preprocess tree with LCA and distance arrays, then efficiently answer queries

Brute Force (BFS for each query) — Algorithm Steps

For each query, use BFS to find path from start to end
Store all nodes on the path in a list
For each node on path, use BFS to calculate distance to target
Return the path node with minimum distance to target

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Path

Use BFS to find the unique path from start to end

Check Each Node

For each node on path, calculate distance to target

Find Minimum

Return the path node with minimum distance to target

Code -

solution.c — C

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

#define MAX_N 1005

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int visited[MAX_N];
int path[MAX_N];
int pathSize;

int bfsDistance(int start, int target, int n) {
    if (start == target) return 0;
    
    int queue[MAX_N * 2][2];
    int front = 0, rear = 0;
    int vis[MAX_N] = {0};
    
    queue[rear][0] = start;
    queue[rear][1] = 0;
    rear++;
    vis[start] = 1;
    
    while (front < rear) {
        int node = queue[front][0];
        int dist = queue[front][1];
        front++;
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!vis[neighbor]) {
                if (neighbor == target) {
                    return dist + 1;
                }
                queue[rear][0] = neighbor;
                queue[rear][1] = dist + 1;
                rear++;
                vis[neighbor] = 1;
            }
        }
    }
    
    return INT_MAX;
}

int dfsPath(int current, int end, int depth) {
    if (current == end) {
        path[depth] = current;
        pathSize = depth + 1;
        return 1;
    }
    
    visited[current] = 1;
    path[depth] = current;
    
    for (int i = 0; i < graphSize[current]; i++) {
        int neighbor = graph[current][i];
        if (!visited[neighbor]) {
            if (dfsPath(neighbor, end, depth + 1)) {
                return 1;
            }
        }
    }
    
    visited[current] = 0;
    return 0;
}

int* closestNode(int n, int** edges, int edgesSize, int** queries, int queriesSize, int* returnSize) {
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int start = queries[i][0];
        int end = queries[i][1];
        int target = queries[i][2];
        
        // Reset visited array
        for (int j = 0; j < n; j++) {
            visited[j] = 0;
        }
        
        // Find path
        dfsPath(start, end, 0);
        
        int minDist = INT_MAX;
        int closest = path[0];
        
        for (int j = 0; j < pathSize; j++) {
            int dist = bfsDistance(path[j], target, n);
            if (dist < minDist) {
                minDist = dist;
                closest = path[j];
            }
        }
        
        result[i] = closest;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n²)

For m queries, each query requires O(n) to find path and O(n²) to calculate distances

⚠ Quadratic Growth

Space Complexity

O(n)

Space for BFS queue and storing paths

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ node1_i, node2_i ≤ n - 1
The input represents a valid tree
1 ≤ queries.length ≤ 10⁵
query[i].length == 3
0 ≤ start_i, end_i, node_i ≤ n - 1

67.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (BFS for each query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler