



import sys
from collections import defaultdict



class      _UpperCAmelCase      :




     def __init__(					self):
         A__					=       []




     def 		snake_case_		(					self			,    a__):
         return self.node_position[vertex]




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       pos




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__):
         if start > size // 2 - 1:
             return
         else:
             if 2 * start + 2 >= size:
                 A__					=       2 * start + 1
             else:
                 if heap[2 * start + 1] < heap[2 * start + 2]:
                     A__					=       2 * start + 1
                 else:
                     A__					=       2 * start + 2
             if heap[smallest_child] < heap[start]:
                 A__			,						A__					=       heap[smallest_child], positions[smallest_child]
                 A__			,						A__					=       (
                     heap[start],
                     positions[start],
                 )
                 A__			,						A__					=       temp, tempa

                 A__					=       self.get_position(positions[smallest_child])
                 self.set_position(
                     positions[smallest_child]			,    self.get_position(positions[start]))
                 self.set_position(positions[start]			,    a__)

                 self.top_to_bottom(a__			,    a__			,    a__			,    a__)




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__):
         A__					=       position[index]

         while index != 0:
             A__					=       int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2)

             if val < heap[parent]:
                 A__					=       heap[parent]
                 A__					=       position[parent]
                 self.set_position(position[parent]			,    a__)
             else:
                 A__					=       val
                 A__					=       temp
                 self.set_position(a__			,    a__)
                 break
             A__					=       parent
         else:
             A__					=       val
             A__					=       temp
             self.set_position(a__			,    0)




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       len(a__) // 2 - 1
         for i in range(a__			,    -1			,    -1):
             self.top_to_bottom(a__			,    a__			,    len(a__)			,    a__)




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       positions[0]
         A__					=       sys.maxsize
         self.top_to_bottom(a__			,    0			,    len(a__)			,    a__)
         return temp







def 		lowerCAmelCase__     (       UpperCamelCase_					:							Optional[Any]						)->	int:
    A__					=       Heap()

    A__					=       [0] * len(UpperCamelCase_						)
    A__					=       [-1] * len(UpperCamelCase_						)  # Neighboring Tree Vertex of selected vertex
    # Minimum Distance of explored vertex with neighboring vertex of partial tree
    # formed in graph
    A__					=       []  # Heap of Distance of vertices from their neighboring vertex
    A__					=       []

    for vertex in range(len(UpperCamelCase_						)						):
        distance_tv.append(sys.maxsize						)
        positions.append(UpperCamelCase_						)
        heap.node_position.append(UpperCamelCase_						)

    A__					=       []
    A__					=       1
    A__					=       sys.maxsize
    for neighbor, distance in adjacency_list[0]:
        A__					=       0
        A__					=       distance
    heap.heapify(UpperCamelCase_			,							UpperCamelCase_						)

    for _ in range(1			,							len(UpperCamelCase_						)						):
        A__					=       heap.delete_minimum(UpperCamelCase_			,							UpperCamelCase_						)
        if visited[vertex] == 0:
            tree_edges.append((nbr_tv[vertex], vertex)						)
            A__					=       1
            for neighbor, distance in adjacency_list[vertex]:
                if (
                    visited[neighbor] == 0
                    and distance < distance_tv[heap.get_position(UpperCamelCase_						)]
                ):
                    A__					=       distance
                    heap.bottom_to_top(
                        UpperCamelCase_			,							heap.get_position(UpperCamelCase_						)			,							UpperCamelCase_			,							UpperCamelCase_						)
                    A__					=       vertex
    return tree_edges


if __name__ == "__main__":  # pragma: no cover
   # < --------- Prims Algorithm --------- >
   _lowercase    	=		int(input("Enter number of edges: ").strip())
   _lowercase    	=		defaultdict(list)
   for _ in range(edges_number):
      _lowercase    	=		[int(x) for x in input().strip().split()]
      adjacency_list[edge[0]].append([edge[1], edge[2]])
      adjacency_list[edge[1]].append([edge[0], edge[2]])
   print(prisms_algorithm(adjacency_list))





from manim import *



class      _UpperCAmelCase      (							A__  ):




     def 		snake_case_		(					self):
         A__					=       Rectangle(height=0.5			,    width=0.5)
         A__					=       Rectangle(height=0.2_5			,    width=0.2_5)
         A__					=       Rectangle(height=0.4_6			,    width=0.4_6).set_stroke(width=0)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(a__			,    a__).arrange(a__			,    buff=0)
         A__					=       Text('''CPU'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         cpu.move_to([-2.5, -0.5, 0])
         self.add(a__)

         A__					=       [mem.copy() for i in range(4)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       Text('''GPU'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         gpu.move_to([-1, -1, 0])
         self.add(a__)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)

         A__					=       Text('''Model'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         model.move_to([3, -1.0, 0])
         self.add(a__)

         A__					=       []
         A__					=       []
         A__					=       []

         for i, rect in enumerate(a__):
             rect.set_stroke(a__)

             A__					=       Rectangle(height=0.4_6 / 4			,    width=0.4_6 / 3).set_stroke(width=0.0).set_fill(a__			,    opacity=0.7)

             if i == 0:
                 cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)			,    buff=0.0_2			,    direction=a__)
                 cpu_target.set_x(cpu_target.get_x() + 0.1)
             elif i == 3:
                 cpu_target.next_to(model_cpu_arr[0]			,    direction=a__			,    buff=0.0)
             else:
                 cpu_target.next_to(model_cpu_arr[i - 1]			,    direction=a__			,    buff=0.0)
             self.add(a__)
             model_cpu_arr.append(a__)

         self.add(*a__			,    *a__			,    *a__)

         A__					=       [mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)

         A__					=       Text('''Loaded Checkpoint'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         checkpoint.move_to([3, 0.5, 0])

         self.add(a__)

         A__					=       []
         A__					=       []

         for i, rect in enumerate(a__):
             A__					=       fill.copy().set_fill(a__			,    opacity=0.7)
             target.move_to(a__)
             ckpt_arr.append(a__)

             A__					=       target.copy()
             if i < 5:
                 cpu_target.move_to(cpu_left_col_base[i + 1])
             else:
                 cpu_target.move_to(cpu_right_col_base[i - 5])
             ckpt_cpu_arr.append(a__)
         self.add(*a__			,    *a__)

         A__					=       Square(side_length=2.2)
         key.move_to([-5, 2, 0])

         A__					=       MarkupText(
             F"<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"			,    font_size=1_8			,    )

         key_text.move_to([-5, 2.4, 0])

         self.add(a__			,    a__)

         A__					=       MarkupText(
             F"<span fgcolor='{BLUE}'>●</span> Checkpoint"			,    font_size=1_8			,    )

         blue_text.next_to(a__			,    DOWN * 2.4			,    aligned_edge=key_text.get_left())
         self.add(a__)

         A__					=       MarkupText(
             F"Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device."			,    font_size=2_4			,    )
         step_a.move_to([2, 2, 0])

         A__					=       [meta_mem.copy() for i in range(6)]
         A__					=       [meta_mem.copy() for i in range(6)]
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(*a__).arrange(a__			,    buff=0)
         A__					=       VGroup(a__			,    a__).arrange(a__			,    buff=0)
         A__					=       Text('''Disk'''			,    font_size=2_4)
         A__					=       Group(a__			,    a__).arrange(a__			,    buff=0.5			,    aligned_edge=a__)
         disk.move_to([-4.0, -1.2_5, 0])
         self.play(Write(a__			,    run_time=3)			,    Write(a__			,    run_time=1)			,    Create(a__			,    run_time=1))

         A__					=       []
         for i, rect in enumerate(a__):
             A__					=       rect.copy()
             target.generate_target()
             target.target.move_to(disk_left_col_base[i]).scale(0.5)
             animations.append(MoveToTarget(a__			,    run_time=1.5))
         self.play(*a__)

         self.play(FadeOut(a__))

         A__					=       MarkupText(F"Then, the checkpoint is removed from memory\nthrough garbage collection."			,    font_size=2_4)
         step_a.move_to([2, 2, 0])

         self.play(Write(a__			,    run_time=3))

         self.play(
             FadeOut(a__			,    a__			,    *a__			,    *a__)			,    )

         self.wait()
