code: 
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			Optional[Any]:
       print("\nVertex Distance"    )
       for i in range(__lowerCAmelCase    ):
            if dist[i] != float("inf"    ):
                 print(__lowerCAmelCase      ,					"\t"      ,					int(dist[i]    )      ,					end="\t"    )
            else:
                 print(__lowerCAmelCase      ,					"\t"      ,					"INF"      ,					end="\t"    )
            print()
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			Tuple:
       UpperCamelCase__    :     Union[str, Any]        = float("inf"    )
       UpperCamelCase__    :     List[Any]        = -1
       for i in range(__lowerCAmelCase    ):
            if (not vset[i]) and mdist[i] < min_val:
                 UpperCamelCase__    :     Union[str, Any]        = i
                 UpperCamelCase__    :     List[Any]        = mdist[i]
       return min_ind
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			Union[str, Any]:
       UpperCamelCase__    :     Tuple        = [float("inf"    ) for _ in range(__lowerCAmelCase    )]
       UpperCamelCase__    :     Tuple        = [False for _ in range(__lowerCAmelCase    )]
       UpperCamelCase__    :     str        = 0.0
  
       for _ in range(v - 1    ):
            UpperCamelCase__    :     Optional[int]        = min_dist(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
            UpperCamelCase__    :     Optional[int]        = True
  
            for i in range(__lowerCAmelCase    ):
                 if (
                     (not vset[i])
                     and graph[u][i] != float("inf"    )
                     and mdist[u] + graph[u][i] < mdist[i]
                 ):
                      UpperCamelCase__    :     Union[str, Any]        = mdist[u] + graph[u][i]
  
       print_dist(__lowerCAmelCase      ,					__lowerCAmelCase    )
  
  
  if __name__ == "__main__":
   lowerCamelCase			:							Dict       =int(input('''Enter number of vertices: ''').strip())
   lowerCamelCase			:							Tuple       =int(input('''Enter number of edges: ''').strip())
  
   lowerCamelCase			:							List[Any]       =[[float('''inf''') for i in range(V)] for j in range(V)]
  
   for i in range(V):
    lowerCamelCase			:							List[str]       =0.0
  
   for i in range(E):
    print('''\nEdge ''', i + 1)
    lowerCamelCase			:							Dict       =int(input('''Enter source:''').strip())
    lowerCamelCase			:							Optional[int]       =int(input('''Enter destination:''').strip())
    lowerCamelCase			:							Tuple       =float(input('''Enter weight:''').strip())
    lowerCamelCase			:							str       =weight
  
   lowerCamelCase			:							Dict       =int(input('''\nEnter shortest path source:''').strip())
   dijkstra(graph, V, gsrc)
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			list[int]:
       if not list_of_ints:
            return []
  
       if min(__lowerCAmelCase    ) < 0:
            raise ValueError("All numbers must be positive"    )
  
       UpperCamelCase__    :     Dict        =						max(len(bin(__lowerCAmelCase    )[2:]    ) for x in list_of_ints    )
       return _msd_radix_sort(__lowerCAmelCase      ,					__lowerCAmelCase    )
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			list[int]:
       if bit_position == 0 or len(__lowerCAmelCase    ) in [0, 1]:
            return list_of_ints
  
       UpperCamelCase__    :     Union[str, Any]        =						[]
       UpperCamelCase__    :     Dict        =						[]
       # Split numbers based on bit at bit_position from the right
       for number in list_of_ints:
            if (number >> (bit_position - 1)) & 1:
                 # number has a one at bit bit_position
                 ones.append(__lowerCAmelCase    )
            else:
                 # number has a zero at bit bit_position
                 zeros.append(__lowerCAmelCase    )
  
      # recursively split both lists further
       UpperCamelCase__    :     str        =						_msd_radix_sort(__lowerCAmelCase      ,					bit_position - 1    )
       UpperCamelCase__    :     Optional[Any]        =						_msd_radix_sort(__lowerCAmelCase      ,					bit_position - 1    )
  
       # recombine lists
       UpperCamelCase__    :     Optional[int]        =						zeros
       res.extend(__lowerCAmelCase    )
  
       return res
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			Dict:
       UpperCamelCase__    :     Optional[int]        =						len(__lowerCAmelCase    )
       if not list_of_ints or length == 1:
            return
  
       if min(__lowerCAmelCase    ) < 0:
            raise ValueError("All numbers must be positive"    )
  
       UpperCamelCase__    :     int        =						max(len(bin(__lowerCAmelCase    )[2:]    ) for x in list_of_ints    )
       _msd_radix_sort_inplace(__lowerCAmelCase      ,					__lowerCAmelCase      ,					0      ,					__lowerCAmelCase    )
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			List[str]:
       if bit_position == 0 or end_index - begin_index <= 1:
            return
  
       bit_position -= 1
  
       UpperCamelCase__    :     Any        =						begin_index
       UpperCamelCase__    :     List[str]        =						end_index - 1
       while i <= j:
            UpperCamelCase__    :     Tuple        =						False
            if not (list_of_ints[i] >> bit_position) & 1:
                 # found zero at the beginning
                 i += 1
                 UpperCamelCase__    :     Any        =						True
            if (list_of_ints[j] >> bit_position) & 1:
                 # found one at the end
                 j -= 1
                 UpperCamelCase__    :     Dict        =						True
  
            if changed:
                 continue
  
            UpperCamelCase__       ,  UpperCamelCase__    :     Any        =						list_of_ints[j], list_of_ints[i]
            j -= 1
            if j != i:
                 i += 1
  
       _msd_radix_sort_inplace(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
       _msd_radix_sort_inplace(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
  
  
  if __name__ == "__main__":
   import doctest
  
   doctest.testmod()