def closest_node_to_path_brute_force(tree, path, start_node): 
    path_nodes = set(path)
    min_distance = float('inf')
    closest_node = None

    # Iterate through each node in the tree
    for current_node in tree:
        # Calculate the distance to the closest node on the path
        current_min_distance = float('inf')
        for target_node in path_nodes:
            distance = find_distance(tree, current_node, target_node)
            current_min_distance = min(current_min_distance, distance)

        # Update the minimum distance and closest node if needed
        if current_min_distance < min_distance:

            #If we find a closer node update values
            min_distance = current_min_distance
            closest_node = current_node
        elif current_min_distance == min_distance:
            #if the same distance pick one node
            pass

    return closest_node

def find_distance(tree, start_node, end_node):
    if start_node == end_node:
        return 0

    visited = {start_node}
    queue = [(start_node, 0)]

    while queue:
        node, distance = queue.pop(0)
        for neighbor in get_neighbors(tree, node):
            if neighbor == end_node:
                return distance + 1
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, distance + 1))

    return float('inf')

def get_neighbors(tree, node):
    neighbors = []
    for start, end in tree:
        if start == node:
            neighbors.append(end)
        if end == node:
            neighbors.append(start)
    return neighbors

from collections import deque

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def closest_node_to_path(root_node, start_node, end_node):
    path_nodes = find_path(root_node, start_node, end_node)

    if not path_nodes:
        return None

    queue = deque([(node, 0) for node in path_nodes])
    visited_nodes = set(path_nodes)

    # Begin BFS to find the closest node.
    while queue:
        current_node, distance = queue.popleft()

        if current_node.left and current_node.left not in visited_nodes:
            return current_node.left

        if current_node.right and current_node.right not in visited_nodes:
            return current_node.right

        if current_node.left:
            queue.append((current_node.left, distance + 1))
            visited_nodes.add(current_node.left)

        if current_node.right:
            queue.append((current_node.right, distance + 1))
            visited_nodes.add(current_node.right)

    return None

def find_path(root_node, start_node, end_node):
    path_nodes = []
    path_found = find_path_recursive(root_node, start_node, end_node, path_nodes)

    if path_found:
        return path_nodes
    else:
        return []

def find_path_recursive(current_node, start_node, end_node, path_nodes):
    if not current_node:
        return False

    path_nodes.append(current_node)

    if current_node == end_node:
        return True

    # Prioritize left subtree exploration.
    if current_node.left and find_path_recursive(current_node.left, start_node, end_node, path_nodes):
        return True

    # Then explore the right subtree.
    if current_node.right and find_path_recursive(current_node.right, start_node, end_node, path_nodes):
        return True

    # Backtrack if neither subtree leads to the end node.
    path_nodes.pop()
    return False