Find Closest Node to Given Two Nodes

Tested Python solution for LeetCode 2359 with 18 pytest cases. Generate a practice environment with lcpy.

LeetCode 2359, Medium. Topics: Depth-First Search, Graph Theory. View on LeetCode.

Generate this problem as a practice environment: tested reference solution, 18 parametrized pytest cases, and a playground notebook:

lcpy gen -n 2359   # by problem number
lcpy gen -s find_closest_node_to_given_two_nodes   # by problem name

​

Problem

You are given a directed graph of n nodes numbered from 0 to n - 1, where each node has at most one outgoing edge.

The graph is represented with a given 0-indexed array edges of size n, indicating that there is a directed edge from node i to node edges[i]. If there is no outgoing edge from i, then edges[i] == -1.

You are also given two integers node1 and node2.

Return the index of the node that can be reached from both node1 and node2, such that the maximum between the distance from node1 to that node, and from node2 to that node is minimized. If there are multiple answers, return the node with the smallest index, and if no possible answer exists, return -1.

Note that edges may contain cycles.

​

Examples

Input: edges = [2,2,3,-1], node1 = 0, node2 = 1
Output: 2
Explanation: The distance from node 0 to node 2 is 1, and the distance from node 1 to node 2 is 1. The maximum of those two distances is 1. It can be proven that we cannot get a node with a smaller maximum distance than 1, so we return node 2.

Input: edges = [1,2,-1], node1 = 0, node2 = 2
Output: 2
Explanation: The distance from node 0 to node 2 is 2, and the distance from node 2 to itself is 0. The maximum of those two distances is 2. It can be proven that we cannot get a node with a smaller maximum distance than 2, so we return node 2.

​

Constraints

• n == edges.length
• 2 <= n <= 10^5
• -1 <= edges[i] < n
• edges[i] != i
• 0 <= node1, node2 < n

​

Solution

Reference implementation from solution.py on GitHub, full suite in test_solution.py:

class Solution:
    # Time: O(n)
    # Space: O(n)
    def closest_meeting_node(self, edges: list[int], node1: int, node2: int) -> int:
        def distances(start: int) -> list[int]:
            dist = [-1] * len(edges)
            node = start
            step = 0
            while node != -1 and dist[node] == -1:
                dist[node] = step
                node = edges[node]
                step += 1
            return dist

        dist1 = distances(node1)
        dist2 = distances(node2)
        best_node = -1
        best_max = -1
        for i in range(len(edges)):
            if dist1[i] == -1 or dist2[i] == -1:
                continue
            curr_max = max(dist1[i], dist2[i])
            if best_node == -1 or curr_max < best_max:
                best_node = i
                best_max = curr_max
        return best_node

​

Complexity

Time	Space
O(n)	O(n)

​

Tags

NeetCode All.