



def 							A     (					_UpperCAmelCase    :       int   )    ->			"list[int]":







			'''simple docstring'''
			if upper_limit < 0:
						raise ValueError('Limit for the Catalan sequence must be ≥ 0'   )

			_UpperCAmelCase			=       [0] * (upper_limit + 1)

			# Base case: C(0) = C(1) = 1
			_UpperCAmelCase			=       1
			if upper_limit > 0:
						_UpperCAmelCase			=       1

			# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
			for i in range(2							,       upper_limit + 1   ):
						for j in range(_UpperCAmelCase   ):
									catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

			return catalan_list


if __name__ == "__main__":
							print("\n********* Catalan Numbers Using Dynamic Programming ************\n")
							print("\n*** Enter -1 at any time to quit ***")
							print("\nEnter the upper limit (≥ 0) for the Catalan number sequence: ", end="")
							try:
														while True:
																					UpperCAmelCase__       =	int(input().strip())
																					if N < 0:
																												print("\n********* Goodbye!! ************")
																												break
																					else:
																												print(f"""The Catalan numbers from 0 through {N} are:""")
																												print(catalan_numbers(N))
																												print("Try another upper limit for the sequence: ", end="")
							except (NameError, ValueError):
														print("\n********* Invalid input, goodbye! ************\n")

							import doctest

							doctest.testmod()





UpperCAmelCase__       =	{
    "A": ["B", "C", "E"],
    "B": ["A", "D", "E"],
    "C": ["A", "F", "G"],
    "D": ["B"],
    "E": ["A", "B", "D"],
    "F": ["C"],
    "G": ["C"],
}





def 							A     (					_UpperCAmelCase    :       dict							,       _UpperCAmelCase    :       Optional[int]							,       _UpperCAmelCase    :       List[Any]   )    ->			list[str]:







			'''simple docstring'''
			_UpperCAmelCase			=       set()
			# keep track of all the paths to be checked
			_UpperCAmelCase			=       [[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
						_UpperCAmelCase			=       queue.pop(0   )
						# get the last node from the path
						_UpperCAmelCase			=       path[-1]
						if node not in explored:
									_UpperCAmelCase			=       graph[node]
									# go through all neighbour nodes, construct a new path and
									# push it into the queue
									for neighbour in neighbours:
												_UpperCAmelCase			=       list(_UpperCAmelCase   )
												new_path.append(_UpperCAmelCase   )
												queue.append(_UpperCAmelCase   )
												# return path if neighbour is goal
												if neighbour == goal:
															return new_path

            # mark node as explored
									explored.add(_UpperCAmelCase   )

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





def 							A     (					_UpperCAmelCase    :       dict							,       _UpperCAmelCase    :       Any							,       _UpperCAmelCase    :       List[str]   )    ->			int:







			'''simple docstring'''
			if not graph or start not in graph or target not in graph:
						return -1
			if start == target:
						return 0
			_UpperCAmelCase			=       [start]
			_UpperCAmelCase			=       set(_UpperCAmelCase   )
			# Keep tab on distances from `start` node.
			_UpperCAmelCase			=       {start: 0, target: -1}
			while queue:
						_UpperCAmelCase			=       queue.pop(0   )
						if node == target:
									_UpperCAmelCase			=       (
									    dist[node] if dist[target] == -1 else min(dist[target]							,       dist[node]   )
									)
						for adjacent in graph[node]:
									if adjacent not in visited:
												visited.add(_UpperCAmelCase   )
												queue.append(_UpperCAmelCase   )
												_UpperCAmelCase			=       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
