






import heapq as hq
import math
from collections.abc import Iterator

class 		_snake_case	:






			def __init__(							self		,       a)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE							=			str(id_)
						SCREAMING_SNAKE_CASE							=			None
						SCREAMING_SNAKE_CASE							=			None
						SCREAMING_SNAKE_CASE							=			[]
						SCREAMING_SNAKE_CASE							=			{}  # {vertex:distance}






			def __lt__(							self		,       a)   ->							Dict:
						return self.key < other.key






			def __repr__(							self)   ->							Optional[Any]:
						return self.id






			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Optional[Any]:
						self.neighbors.append(a)







			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a)   ->							Tuple:
						SCREAMING_SNAKE_CASE							=			weight






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase				,							_UpperCAmelCase				,							_UpperCAmelCase):
			# add the neighbors:
			graph[a - 1].add_neighbor(graph[b - 1])
			graph[b - 1].add_neighbor(graph[a - 1])
			# add the edges:
			graph[a - 1].add_edge(graph[b - 1]				,							_UpperCAmelCase)
			graph[b - 1].add_edge(graph[a - 1]				,							_UpperCAmelCase)






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase):
			SCREAMING_SNAKE_CASE							=			[]
			for u in graph:
						SCREAMING_SNAKE_CASE							=			math.inf
						SCREAMING_SNAKE_CASE							=			None
			SCREAMING_SNAKE_CASE							=			0
			SCREAMING_SNAKE_CASE							=			graph[:]
			while q:
						SCREAMING_SNAKE_CASE							=			min(_UpperCAmelCase)
						q.remove(_UpperCAmelCase)
						for v in u.neighbors:
									if (v in q) and (u.edges[v.id] < v.key):
												SCREAMING_SNAKE_CASE							=			u
												SCREAMING_SNAKE_CASE							=			u.edges[v.id]
			for i in range(1				,							len(_UpperCAmelCase)):
						a.append((int(graph[i].id) + 1, int(graph[i].pi.id) + 1))
			return a






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase):
			for u in graph:
						SCREAMING_SNAKE_CASE							=			math.inf
						SCREAMING_SNAKE_CASE							=			None
			SCREAMING_SNAKE_CASE							=			0

			SCREAMING_SNAKE_CASE							=			list(_UpperCAmelCase)
			hq.heapify(_UpperCAmelCase)

			while h:
						SCREAMING_SNAKE_CASE							=			hq.heappop(_UpperCAmelCase)
						for v in u.neighbors:
									if (v in h) and (u.edges[v.id] < v.key):
												SCREAMING_SNAKE_CASE							=			u
												SCREAMING_SNAKE_CASE							=			u.edges[v.id]
												hq.heapify(_UpperCAmelCase)

			for i in range(1				,							len(_UpperCAmelCase)):
						yield (int(graph[i].id) + 1, int(graph[i].pi.id) + 1)






def 					lowerCamelCase__					():
			pass


if __name__ == "__main__":
				import doctest

				doctest.testmod()









from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def 	_lowerCAmelCase (    ):
      import os as original_os
      from os import path as original_path
      from os import rename as original_rename
      from os.path import dirname as original_dirname
      from os.path import join as original_join

      assert _test_patching.os is original_os
      assert _test_patching.path is original_path
      assert _test_patching.join is original_join

      assert _test_patching.renamed_os is original_os
      assert _test_patching.renamed_path is original_path
      assert _test_patching.renamed_join is original_join

      lowercase__  =	'__test_patch_submodule_mock__'
      with patch_submodule(_test_patching    ,	'os.path.join'    ,	A__						):
            # Every way to access os.path.join must be patched, and the rest must stay untouched

            # check os.path.join
            assert isinstance(_test_patching.os    ,	_PatchedModuleObj						)
            assert isinstance(_test_patching.os.path    ,	_PatchedModuleObj						)
            assert _test_patching.os.path.join is mock

            # check path.join
            assert isinstance(_test_patching.path    ,	_PatchedModuleObj						)
            assert _test_patching.path.join is mock

            # check join
            assert _test_patching.join is mock

            # check that the other attributes are untouched
            assert _test_patching.os.rename is original_rename
            assert _test_patching.path.dirname is original_dirname
            assert _test_patching.os.path.dirname is original_dirname

            # Even renamed modules or objects must be patched

            # check renamed_os.path.join
            assert isinstance(_test_patching.renamed_os    ,	_PatchedModuleObj						)
            assert isinstance(_test_patching.renamed_os.path    ,	_PatchedModuleObj						)
            assert _test_patching.renamed_os.path.join is mock

            # check renamed_path.join
            assert isinstance(_test_patching.renamed_path    ,	_PatchedModuleObj						)
            assert _test_patching.renamed_path.join is mock

            # check renamed_join
            assert _test_patching.renamed_join is mock

            # check that the other attributes are untouched
            assert _test_patching.renamed_os.rename is original_rename
            assert _test_patching.renamed_path.dirname is original_dirname
            assert _test_patching.renamed_os.path.dirname is original_dirname

      # check that everthing is back to normal when the patch is over

      assert _test_patching.os is original_os
      assert _test_patching.path is original_path
      assert _test_patching.join is original_join

      assert _test_patching.renamed_os is original_os
      assert _test_patching.renamed_path is original_path
      assert _test_patching.renamed_join is original_join

def 	_lowerCAmelCase (    ):
      assert _test_patching.open is open

      lowercase__  =	'__test_patch_submodule_builtin_mock__'
      # _test_patching has "open" in its globals
      assert _test_patching.open is open
      with patch_submodule(_test_patching    ,	'open'    ,	A__						):
            assert _test_patching.open is mock

      # check that everthing is back to normal when the patch is over

      assert _test_patching.open is open

def 	_lowerCAmelCase (    ):
      # pandas.read_csv is not present in _test_patching
      lowercase__  =	'__test_patch_submodule_missing_mock__'
      with patch_submodule(_test_patching    ,	'pandas.read_csv'    ,	A__						):
            pass

def 	_lowerCAmelCase (    ):
      # builtin should always be mocked even if they're not in the globals
      # in case they're loaded at one point
      lowercase__  =	'__test_patch_submodule_missing_builtin_mock__'
      # _test_patching doesn't have "len" in its globals
      assert getattr(_test_patching    ,	'len'    ,	A__						) is None
      with patch_submodule(_test_patching    ,	'len'    ,	A__						):
            assert _test_patching.len is mock
      assert _test_patching.len is len

def 	_lowerCAmelCase (    ):
      lowercase__  =	'__test_patch_submodule_start_and_stop_mock__'
      lowercase__  =	patch_submodule(_test_patching    ,	'open'    ,	A__						)
      assert _test_patching.open is open
      patch.start()
      assert _test_patching.open is mock
      patch.stop()
      assert _test_patching.open is open

def 	_lowerCAmelCase (    ):
      from os import rename as original_rename
      from os.path import dirname as original_dirname
      from os.path import join as original_join

      lowercase__  =	'__test_patch_submodule_successive_join__'
      lowercase__  =	'__test_patch_submodule_successive_dirname__'
      lowercase__  =	'__test_patch_submodule_successive_rename__'
      assert _test_patching.os.path.join is original_join
      assert _test_patching.os.path.dirname is original_dirname
      assert _test_patching.os.rename is original_rename

      with patch_submodule(_test_patching    ,	'os.path.join'    ,	A__						):
            with patch_submodule(_test_patching    ,	'os.rename'    ,	A__						):
                  with patch_submodule(_test_patching    ,	'os.path.dirname'    ,	A__						):
                        assert _test_patching.os.path.join is mock_join
                        assert _test_patching.os.path.dirname is mock_dirname
                        assert _test_patching.os.rename is mock_rename

    # try another order
      with patch_submodule(_test_patching    ,	'os.rename'    ,	A__						):
            with patch_submodule(_test_patching    ,	'os.path.join'    ,	A__						):
                  with patch_submodule(_test_patching    ,	'os.path.dirname'    ,	A__						):
                        assert _test_patching.os.path.join is mock_join
                        assert _test_patching.os.path.dirname is mock_dirname
                        assert _test_patching.os.rename is mock_rename

      assert _test_patching.os.path.join is original_join
      assert _test_patching.os.path.dirname is original_dirname
      assert _test_patching.os.rename is original_rename

def 	_lowerCAmelCase (    ):
      lowercase__  =	'__test_patch_submodule_doesnt_exist_mock__'
      with patch_submodule(_test_patching    ,	'__module_that_doesn_exist__.__attribute_that_doesn_exist__'    ,	A__						):
            pass
      with patch_submodule(_test_patching    ,	'os.__attribute_that_doesn_exist__'    ,	A__						):
            pass
