

"""simple docstring"""


def   _A					(	_a	:						List[str]     ,   _a	:						Dict				):



      """simple docstring"""






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



def   _A					(	_a	:						Any     ,   _a	:						Any				):



      """simple docstring"""






      A				  =		[[float("""inf"""				) for _ in range(_a				)] for _ in range(_a				)]

      for i in range(_a				):
            for j in range(_a				):
                  A				  =		graph[i][j]

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

      _print_dist(_a     ,   _a				)
      return dist, v


if __name__ == "__main__":
  UpperCAmelCase													=int(input("Enter number of vertices: "))
  UpperCAmelCase													=int(input("Enter number of edges: "))

  UpperCAmelCase													=[[float("inf") for i in range(v)] for j in range(v)]

  for i in range(v):
    UpperCAmelCase													=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)
    UpperCAmelCase													=int(input("Enter source:"))
    UpperCAmelCase													=int(input("Enter destination:"))
    UpperCAmelCase													=float(input("Enter weight:"))
    UpperCAmelCase													=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_torch_available,
)


UpperCAmelCase													={
    "configuration_mega": ["MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP", "MegaConfig", "MegaOnnxConfig"],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase													=[
      "MEGA_PRETRAINED_MODEL_ARCHIVE_LIST",
      "MegaForCausalLM",
      "MegaForMaskedLM",
      "MegaForMultipleChoice",
      "MegaForQuestionAnswering",
      "MegaForSequenceClassification",
      "MegaForTokenClassification",
      "MegaModel",
      "MegaPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mega import (
        MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
        MegaForCausalLM,
        MegaForMaskedLM,
        MegaForMultipleChoice,
        MegaForQuestionAnswering,
        MegaForSequenceClassification,
        MegaForTokenClassification,
        MegaModel,
        MegaPreTrainedModel,
    )

else:
  import sys

  UpperCAmelCase													=_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




