





import sys
from collections import defaultdict







class     __lowerCAmelCase	:







      def __init__(   self							)       ->						int:



        '''simple docstring'''




        a__     : Optional[Any]  =[]







      def        _lowercase  (   self		,				lowerCAmelCase__							)       ->						str:



        '''simple docstring'''




        return self.node_position[vertex]







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						int:



        '''simple docstring'''




        a__     : str  =pos







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						Optional[int]:



        '''simple docstring'''




        if start > size // 2 - 1:
          return
        else:
          if 2 * start + 2 >= size:
            a__     : Optional[int]  =2 * start + 1
          else:
            if heap[2 * start + 1] < heap[2 * start + 2]:
              a__     : Dict  =2 * start + 1
            else:
              a__     : List[Any]  =2 * start + 2
          if heap[smallest_child] < heap[start]:
            a__ ,							a__     : Optional[Any]  =heap[smallest_child], positions[smallest_child]
            a__ ,							a__     : Tuple  =(
                heap[start],
                positions[start],
            )
            a__ ,							a__     : Tuple  =temp, tempa

            a__     : Any  =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        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						Tuple:



        '''simple docstring'''




        a__     : List[str]  =position[index]

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

          if val < heap[parent]:
            a__     : Union[str, Any]  =heap[parent]
            a__     : List[str]  =position[parent]
            self.set_position(position[parent]		,				lowerCAmelCase__							)
          else:
            a__     : Tuple  =val
            a__     : Optional[int]  =temp
            self.set_position(lowerCAmelCase__		,				lowerCAmelCase__							)
            break
          a__     : Optional[int]  =parent
        else:
          a__     : int  =val
          a__     : List[str]  =temp
          self.set_position(lowerCAmelCase__		,				0							)







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						List[Any]:



        '''simple docstring'''




        a__     : str  =len(lowerCAmelCase__							) // 2 - 1
        for i in range(lowerCAmelCase__		,				-1		,				-1							):
          self.top_to_bottom(lowerCAmelCase__		,				lowerCAmelCase__		,				len(lowerCAmelCase__							)		,				lowerCAmelCase__							)







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						Dict:



        '''simple docstring'''




        a__     : Optional[Any]  =positions[0]
        a__     : Tuple  =sys.maxsize
        self.top_to_bottom(lowerCAmelCase__		,				0		,				len(lowerCAmelCase__							)		,				lowerCAmelCase__							)
        return temp
def 					_A	(		SCREAMING_SNAKE_CASE					:       str						):





  """simple docstring"""



  a__     : int  =Heap()

  a__     : List[str]  =[0] * len(SCREAMING_SNAKE_CASE						)
  a__     : List[Any]  =[-1] * len(SCREAMING_SNAKE_CASE						)  # Neighboring Tree Vertex of selected vertex
  # Minimum Distance of explored vertex with neighboring vertex of partial tree
  # formed in graph
  a__     : Optional[Any]  =[]  # Heap of Distance of vertices from their neighboring vertex
  a__     : List[Any]  =[]

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

  a__     : str  =[]
  a__     : str  =1
  a__     : str  =sys.maxsize
  for neighbor, distance in adjacency_list[0]:
    a__     : Union[str, Any]  =0
    a__     : List[str]  =distance
  heap.heapify(SCREAMING_SNAKE_CASE	,	SCREAMING_SNAKE_CASE						)

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


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













import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
UpperCAmelCase     :     List[Any]							=	{"""LayoutLMv2Config""", """LayoutLMv3Config"""}







@is_pipeline_test
class     __lowerCAmelCase	(   unittest.TestCase):
      _lowercase    : str            =      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
      _lowercase    : Tuple            =      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

      if model_mapping is not None:
            _lowercase    : Dict            =      {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
      if tf_model_mapping is not None:
            _lowercase    : int            =      {
                config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
            }







      @require_torch
      def        _lowercase  (   self							)       ->						Tuple:



        '''simple docstring'''




        a__     : str  =pipeline(
            task="text-classification"		,				model="hf-internal-testing/tiny-random-distilbert"		,				framework="pt"							)

        a__     : Any  =text_classifier("This is great !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}]							)

        a__     : Any  =text_classifier("This is great !"		,				top_k=2							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]							)

        a__     : Tuple  =text_classifier(["This is great !", "This is bad"]		,				top_k=2							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[
                [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
                [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
            ]		,				)

        a__     : List[Any]  =text_classifier("This is great !"		,				top_k=1							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}]							)

        # Legacy behavior
        a__     : Any  =text_classifier("This is great !"		,				return_all_scores=lowerCAmelCase__							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}]							)

        a__     : List[str]  =text_classifier("This is great !"		,				return_all_scores=lowerCAmelCase__							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]]							)

        a__     : Optional[int]  =text_classifier(["This is great !", "Something else"]		,				return_all_scores=lowerCAmelCase__							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[
                [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
                [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
            ]		,				)

        a__     : int  =text_classifier(["This is great !", "Something else"]		,				return_all_scores=lowerCAmelCase__							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[
                {"label": "LABEL_0", "score": 0.5_04},
                {"label": "LABEL_0", "score": 0.5_04},
            ]		,				)







      @require_torch
      def        _lowercase  (   self							)       ->						List[Any]:



        '''simple docstring'''




        import torch

        a__     : Dict  =pipeline(
            task="text-classification"		,				model="hf-internal-testing/tiny-random-distilbert"		,				framework="pt"		,				device=torch.device("cpu"							)		,				)

        a__     : Optional[Any]  =text_classifier("This is great !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}]							)







      @require_tf
      def        _lowercase  (   self							)       ->						Union[str, Any]:



        '''simple docstring'''




        a__     : Optional[int]  =pipeline(
            task="text-classification"		,				model="hf-internal-testing/tiny-random-distilbert"		,				framework="tf"							)

        a__     : Optional[Any]  =text_classifier("This is great !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "LABEL_0", "score": 0.5_04}]							)







      @slow
      @require_torch
      def        _lowercase  (   self							)       ->						str:



        '''simple docstring'''




        a__     : Union[str, Any]  =pipeline("text-classification"							)

        a__     : Union[str, Any]  =text_classifier("This is great !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "POSITIVE", "score": 1.0}]							)
        a__     : Optional[Any]  =text_classifier("This is bad !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "NEGATIVE", "score": 1.0}]							)
        a__     : Dict  =text_classifier("Birds are a type of animal"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "POSITIVE", "score": 0.9_88}]							)







      @slow
      @require_tf
      def        _lowercase  (   self							)       ->						Optional[int]:



        '''simple docstring'''




        a__     : Tuple  =pipeline("text-classification"		,				framework="tf"							)

        a__     : str  =text_classifier("This is great !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "POSITIVE", "score": 1.0}]							)
        a__     : str  =text_classifier("This is bad !"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "NEGATIVE", "score": 1.0}]							)
        a__     : Dict  =text_classifier("Birds are a type of animal"							)
        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": "POSITIVE", "score": 0.9_88}]							)







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						Optional[int]:



        '''simple docstring'''




        a__     : List[Any]  =TextClassificationPipeline(model=lowerCAmelCase__		,				tokenizer=lowerCAmelCase__							)
        return text_classifier, ["HuggingFace is in", "This is another test"]







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						List[str]:



        '''simple docstring'''




        a__     : Tuple  =text_classifier.model
        # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
        a__     : List[Any]  ="HuggingFace is in"
        a__     : int  =text_classifier(lowerCAmelCase__							)

        self.assertEqual(nested_simplify(lowerCAmelCase__							)		,				[{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}]							)
        self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()							)

        a__     : Optional[int]  =["HuggingFace is in ", "Paris is in France"]
        a__     : Optional[Any]  =text_classifier(lowerCAmelCase__							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}, {"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}]		,				)
        self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()							)
        self.assertTrue(outputs[1]["label"] in model.config.idalabel.values()							)

        # Forcing to get all results with `top_k=None`
        # This is NOT the legacy format
        a__     : Union[str, Any]  =text_classifier(lowerCAmelCase__		,				top_k=lowerCAmelCase__							)
        a__     : Optional[Any]  =len(model.config.idalabel.values()							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[[{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}] * N, [{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}] * N]		,				)

        a__     : List[str]  ={"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
        a__     : Optional[Any]  =text_classifier(lowerCAmelCase__							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}		,				)
        self.assertTrue(outputs["label"] in model.config.idalabel.values()							)

        # This might be used a text pair, but tokenizer + pipe interaction
        # makes it hard to understand that it's not using the pair properly
        # https://github.com/huggingface/transformers/issues/17305
        # We disabled this usage instead as it was outputting wrong outputs.
        a__     : Any  =[["HuggingFace is in ", "Paris is in France"]]
        with self.assertRaises(lowerCAmelCase__							):
          text_classifier(lowerCAmelCase__							)

        # This used to be valid for doing text pairs
        # We're keeping it working because of backward compatibility
        a__     : Optional[int]  =text_classifier([[["HuggingFace is in ", "Paris is in France"]]]							)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__							)		,				[{"label": ANY(lowerCAmelCase__							), "score": ANY(lowerCAmelCase__							)}]		,				)
        self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()							)






