






'''simple docstring'''
a_					= {
    '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__				:						List[Any],	UpperCamelCase__				:						List[Any]							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				List[str]									=set()
      # keep track of all the paths to be checked
      SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=[[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
            SCREAMING_SNAKE_CASE__     :				List[Any]									=queue.pop(0							)
            # get the last node from the path
            SCREAMING_SNAKE_CASE__     :				Optional[int]									=path[-1]
            if node not in explored:
                  SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=graph[node]
                  # go through all neighbour nodes, construct a new path and
                  # push it into the queue
                  for neighbour in neighbours:
                        SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=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__				:						Tuple,	UpperCamelCase__				:						str							):




      '''simple docstring'''






      if not graph or start not in graph or target not in graph:
            return -1
      if start == target:
            return 0
      SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[start]
      SCREAMING_SNAKE_CASE__     :				Tuple									=set(UpperCamelCase__							)
      # Keep tab on distances from `start` node.
      SCREAMING_SNAKE_CASE__     :				Tuple									={start: 0, target: -1}
      while queue:
            SCREAMING_SNAKE_CASE__     :				Optional[Any]									=queue.pop(0							)
            if node == target:
                  SCREAMING_SNAKE_CASE__     :				List[Any]									=(
                      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__							)
                        SCREAMING_SNAKE_CASE__     :				Any									=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







'''simple docstring'''
def  _a(  UpperCamelCase__				:						str,	UpperCamelCase__				:						str							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				Optional[int]									=len(UpperCamelCase__							)
      SCREAMING_SNAKE_CASE__     :				Optional[Any]									=len(UpperCamelCase__							)
      SCREAMING_SNAKE_CASE__     :				Tuple									=[[False for _ in range(m + 1							)] for _ in range(n + 1							)]
      SCREAMING_SNAKE_CASE__     :				List[Any]									=True
      for i in range(UpperCamelCase__							):
            for j in range(m + 1							):
                  if dp[i][j]:
                        if j < m and a[i].upper() == b[j]:
                              SCREAMING_SNAKE_CASE__     :				Optional[int]									=True
                        if a[i].islower():
                              SCREAMING_SNAKE_CASE__     :				List[Any]									=True
      return dp[n][m]


if __name__ == "__main__":
  import doctest

  doctest.testmod()