Find Closest Node to Given Two Nodes - Practice Coding Problems

Find Closest Node to Given Two Nodes - Problem

Imagine you're navigating through a unique road network where each intersection has at most one outgoing road. This creates an interesting graph structure that might contain cycles or dead ends!

You're given a directed graph of n nodes numbered from 0 to n-1. The graph is represented by an array edges where edges[i] tells you which node you can reach from node i. If there's no outgoing edge from node i, then edges[i] = -1.

Your mission: Find a meeting point that both node1 and node2 can reach, such that the maximum distance either traveler needs to walk is minimized. If multiple meeting points exist with the same optimal distance, choose the one with the smallest index.

Key Challenge: The graph may contain cycles, so you need to handle infinite loops carefully!

Input & Output

example_1.py — Basic Path

$ Input: edges = [2,2,3,-1], node1 = 0, node2 = 1

› Output: 2

💡 Note: Node 0 can reach node 2 in 1 step (0→2). Node 1 can reach node 2 in 1 step (1→2). The maximum distance is max(1,1) = 1, making node 2 the optimal meeting point.

example_2.py — Cycle Handling

$ Input: edges = [1,2,0,-1], node1 = 0, node2 = 2

› Output: 1

💡 Note: There's a cycle 0→1→2→0. From node 0: reaches node 1 in 1 step, node 2 in 2 steps. From node 2: reaches node 0 in 1 step, node 1 in 2 steps. Node 1 gives max(1,2) = 2, node 0 gives max(2,1) = 2. Node 1 has smaller index, so answer is 1.

example_3.py — No Common Node

$ Input: edges = [1,-1], node1 = 0, node2 = 1

› Output: -1

💡 Note: Node 0 can reach node 1, but node 1 has no outgoing edge and cannot reach node 0. There's no node that both can reach, so return -1.

Constraints

n == edges.length
2 ≤ n ≤ 10⁵
edges[i] == -1 or 0 ≤ edges[i] < n
edges[i] != i (no self-loops in input)
0 ≤ node1, node2 < n

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Each node has at most one outgoing edge, creating chains and cycles

Calculate Distances

Use BFS from both starting points to find distances to all reachable nodes

Find Common Nodes

Identify nodes that both travelers can reach

Minimize Maximum

Choose the meeting point that minimizes the longer of the two journeys

Key Takeaway

🎯 Key Insight: Use BFS to efficiently compute distances while handling cycles, then minimize the maximum distance to ensure fair meeting point for both travelers.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 20

The optimal approach uses two-pass BFS to compute distance maps from both starting nodes, then finds the meeting point that minimizes the maximum distance. This achieves O(n) time complexity by visiting each node at most twice, significantly better than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Nodes)	O(n²)	O(n)	Check every node as a potential meeting point by computing distances from both starting nodes
Two-Pass BFS with Distance Maps	O(n)	O(n)	Build distance maps from both starting nodes, then find the optimal meeting point

Brute Force (Check All Nodes) — Algorithm Steps

For each node i from 0 to n-1:
Calculate distance from node1 to node i (if reachable)
Calculate distance from node2 to node i (if reachable)
If both can reach node i, update the best meeting point based on max(dist1, dist2)
Return the node with smallest index among optimal solutions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with node 0

Calculate distances from both starting nodes to node 0

Check node 1

Calculate distances from both starting nodes to node 1

Continue for all nodes

Repeat for every possible meeting point

Find minimum

Choose the node with minimum maximum distance

Code -

solution.c — C

int getDistance(int* edges, int n, int start, int target) {
    if (start == target) return 0;
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int current = start;
    int distance = 0;
    
    while (current != -1 && !visited[current]) {
        visited[current] = true;
        current = edges[current];
        distance++;
        if (current == target) {
            free(visited);
            return distance;
        }
    }
    free(visited);
    return INT_MAX;
}

int closestMeetingNode(int* edges, int edgesSize, int node1, int node2) {
    int minMaxDist = INT_MAX;
    int result = -1;
    
    for (int i = 0; i < edgesSize; i++) {
        int dist1 = getDistance(edges, edgesSize, node1, i);
        int dist2 = getDistance(edges, edgesSize, node2, i);
        
        if (dist1 != INT_MAX && dist2 != INT_MAX) {
            int maxDist = (dist1 > dist2) ? dist1 : dist2;
            if (maxDist < minMaxDist) {
                minMaxDist = maxDist;
                result = i;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse up to n edges to calculate distance

⚠ Quadratic Growth

Space Complexity

O(n)

Only need space to track visited nodes during path traversal to detect cycles

⚡ Linearithmic Space

35.0K Views

Medium-High Frequency

~25 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

Brute Force (Check All Nodes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler