

from __future__ import annotations






class 							A_				:


     def __init__(							self    :	Optional[Any]    ,						UpperCAmelCase    :	Union[str, Any]      )							->			None:
      __lowerCAmelCase:     Optional[Any]     			=   vertices
      __lowerCAmelCase:     int     			=   [[0] * vertices for _ in range(lowercase_      )]


     def 						UpperCAmelCase						(							self    :	Tuple    ,						UpperCAmelCase    :	List[str]      )							->			None:
      print('Vertex \t Distance from Source'      )
      for vertex in range(self.vertices      ):
       print(lowercase_    ,						'\t\t'    ,						distances_from_source[vertex]      )


     def 						UpperCAmelCase						(							self    :	str    ,						UpperCAmelCase    :	List[Any]    ,						UpperCAmelCase    :	Dict      )							->			int:
      __lowerCAmelCase:     List[Any]     			=   1E7
      __lowerCAmelCase:     Tuple     			=   0

      # Search not nearest vertex not in the shortest path tree
      for vertex in range(self.vertices      ):
       if distances_from_source[vertex] < minimum and visited[vertex] is False:
        __lowerCAmelCase:     Dict     			=   distances_from_source[vertex]
        __lowerCAmelCase:     int     			=   vertex
      return min_index


     def 						UpperCAmelCase						(							self    :	Tuple    ,						UpperCAmelCase    :	str      )							->			None:
      __lowerCAmelCase:     List[Any]     			=   [int(1E7      )] * self.vertices  # distances from the source
      __lowerCAmelCase:     List[Any]     			=   0
      __lowerCAmelCase:     List[str]     			=   [False] * self.vertices

      for _ in range(self.vertices      ):
       __lowerCAmelCase:     List[Any]     			=   self.minimum_distance(lowercase_    ,						lowercase_      )
       __lowerCAmelCase:     List[str]     			=   True

       # Update dist value of the adjacent vertices
       # of the picked vertex only if the current
       # distance is greater than new distance and
       # the vertex in not in the shortest path tree
       for v in range(self.vertices      ):
        if (
            self.graph[u][v] > 0
            and visited[v] is False
            and distances[v] > distances[u] + self.graph[u][v]
        ):
         __lowerCAmelCase:     Any     			=   distances[u] + self.graph[u][v]

      self.print_solution(lowercase_      )


if __name__ == "__main__":
  _a	 =     Graph(9)
  _a	 =     [
      [0, 4, 0, 0, 0, 0, 0, 8, 0],
      [4, 0, 8, 0, 0, 0, 0, 1_1, 0],
      [0, 8, 0, 7, 0, 4, 0, 0, 2],
      [0, 0, 7, 0, 9, 1_4, 0, 0, 0],
      [0, 0, 0, 9, 0, 1_0, 0, 0, 0],
      [0, 0, 4, 1_4, 1_0, 0, 2, 0, 0],
      [0, 0, 0, 0, 0, 2, 0, 1, 6],
      [8, 1_1, 0, 0, 0, 0, 1, 0, 7],
      [0, 0, 2, 0, 0, 0, 6, 7, 0],
  ]
  graph.dijkstra(0)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_keras_nlp_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_a	 =     {
    '''configuration_gpt2''': ['''GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPT2Config''', '''GPT2OnnxConfig'''],
    '''tokenization_gpt2''': ['''GPT2Tokenizer'''],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     ['''GPT2TokenizerFast''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     [
      '''GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''GPT2DoubleHeadsModel''',
      '''GPT2ForQuestionAnswering''',
      '''GPT2ForSequenceClassification''',
      '''GPT2ForTokenClassification''',
      '''GPT2LMHeadModel''',
      '''GPT2Model''',
      '''GPT2PreTrainedModel''',
      '''load_tf_weights_in_gpt2''',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     [
      '''TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''TFGPT2DoubleHeadsModel''',
      '''TFGPT2ForSequenceClassification''',
      '''TFGPT2LMHeadModel''',
      '''TFGPT2MainLayer''',
      '''TFGPT2Model''',
      '''TFGPT2PreTrainedModel''',
  ]

try:
  if not is_keras_nlp_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     ['''TFGPT2Tokenizer''']

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     ['''FlaxGPT2LMHeadModel''', '''FlaxGPT2Model''', '''FlaxGPT2PreTrainedModel''']

if TYPE_CHECKING:
  from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
  from .tokenization_gpta import GPTaTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_gpta_fast import GPTaTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gpta import (
        GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTaDoubleHeadsModel,
        GPTaForQuestionAnswering,
        GPTaForSequenceClassification,
        GPTaForTokenClassification,
        GPTaLMHeadModel,
        GPTaModel,
        GPTaPreTrainedModel,
        load_tf_weights_in_gpta,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_gpta import (
        TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFGPTaDoubleHeadsModel,
        TFGPTaForSequenceClassification,
        TFGPTaLMHeadModel,
        TFGPTaMainLayer,
        TFGPTaModel,
        TFGPTaPreTrainedModel,
    )

  try:
    if not is_keras_nlp_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_gpta_tf import TFGPTaTokenizer

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel

else:
  import sys

  _a	 =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





