




def       UpperCAmelCase__  (     lowerCamelCase   ):
  lowercase    :Union[str, Any]      	=						set()
  # edges = list of graph's edges
  lowercase    :int      	=						get_edges(lowerCamelCase   )

  # While there are still elements in edges list, take an arbitrary edge
  # (from_node, to_node) and add his extremity to chosen_vertices and then
  # remove all arcs adjacent to the from_node and to_node
  while edges:
    lowercase    :Any      	=						edges.pop()
    chosen_vertices.add(lowerCamelCase   )
    chosen_vertices.add(lowerCamelCase   )
    for edge in edges.copy():
      if from_node in edge or to_node in edge:
        edges.discard(lowerCamelCase   )
  return chosen_vertices



def       UpperCAmelCase__  (     lowerCamelCase   ):
  lowercase    :int      	=						set()
  for from_node, to_nodes in graph.items():
    for to_node in to_nodes:
      edges.add((from_node, to_node)   )
  return edges


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
     # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")









from collections import defaultdict

from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst



def       UpperCAmelCase__  (     ):
  lowercase	,    lowercase    :Union[str, Any]      	=						9, 14  # noqa: F841
  lowercase    :Optional[Any]      	=						[
      [0, 1, 4],
      [0, 7, 8],
      [1, 2, 8],
      [7, 8, 7],
      [7, 6, 1],
      [2, 8, 2],
      [8, 6, 6],
      [2, 3, 7],
      [2, 5, 4],
      [6, 5, 2],
      [3, 5, 14],
      [3, 4, 9],
      [5, 4, 10],
      [1, 7, 11],
  ]

  lowercase    :Optional[Any]      	=						defaultdict(lowerCamelCase   )
  for nodea, nodea, cost in edges:
    adjancency[nodea].append([nodea, cost]   )
    adjancency[nodea].append([nodea, cost]   )

  lowercase    :Optional[int]      	=						mst(lowerCamelCase   )

  lowercase    :Any      	=						[
      [7, 6, 1],
      [2, 8, 2],
      [6, 5, 2],
      [0, 1, 4],
      [2, 5, 4],
      [2, 3, 7],
      [0, 7, 8],
      [3, 4, 9],
  ]

  for answer in expected:
    lowercase    :Any      	=						tuple(answer[:2]   )
    lowercase    :str      	=						tuple(edge[::-1]   )
    assert edge in result or reverse in result



