





'''simple docstring'''





from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass



@dataclass
class        _lowerCAmelCase    :


  '''simple docstring'''
  a_							:       int      					=42
  a_							:       List[str]      					=42




class        _lowerCAmelCase    :


  '''simple docstring'''







  def __init__(      self      :					Optional[int]      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    _snake_case   :				list[list[Edge]]														=	[[] for _ in range(__lowerCamelCase							)]
    _snake_case   :				int														=	size







  def __getitem__(      self      :					Optional[int]      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    return iter(self._graph[vertex]							)







  @property
  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    return self._size







  def UpperCamelCase_ (      self      :					Dict      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    if weight not in (0, 1):
      raise ValueError('Edge weight must be either 0 or 1.'							)

    if to_vertex < 0 or to_vertex >= self.size:
      raise ValueError('Vertex indexes must be in [0; size).'							)

    self._graph[from_vertex].append(Edge(__lowerCamelCase      ,				__lowerCamelCase							)							)







  def UpperCamelCase_ (      self      :					Union[str, Any]      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    _snake_case   :				List[Any]														=	deque([start_vertex]							)
    _snake_case   :				list[int | None]														=	[None] * self.size
    _snake_case   :				str														=	0

    while queue:
      _snake_case   :				Union[str, Any]														=	queue.popleft()
      _snake_case   :				int														=	distances[current_vertex]
      if current_distance is None:
        continue

      for edge in self[current_vertex]:
        _snake_case   :				Tuple														=	current_distance + edge.weight
        _snake_case   :				str														=	distances[edge.destination_vertex]
        if (
            isinstance(__lowerCamelCase      ,				__lowerCamelCase							)
            and new_distance >= dest_vertex_distance
        ):
          continue
        _snake_case   :				Tuple														=	new_distance
        if edge.weight == 0:
          queue.appendleft(edge.destination_vertex							)
        else:
          queue.append(edge.destination_vertex							)

    if distances[finish_vertex] is None:
      raise ValueError('No path from start_vertex to finish_vertex.'							)

    return distances[finish_vertex]


if __name__ == "__main__":
      import doctest

      doctest.testmod()











def     lowerCamelCase_	(      lowerCAmelCase:	int				)->		int:

  if not isinstance(lowerCAmelCase    ,							lowerCAmelCase				):
    _snake_case   :				Union[str, Any]														=	F"""Input value of [number={number}] must be an integer"""
    raise TypeError(lowerCAmelCase				)

  if number < 1:
    _snake_case   :				int														=	F"""Input value of [number={number}] must be > 0"""
    raise ValueError(lowerCAmelCase				)

  _snake_case   :				int														=	1

  for i in range(1    ,							lowerCAmelCase				):
    current_number *= 4 * i - 2
    current_number //= i + 1

  return current_number


if __name__ == "__main__":
      import doctest

      doctest.testmod()




