feat(graphs, bfs): closest node in tree along path

Author: BrianLusina

datastructures/graphs/graph.py

@@ -3,8 +3,8 @@
 from pprint import PrettyPrinter
 from typing import List, Set, Union, Generic, TypeVar
 from datastructures.stacks import Stack
-from .vertex import Vertex
-from .edge import Edge
+from datastructures.graphs.vertex import Vertex
+from datastructures.graphs.edge import Edge
 
 T = TypeVar("T")
 

datastructures/graphs/undirected/README.md

@@ -0,0 +1,31 @@
+# Undirected Graph
+
+## Closest Node to Path in Tree
+
+You are given a positive integer, n, representing the number of nodes in a tree, numbered from `0 to n−1`. You are also 
+given a 2D integer array edges of length `n−1`, where `edges[i] = [ui, vi]` indicates that there is a bidirectional edge 
+connecting nodes `ui` and `vi`.
+
+You are also given a 2D integer array query of length `m`, where `query[i]=[starti ,endi ,nodei]`. For each query i, 
+find the node on the path between `starti` and `endi` that is closest to `nodei` in terms of the number of edges.
+
+Return an integer array where the value at index `i` corresponds to the answer for the `ith` query.
+
+> Note: If there are multiple such nodes at the same minimum distance, return the one with the smallest index.
+
+Constraints
+- `1 ≤ n ≤ 1000`
+- `edges.length == n-1`
+- `edges[i].length == 2`
+- `0 ≤ ui, vi ≤ n-1`
+- `ui != vi`
+- `1 ≤ query.length ≤ 1000`
+- `query[i].length == 3`
+- `0 ≤ starti, endi, nodei ≤ n-1`
+- `the graph is a tree`
+
+### Examples
+
+![Example 1](./images/examples/closest_node_to_path_in_tree_example_1.png)
+![Example 2](./images/examples/closest_node_to_path_in_tree_example_2.png)
+![Example 3](./images/examples/closest_node_to_path_in_tree_example_3.png)

datastructures/graphs/undirected/__init__.py

@@ -1,8 +1,4 @@
-from typing import List
+from datastructures.graphs.undirected.undirected_graph import UndirectedGraph
 
-from datastructures.graphs import Edge, Graph
 
-
-class UnDirectedGraph(Graph):
-    def __init__(self, edge_list: List[Edge]):
-        super(UnDirectedGraph, self).__init__(edge_list)
+__all__ = ["UndirectedGraph"]

datastructures/graphs/undirected/images/examples/closest_node_to_path_in_tree_example_1.png

@@ -0,0 +1,23 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from datastructures.graphs.undirected.utils import closest_node
+
+
+class ClosestNodeToPathInTreeTestCase(unittest.TestCase):
+
+    @parameterized.expand([
+        (3, [[0,1],[1,2]], [[0,2,1]], [1]),
+        (4, [[0,1],[1,2],[1,3]], [[2,3,0]], [1]),
+        (6, [[0,1],[0,2],[0,3],[0,4],[0,5]], [[1,5,2],[2,3,4]], [0,0]),
+        (7, [[0,1],[0,2],[0,3],[1,4],[2,5],[2,6]], [[5,3,4],[5,3,6]], [0,2]),
+        (3, [[0,1],[1,2]], [[0,1,2]], [1]),
+        (3, [[0,1],[1,2]], [[0,0,0]], [0]),
+    ])
+    def test_closest_node(self, n: int, edges: List[List[int]], query: List[List[int]], expected: int):
+        actual = closest_node(n, edges, query)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == '__main__':
+    unittest.main()

datastructures/graphs/undirected/images/examples/closest_node_to_path_in_tree_example_2.png

@@ -0,0 +1,15 @@
+from typing import List, Set
+
+from datastructures.graphs import Edge, Graph, Vertex
+
+
+class UndirectedGraph(Graph):
+
+    def __init__(self, edge_list: List[Edge]):
+        super(UndirectedGraph, self).__init__(edge_list)
+
+    def bfs_from_root_to_target(self, root: Vertex, target: Vertex) -> Set[Vertex]:
+        pass
+
+    def bfs_from_node(self, source: Vertex) -> Set[Vertex]:
+        pass

datastructures/graphs/undirected/images/examples/closest_node_to_path_in_tree_example_3.png

@@ -0,0 +1,94 @@
+from typing import List, DefaultDict, Dict, Optional
+from collections import defaultdict, deque
+
+
+def closest_node(n: int, edges: List[List[int]], query: List[List[int]]) -> List[int]:
+    # build and adjacency list
+    adj_list: DefaultDict[int, List[int]] = defaultdict(list)
+    for u, v in edges:
+        adj_list[u].append(v)
+        adj_list[v].append(u)
+
+    def bfs_distance(start: int) -> List[int]:
+        """
+        Compute the shortest distance from start node to all other nodes using BFS.
+        Returns a list where distances[i] is the distance from start to node i.
+        """
+        # -1 means not visited
+        distances = [-1] * n
+        distances[start] = 0
+        queue = deque([start])
+
+        while queue:
+            node = queue.popleft()
+            for neighbor in adj_list[node]:
+                if distances[neighbor] == -1:  # Not visited
+                    distances[neighbor] = distances[node] + 1
+                    queue.append(neighbor)
+
+        return distances
+
+    def find_path(start: int, end: int) -> List[int]:
+        """
+        Find the unique path from start to end in the tree using BFS.
+        Returns the list of nodes on the path (including start and end).
+        """
+        if start == end:
+            return [start]
+
+        # BFS to find path, keeping track of parent pointers
+        parent: Dict[int, Optional[int]] = {start: None}
+        queue = deque([start])
+
+        while queue:
+            node = queue.popleft()
+            if node == end:
+                break
+
+            for neighbor in adj_list[node]:
+                # not visited
+                if neighbor not in parent:
+                    parent[neighbor] = node
+                    queue.append(neighbor)
+
+        # Reconstruct path from end to start using pointers
+        path = []
+        current = end
+        # Add safety check: limit iterations to avoid infinite loops
+        # In a tree with n nodes, path length can't exceed n
+        for _ in range(n):
+            if current not in parent:
+                # This shouldn't happen in a valid connected tree
+                break
+            path.append(current)
+            if current == start:
+                # We've reached the start, we're done
+                break
+            current = parent[current]
+
+        # reverse to get the path start to end
+        return path[::-1]
+
+    result = []
+    for start, end, target in query:
+        # find the path from start to end
+        found_path = find_path(start, end)
+
+        # compute distances from target node to all nodes
+        distances_from_target = bfs_distance(target)
+
+        # Find the node on the path with minimum distance to target
+        # If there's a tie, we want the one with the smallest index
+        min_distance = float('inf')
+        closest = -1
+
+        for node in found_path:
+            dist = distances_from_target[node]
+            # Update if we found a closer node, or same distance but smaller index
+            if dist < min_distance or (dist == min_distance and node < closest):
+                min_distance = dist
+                closest = node
+
+        result.append(closest)
+
+    return result