
_lowerCamelCase	:    str          =      {
    '''A''': ['''B''', '''C''', '''E'''],
    '''B''': ['''A''', '''D''', '''E'''],
    '''C''': ['''A''', '''F''', '''G'''],
    '''D''': ['''B'''],
    '''E''': ['''A''', '''B''', '''D'''],
    '''F''': ['''C'''],
    '''G''': ['''C'''],
}






def 	a_		(	__lowercase       :     dict	, __lowercase       :     List[str]	, __lowercase       :     int			)			->  list[str]:
			_snake_case          =      set()
			# keep track of all the paths to be checked
			_snake_case          =      [[start]]

			# return path if start is goal
			if start == goal:
						return [start]

			# keeps looping until all possible paths have been checked
			while queue:
						# pop the first path from the queue
						_snake_case          =      queue.pop(0			)
						# get the last node from the path
						_snake_case          =      path[-1]
						if node not in explored:
									_snake_case          =      graph[node]
									# go through all neighbour nodes, construct a new path and
									# push it into the queue
									for neighbour in neighbours:
												_snake_case          =      list(__lowercase			)
												new_path.append(__lowercase			)
												queue.append(__lowercase			)
												# return path if neighbour is goal
												if neighbour == goal:
															return new_path

            # mark node as explored
									explored.add(__lowercase			)

    # in case there's no path between the 2 nodes
			return []






def 	a_		(	__lowercase       :     dict	, __lowercase       :     Dict	, __lowercase       :     str			)			->  int:
			if not graph or start not in graph or target not in graph:
						return -1
			if start == target:
						return 0
			_snake_case          =      [start]
			_snake_case          =      set(__lowercase			)
			# Keep tab on distances from `start` node.
			_snake_case          =      {start: 0, target: -1}
			while queue:
						_snake_case          =      queue.pop(0			)
						if node == target:
									_snake_case          =      (
									    dist[node] if dist[target] == -1 else min(dist[target]	, dist[node]			)
									)
						for adjacent in graph[node]:
									if adjacent not in visited:
												visited.add(__lowercase			)
												queue.append(__lowercase			)
												_snake_case          =      dist[node] + 1
			return dist[target]


if __name__ == "__main__":
			print(bfs_shortest_path(demo_graph, '''G''', '''D'''))  # returns ['G', 'C', 'A', 'B', 'D']
			print(bfs_shortest_path_distance(demo_graph, '''G''', '''D'''))  # returns 4

from functools import lru_cache






@lru_cache
def 	a_		(	__lowercase       :     int			)			->  int:
			if num < 0:
						raise ValueError('Number should not be negative.'			)

			return 1 if num in (0, 1) else num * factorial(num - 1			)


if __name__ == "__main__":
			import doctest

			doctest.testmod()