

"""simple docstring"""




from __future__ import annotations

from typing import Any







class   __lowercase      :

  def __init__(	self		:      int       ,A		:      int     ):






   '''simple docstring'''
   UpperCAmelCase__       :	List[str]        =       num_of_nodes
   UpperCAmelCase__       :	list[list[int]]        =       []
   UpperCAmelCase__       :	dict[int, int]        =       {}

  def  __lowercase							(	self		:      Any       ,A		:      int       ,A		:      int       ,A		:      int     ):






   '''simple docstring'''
   self.m_edges.append([u_node, v_node, weight]     )

  def  __lowercase							(	self		:      Tuple       ,A		:      int     ):






   '''simple docstring'''

   if self.m_component[u_node] == u_node:
    return u_node
   return self.find_component(self.m_component[u_node]     )

  def  __lowercase							(	self		:      List[Any]       ,A		:      int     ):






   '''simple docstring'''

   if self.m_component[u_node] != u_node:
    for k in self.m_component:
     UpperCAmelCase__       :	List[Any]        =       self.find_component(A     )

  def  __lowercase							(	self		:      List[str]       ,A		:      list[int]       ,A		:      int       ,A		:      int     ):






   '''simple docstring'''

   if component_size[u_node] <= component_size[v_node]:
    UpperCAmelCase__       :	Any        =       v_node
    component_size[v_node] += component_size[u_node]
    self.set_component(A     )

   elif component_size[u_node] >= component_size[v_node]:
    UpperCAmelCase__       :	List[str]        =       self.find_component(A     )
    component_size[u_node] += component_size[v_node]
    self.set_component(A     )




  def  __lowercase							(	self		:      int     ):






   '''simple docstring'''
   UpperCAmelCase__       :	Dict        =       []
   UpperCAmelCase__       :	str        =       0

   UpperCAmelCase__       :	list[Any]        =       [-1] * self.m_num_of_nodes

   # A list of components (initialized to all of the nodes)
   for node in range(self.m_num_of_nodes     ):
    self.m_component.update({node: node}     )
    component_size.append(1     )

   UpperCAmelCase__       :	Tuple        =       self.m_num_of_nodes

   while num_of_components > 1:
    for edge in self.m_edges:
     UpperCAmelCase__ ,   UpperCAmelCase__ ,   UpperCAmelCase__       :	Optional[int]        =       edge

     UpperCAmelCase__       :	Tuple        =       self.m_component[u]
     UpperCAmelCase__       :	Optional[int]        =       self.m_component[v]

     if u_component != v_component:

      for component in (u_component, v_component):
       if (
           minimum_weight_edge[component] == -1
           or minimum_weight_edge[component][2] > w
       ):
        UpperCAmelCase__       :	Optional[int]        =       [u, v, w]

    for edge in minimum_weight_edge:
     if isinstance(A       ,A     ):
      UpperCAmelCase__ ,   UpperCAmelCase__ ,   UpperCAmelCase__       :	Tuple        =       edge

      UpperCAmelCase__       :	str        =       self.m_component[u]
      UpperCAmelCase__       :	List[str]        =       self.m_component[v]

      if u_component != v_component:
       mst_weight += w
       self.union(A       ,A       ,A     )
       print(f"Added edge [{u} - {v}]\nAdded weight: {w}\n"     )
       num_of_components -= 1

    UpperCAmelCase__       :	Union[str, Any]        =       [-1] * self.m_num_of_nodes
   print(f"The total weight of the minimal spanning tree is: {mst_weight}"     )







def 	lowerCAmelCase    (       ):
 '''simple docstring'''







if __name__ == "__main__":
      import doctest

      doctest.testmod()







def 				SCREAMING_SNAKE_CASE_   (      UpperCamelCase__			,		UpperCamelCase__		):

      def get_matched_characters(UpperCamelCase__			,		UpperCamelCase__		) -> str:
            UpperCamelCase__     : Union[str, Any]											=					[]
            UpperCamelCase__     : Union[str, Any]											=					min(len(_stra		)			,		len(_stra		)		) // 2
            for i, l in enumerate(_stra		):
                  UpperCamelCase__     : Optional[int]											=					int(max(0			,		i - limit		)		)
                  UpperCamelCase__     : List[str]											=					int(min(i + limit + 1			,		len(_stra		)		)		)
                  if l in _stra[left:right]:
                        matched.append(UpperCamelCase__		)
                        UpperCamelCase__     : List[str]											=					f'''{_stra[0:_stra.index(UpperCamelCase__		)]} {_stra[_stra.index(UpperCamelCase__		) + 1:]}'''

            return "".join(UpperCamelCase__		)

      # matching characters
      UpperCamelCase__     : Any											=					get_matched_characters(UpperCamelCase__			,		UpperCamelCase__		)
      UpperCamelCase__     : Union[str, Any]											=					get_matched_characters(UpperCamelCase__			,		UpperCamelCase__		)
      UpperCamelCase__     : List[Any]											=					len(UpperCamelCase__		)

      # transposition
      UpperCamelCase__     : str											=					(
          len([(ca, ca) for ca, ca in zip(UpperCamelCase__			,		UpperCamelCase__		) if ca != ca]		) // 2
      )

      if not match_count:
            UpperCamelCase__     : Union[str, Any]											=					0.0
      else:
            UpperCamelCase__     : Optional[int]											=					(
                1
                / 3
                * (
                    match_count / len(UpperCamelCase__		)
                    + match_count / len(UpperCamelCase__		)
                    + (match_count - transpositions) / match_count
                )
            )

      # common prefix up to 4 characters
      UpperCamelCase__     : Dict											=					0
      for ca, ca in zip(stra[:4]			,		stra[:4]		):
            if ca == ca:
                  prefix_len += 1
            else:
                  break

      return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    print(jaro_winkler("hello", "world"))


