





"""simple docstring"""



def 		__lowercase     (   snake_case_  :  Tuple				,snake_case_  :  str						)   ->List[Any]:



    '''simple docstring'''







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







def 		__lowercase     (   snake_case_  :  Optional[Any]				,snake_case_  :  str						)   ->Union[str, Any]:



    '''simple docstring'''







    __A    :						Tuple						 =     [[float('''inf'''						) for _ in range(snake_case_						)] for _ in range(snake_case_						)]

    for i in range(snake_case_						):
        for j in range(snake_case_						):
            __A    :						Optional[Any]						 =     graph[i][j]

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

    _print_dist(snake_case_				,snake_case_						)
    return dist, v


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

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

       for i in range(v):
              a_ =			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_ =			int(input("""Enter source:"""))
              a_ =			int(input("""Enter destination:"""))
              a_ =			float(input("""Enter weight:"""))
              a_ =			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 collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a_ =			logging.get_logger(__name__)

a_ =			{
    """roberta-base""": """https://huggingface.co/roberta-base/resolve/main/config.json""",
    """roberta-large""": """https://huggingface.co/roberta-large/resolve/main/config.json""",
    """roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/config.json""",
    """distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/config.json""",
    """roberta-base-openai-detector""": """https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json""",
    """roberta-large-openai-detector""": """https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json""",
}






class 		__snake_case					(		SCREAMING_SNAKE_CASE__     ):





 """simple docstring"""


 _lowerCamelCase        =     """roberta"""

 def __init__(    self					,						__lowerCamelCase=5_0265					,						__lowerCamelCase=768					,						__lowerCamelCase=12					,						__lowerCamelCase=12					,						__lowerCamelCase=3072					,						__lowerCamelCase="gelu"					,						__lowerCamelCase=0.1					,						__lowerCamelCase=0.1					,						__lowerCamelCase=512					,						__lowerCamelCase=2					,						__lowerCamelCase=0.0_2					,						__lowerCamelCase=1e-1_2					,						__lowerCamelCase=1					,						__lowerCamelCase=0					,						__lowerCamelCase=2					,						__lowerCamelCase="absolute"					,						__lowerCamelCase=True					,						__lowerCamelCase=None					,						**__lowerCamelCase					,						):



     '''simple docstring'''




     super().__init__(pad_token_id=__lowerCamelCase					,						bos_token_id=__lowerCamelCase					,						eos_token_id=__lowerCamelCase					,						**__lowerCamelCase  )

     __A    :						str						 =     vocab_size
     __A    :						Any						 =     hidden_size
     __A    :						Any						 =     num_hidden_layers
     __A    :						int						 =     num_attention_heads
     __A    :						List[Any]						 =     hidden_act
     __A    :						Any						 =     intermediate_size
     __A    :						List[str]						 =     hidden_dropout_prob
     __A    :						List[Any]						 =     attention_probs_dropout_prob
     __A    :						Optional[Any]						 =     max_position_embeddings
     __A    :						str						 =     type_vocab_size
     __A    :						int						 =     initializer_range
     __A    :						Tuple						 =     layer_norm_eps
     __A    :						str						 =     position_embedding_type
     __A    :						int						 =     use_cache
     __A    :						Optional[int]						 =     classifier_dropout






class 		__snake_case					(		SCREAMING_SNAKE_CASE__     ):





 """simple docstring"""


 @property
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     if self.task == "multiple-choice":
         __A    :						List[Any]						 =     {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
     else:
         __A    :						Optional[Any]						 =     {0: '''batch''', 1: '''sequence'''}
     return OrderedDict(
         [
             ('''input_ids''', dynamic_axis),
             ('''attention_mask''', dynamic_axis),
         ]  )




