
"""simple docstring"""




import heapq

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


UpperCAmelCase__				:   Optional[Any]   							=			{
    '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__				:   Optional[Any]   							=			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['F', 3]],
    'F': [],
}
UpperCAmelCase__				:   List[Any]   							=			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['G', 2]],
    'F': [],
    'G': [['F', 1]],
}

UpperCAmelCase__				:   Optional[int]   							=			dijkstra(G, 'E', 'C')
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

UpperCAmelCase__				:   str   							=			dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 3 --> F == 3

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

if __name__ == "__main__":
					import doctest

					doctest.testmod()






"""simple docstring"""




def lowercase_  (       _snake_case       ,_snake_case       ,_snake_case						):
							SCREAMING_SNAKE_CASE__						:	Any									=       index
							SCREAMING_SNAKE_CASE__						:	List[Any]									=       2 * index + 1
							SCREAMING_SNAKE_CASE__						:	Any									=       2 * index + 2
							if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
														SCREAMING_SNAKE_CASE__						:	str									=       left_index

							if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
														SCREAMING_SNAKE_CASE__						:	Any									=       right_index

							if largest != index:
														SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Tuple									=       unsorted[index], unsorted[largest]
														heapify(_snake_case       ,_snake_case       ,_snake_case						)

def lowercase_  (       _snake_case						):
							SCREAMING_SNAKE_CASE__						:	List[Any]									=       len(_snake_case						)
							for i in range(n // 2 - 1       ,-1       ,-1						):
														heapify(_snake_case       ,_snake_case       ,_snake_case						)
							for i in range(n - 1       ,0       ,-1						):
														SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Any									=       unsorted[i], unsorted[0]
														heapify(_snake_case       ,0       ,_snake_case						)
							return unsorted


if __name__ == "__main__":
					UpperCAmelCase__				:   Optional[Any]   							=			input('Enter numbers separated by a comma:\n').strip()
					UpperCAmelCase__				:   Optional[int]   							=			[int(item) for item in user_input.split(',')]
					print(heap_sort(unsorted))




