"""simple docstring"""






import sys
from collections import defaultdict





class  _A						:

      def __init__(						self						):







            """simple docstring"""



            lowercase														=	[]

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            return self.node_position[vertex]

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	pos

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



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

                        lowercase														=	self.get_position(positions[smallest_child]						)
                        self.set_position(
                            positions[smallest_child]		,       self.get_position(positions[start]						)						)
                        self.set_position(positions[start]		,       __lowerCAmelCase						)

                        self.top_to_bottom(__lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	position[index]

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

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

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	len(__lowerCAmelCase						) // 2 - 1
            for i in range(__lowerCAmelCase		,       -1		,       -1						):
                  self.top_to_bottom(__lowerCAmelCase		,       __lowerCAmelCase		,       len(__lowerCAmelCase						)		,       __lowerCAmelCase						)







      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	positions[0]
            lowercase														=	sys.maxsize
            self.top_to_bottom(__lowerCAmelCase		,       0		,       len(__lowerCAmelCase						)		,       __lowerCAmelCase						)
            return temp






def 			UpperCAmelCase__       (				lowerCAmelCase__     :Optional[int]		) ->    List[Any]:
      '''simple docstring'''


      lowercase														=	Heap()

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

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

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

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


if __name__ == "__main__":  # pragma: no cover
       # < --------- Prims Algorithm --------- >
       __lowerCAmelCase    :       str					     =int(input("""Enter number of edges: """).strip())
       __lowerCAmelCase    :       Tuple					     =defaultdict(list)
       for _ in range(edges_number):
              __lowerCAmelCase    :       Dict					     =[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))




"""simple docstring"""






from __future__ import annotations

from scipy.special import comb  # type: ignore





class  _A						:

      def __init__(						self		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	list_of_points
            # Degree determines the flexibility of the curve.
            # Degree = 1 will produce a straight line.
            lowercase														=	len(__lowerCAmelCase						) - 1

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            assert 0 <= t <= 1, "Time t must be between 0 and 1."
            lowercase														=	[]
            for i in range(len(self.list_of_points						)						):
                  # basis function for each i
                  output_values.append(
                      comb(self.degree		,       __lowerCAmelCase						) * ((1 - t) ** (self.degree - i)) * (t**i)						)
            # the basis must sum up to 1 for it to produce a valid Bezier curve.
            assert round(sum(__lowerCAmelCase						)		,       5						) == 1
            return output_values

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            assert 0 <= t <= 1, "Time t must be between 0 and 1."

            lowercase														=	self.basis_function(__lowerCAmelCase						)
            lowercase														=	0.0
            lowercase														=	0.0
            for i in range(len(self.list_of_points						)						):
                  # For all points, sum up the product of i-th basis function and i-th point.
                  x += basis_function[i] * self.list_of_points[i][0]
                  y += basis_function[i] * self.list_of_points[i][1]
            return (x, y)







      def 				A__       (						self		,       __lowerCAmelCase = 0.0_1						):







            """simple docstring"""



            from matplotlib import pyplot as plt  # type: ignore

            lowercase														=	[]  # x coordinates of points to plot
            lowercase														=	[]  # y coordinates of points to plot

            lowercase														=	0.0
            while t <= 1:
                  lowercase														=	self.bezier_curve_function(__lowerCAmelCase						)
                  to_plot_x.append(value[0]						)
                  to_plot_y.append(value[1]						)
                  t += step_size

            lowercase														=	[i[0] for i in self.list_of_points]
            lowercase														=	[i[1] for i in self.list_of_points]

            plt.plot(
                __lowerCAmelCase		,       __lowerCAmelCase		,       color="""blue"""		,       label="""Curve of Degree """ + str(self.degree						)		,       )
            plt.scatter(__lowerCAmelCase		,       __lowerCAmelCase		,       color="""red"""		,       label="""Control Points"""						)
            plt.legend()
            plt.show()


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       BezierCurve([(1, 2), (3, 5)]).plot_curve()  # degree 1
       BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve()  # degree 2
       BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve()  # degree 3



