


import heapq

def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_			)						->							Dict:




       '''simple docstring'''






       _lowercase					:				str           =			[(0, start)]  # cost from start node,end node
       _lowercase					:				Optional[int]           =			set()
       while heap:
              (_lowercase)					:				Optional[Any]           =			heapq.heappop(UpperCAmelCase_			)
              if u in visited:
                     continue
              visited.add(UpperCAmelCase_			)
              if u == end:
                     return cost
              for v, c in graph[u]:
                     if v in visited:
                            continue
                     _lowercase					:				Dict           =			cost + c
                     heapq.heappush(UpperCAmelCase_    ,     (next_item, v)			)
       return -1


UpperCamelCase__				       =			{
    'A': [['B', 2], ['C', 5]],
    'B': [['A', 2], ['D', 3], ['E', 1], ['F', 1]],
    'C': [['A', 5], ['F', 3]],
    'D': [['B', 3]],
    'E': [['B', 4], ['F', 3]],
    'F': [['C', 3], ['E', 3]],
}
UpperCamelCase__				       =			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['F', 3]],
    'F': [],
}
UpperCamelCase__				       =			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['G', 2]],
    'F': [],
    'G': [['F', 1]],
}

UpperCamelCase__				       =			dijkstra(G, 'E', 'C')
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

UpperCamelCase__				       =			dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 3 --> F == 3

UpperCamelCase__				       =			dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 2 --> G -- 1 --> F == 3

if __name__ == "__main__":
   import doctest

   doctest.testmod()



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__				       =			logging.get_logger(__name__)

UpperCamelCase__				       =			{
    'facebook/sam-vit-huge': 'https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json',
    'facebook/sam-vit-large': 'https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json',
    'facebook/sam-vit-base': 'https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json',
}

class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




     def __init__( self       :       List[Any]	,      UpperCamelCase       :       Optional[Any]=2_56	,      UpperCamelCase       :       str=10_24	,      UpperCamelCase       :       Any=16	,      UpperCamelCase       :       Optional[Any]=16	,      UpperCamelCase       :       Union[str, Any]=4	,      UpperCamelCase       :       str="gelu"	,      UpperCamelCase       :       Dict=1E-6	,      **UpperCamelCase       :       Tuple	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				Union[str, Any]           =			hidden_size
            _lowercase					:				Optional[Any]           =			image_size
            _lowercase					:				Tuple           =			patch_size
            _lowercase					:				List[str]           =			image_size // patch_size
            _lowercase					:				Optional[Any]           =			mask_input_channels
            _lowercase					:				str           =			num_point_embeddings
            _lowercase					:				List[Any]           =			hidden_act
            _lowercase					:				Union[str, Any]           =			layer_norm_eps




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




     def __init__( self       :       Optional[int]	,      UpperCamelCase       :       str=2_56	,      UpperCamelCase       :       int="relu"	,      UpperCamelCase       :       Any=20_48	,      UpperCamelCase       :       List[Any]=2	,      UpperCamelCase       :       Union[str, Any]=8	,      UpperCamelCase       :       List[str]=2	,      UpperCamelCase       :       Any=3	,      UpperCamelCase       :       List[Any]=3	,      UpperCamelCase       :       int=2_56	,      UpperCamelCase       :       List[str]=1E-6	,      **UpperCamelCase       :       Tuple	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				List[Any]           =			hidden_size
            _lowercase					:				Optional[int]           =			hidden_act
            _lowercase					:				Union[str, Any]           =			mlp_dim
            _lowercase					:				Optional[int]           =			num_hidden_layers
            _lowercase					:				List[str]           =			num_attention_heads
            _lowercase					:				Dict           =			attention_downsample_rate
            _lowercase					:				Optional[Any]           =			num_multimask_outputs
            _lowercase					:				Optional[Any]           =			iou_head_depth
            _lowercase					:				Dict           =			iou_head_hidden_dim
            _lowercase					:				List[str]           =			layer_norm_eps




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




     def __init__( self       :       List[str]	,      UpperCamelCase       :       Union[str, Any]=7_68	,      UpperCamelCase       :       Optional[Any]=2_56	,      UpperCamelCase       :       Optional[Any]=12	,      UpperCamelCase       :       Dict=12	,      UpperCamelCase       :       Dict=3	,      UpperCamelCase       :       Optional[int]=10_24	,      UpperCamelCase       :       Any=16	,      UpperCamelCase       :       Union[str, Any]="gelu"	,      UpperCamelCase       :       int=1E-06	,      UpperCamelCase       :       Tuple=0.0	,      UpperCamelCase       :       List[str]=1E-10	,      UpperCamelCase       :       List[Any]=True	,      UpperCamelCase       :       Any=4.0	,      UpperCamelCase       :       str=True	,      UpperCamelCase       :       Optional[int]=True	,      UpperCamelCase       :       Optional[int]=14	,      UpperCamelCase       :       Any=[2, 5, 8, 11]	,      UpperCamelCase       :       Tuple=1_28	,      UpperCamelCase       :       str=None	,      **UpperCamelCase       :       int	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)

            _lowercase					:				Union[str, Any]           =			hidden_size
            _lowercase					:				Optional[int]           =			output_channels
            _lowercase					:				Dict           =			num_hidden_layers
            _lowercase					:				str           =			num_attention_heads
            _lowercase					:				Dict           =			num_channels
            _lowercase					:				List[Any]           =			image_size
            _lowercase					:				int           =			patch_size
            _lowercase					:				Optional[Any]           =			hidden_act
            _lowercase					:				Any           =			layer_norm_eps
            _lowercase					:				Any           =			attention_dropout
            _lowercase					:				Optional[int]           =			initializer_range
            _lowercase					:				List[str]           =			qkv_bias
            _lowercase					:				Optional[Any]           =			mlp_ratio
            _lowercase					:				Optional[Any]           =			use_abs_pos
            _lowercase					:				List[Any]           =			use_rel_pos
            _lowercase					:				str           =			window_size
            _lowercase					:				Tuple           =			global_attn_indexes
            _lowercase					:				List[Any]           =			num_pos_feats
            _lowercase					:				int           =			int(hidden_size * mlp_ratio		) if mlp_dim is None else mlp_dim




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''
     UpperCAmelCase_         =  '''sam'''
     UpperCAmelCase_         =  True




     def __init__( self       :       Tuple	,      UpperCamelCase       :       Tuple=None	,      UpperCamelCase       :       Any=None	,      UpperCamelCase       :       Tuple=None	,      UpperCamelCase       :       Dict=0.02	,      **UpperCamelCase       :       Union[str, Any]	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				Optional[int]           =			vision_config if vision_config is not None else {}
            _lowercase					:				Any           =			prompt_encoder_config if prompt_encoder_config is not None else {}
            _lowercase					:				Optional[Any]           =			mask_decoder_config if mask_decoder_config is not None else {}

            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				Dict           =			vision_config.to_dict()
            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				List[str]           =			prompt_encoder_config.to_dict()
            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				Optional[int]           =			mask_decoder_config.to_dict()

            _lowercase					:				Union[str, Any]           =			SamVisionConfig(**UpperCamelCase		)
            _lowercase					:				Optional[Any]           =			SamPromptEncoderConfig(**UpperCamelCase		)
            _lowercase					:				List[Any]           =			SamMaskDecoderConfig(**UpperCamelCase		)
            _lowercase					:				Union[str, Any]           =			initializer_range




     def   lowerCAmelCase_   ( self       :       Union[str, Any]		):





            """simple docstring"""



            _lowercase					:				List[Any]           =			copy.deepcopy(self.__dict__		)
            _lowercase					:				int           =			self.vision_config.to_dict()
            _lowercase					:				Optional[int]           =			self.prompt_encoder_config.to_dict()
            _lowercase					:				List[Any]           =			self.mask_decoder_config.to_dict()
            _lowercase					:				List[Any]           =			self.__class__.model_type
            return output