Closest Node to Path in Tree

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.

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

Visualization

Tap to expand

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

✓ One Pass Hash

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

Brute Force (BFS for each query)

⏱️ Time: O(m * n²) Space: O(n)

For each query, we first find the unique path from start to end using BFS, store all nodes on this path, then for each node on the path, calculate its distance to the target node using another BFS. Finally, return the path node with minimum distance to target.

LCA with Distance Preprocessing

⏱️ Time: O(n log n + m * n) Space: O(n log n)

This approach preprocesses the tree to support fast LCA (Lowest Common Ancestor) queries and distance calculations. For each query, we find the path using LCA, then calculate distances from each path node to the target efficiently using precomputed distances from root.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

void dfs(int** grid, int gridSize, int gridColSize, int r, int c, int originalColor) {
    grid[r][c] = -originalColor;
    bool isBorder = false;
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        
        if (nr < 0 || nr >= gridSize || nc < 0 || nc >= gridColSize ||
            abs_val(grid[nr][nc]) != originalColor) {
            isBorder = true;
        } else if (grid[nr][nc] == originalColor) {
            dfs(grid, gridSize, gridColSize, nr, nc, originalColor);
        }
    }
    
    if (!isBorder) {
        grid[r][c] = originalColor;
    }
}

int** colorBorder(int** grid, int gridSize, int* gridColSize, int row, int col, int color, int* returnSize, int** returnColumnSizes) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        *returnSize = gridSize;
        *returnColumnSizes = gridColSize;
        return grid;
    }
    
    int originalColor = grid[row][col];
    
    if (originalColor == color) {
        *returnSize = gridSize;
        *returnColumnSizes = gridColSize;
        return grid;
    }
    
    dfs(grid, gridSize, gridColSize[0], row, col, originalColor);
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[0]; j++) {
            if (grid[i][j] < 0) {
                grid[i][j] = color;
            }
        }
    }
    
    *returnSize = gridSize;
    *returnColumnSizes = gridColSize;
    return grid;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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