






'''simple docstring'''





def    lowerCamelCase_     (    lowercase__				,     lowercase__):
 print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
 for i in range(_lowerCamelCase):
  for j in range(_lowerCamelCase):
   if dist[i][j] != float("inf"):
    print(int(dist[i][j])				,     end="\t")
   else:
    print("INF"				,     end="\t")
  print()






def    lowerCamelCase_     (    lowercase__				,     lowercase__):
 lowerCamelCase__  =     [[float("inf") for _ in range(_lowerCamelCase)] for _ in range(_lowerCamelCase)]

 for i in range(_lowerCamelCase):
  for j in range(_lowerCamelCase):
   lowerCamelCase__  =     graph[i][j]

   # check vertex k against all other vertices (i, j)
 for k in range(_lowerCamelCase):
  # looping through rows of graph array
  for i in range(_lowerCamelCase):
   # looping through columns of graph array
   for j in range(_lowerCamelCase):
    if (
        dist[i][k] != float("inf")
        and dist[k][j] != float("inf")
        and dist[i][k] + dist[k][j] < dist[i][j]
    ):
     lowerCamelCase__  =     dist[i][k] + dist[k][j]

 _print_dist(_lowerCamelCase				,     _lowerCamelCase)
 return dist, v


if __name__ == "__main__":
 __A							:							Any  							=		int(input("""Enter number of vertices: """))
 __A							:							List[str]  							=		int(input("""Enter number of edges: """))

 __A							:							Optional[int]  							=		[[float("""inf""") for i in range(v)] for j in range(v)]

 for i in range(v):
  __A							:							List[Any]  							=		0.0

  # src and dst are indices that must be within the array size graph[e][v]
  # failure to follow this will result in an error
 for i in range(e):
  print("""\nEdge """, i + 1)
  __A							:							Optional[Any]  							=		int(input("""Enter source:"""))
  __A							:							Optional[int]  							=		int(input("""Enter destination:"""))
  __A							:							str  							=		float(input("""Enter weight:"""))
  __A							:							int  							=		weight

 floyd_warshall(graph, v)

 # Example Input
 # Enter number of vertices: 3
 # Enter number of edges: 2

 # # generated graph from vertex and edge inputs
 # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
 # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

 # specify source, destination and weight for edge #1
 # Edge  1
 # Enter source:1
 # Enter destination:2
 # Enter weight:2

 # specify source, destination and weight for edge #2
 # Edge  2
 # Enter source:2
 # Enter destination:1
 # Enter weight:1

 # # Expected Output from the vertice, edge and src, dst, weight inputs!!
 # 0		INF	INF
 # INF	0	2
 # INF	1	0









'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


__A							:							Union[str, Any]  							=		{
    """configuration_layoutlmv2""": ["""LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LayoutLMv2Config"""],
    """processing_layoutlmv2""": ["""LayoutLMv2Processor"""],
    """tokenization_layoutlmv2""": ["""LayoutLMv2Tokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							Optional[Any]  							=		["""LayoutLMv2TokenizerFast"""]

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							List[Any]  							=		["""LayoutLMv2FeatureExtractor"""]
 __A							:							List[Any]  							=		["""LayoutLMv2ImageProcessor"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							Any  							=		[
     """LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """LayoutLMv2ForQuestionAnswering""",
     """LayoutLMv2ForSequenceClassification""",
     """LayoutLMv2ForTokenClassification""",
     """LayoutLMv2Layer""",
     """LayoutLMv2Model""",
     """LayoutLMv2PreTrainedModel""",
 ]

if TYPE_CHECKING:
 from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
 from .processing_layoutlmva import LayoutLMvaProcessor
 from .tokenization_layoutlmva import LayoutLMvaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_layoutlmva import (
      LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
      LayoutLMvaForQuestionAnswering,
      LayoutLMvaForSequenceClassification,
      LayoutLMvaForTokenClassification,
      LayoutLMvaLayer,
      LayoutLMvaModel,
      LayoutLMvaPreTrainedModel,
  )
else:
 import sys

 __A							:							Tuple  							=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

