





from math import pow


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase    ,       ):
       if current_sum == needed_sum:
              # If the sum of the powers is equal to needed_sum, then we have a solution.
              solutions_count += 1
              return current_sum, solutions_count

       _UpperCamelCase              =						int(pow(lowerCAmelCase    ,       lowerCAmelCase					)					)
       if current_sum + i_to_n <= needed_sum:
              # If the sum of the powers is less than needed_sum, then continue adding powers.
              current_sum += i_to_n
              _UpperCamelCase       ,		_UpperCamelCase              =						backtrack(
                  lowerCAmelCase    ,       lowerCAmelCase    ,       current_number + 1    ,       lowerCAmelCase    ,       lowerCAmelCase					)
              current_sum -= i_to_n
       if i_to_n < needed_sum:
              # If the power of i is less than needed_sum, then try with the next power.
              _UpperCamelCase       ,		_UpperCamelCase              =						backtrack(
                  lowerCAmelCase    ,       lowerCAmelCase    ,       current_number + 1    ,       lowerCAmelCase    ,       lowerCAmelCase					)
       return current_sum, solutions_count


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase    ,       lowerCAmelCase					):
       if not (1 <= needed_sum <= 1_000 and 2 <= power <= 10):
              raise ValueError(
                  '''Invalid input\n'''
                  '''needed_sum must be between 1 and 1000, power between 2 and 10.'''					)

       return backtrack(lowerCAmelCase    ,       lowerCAmelCase    ,       1    ,       0    ,       0					)[1]  # Return the solutions_count


if __name__ == "__main__":
       import doctest

       doctest.testmod()













from __future__ import annotations

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

class  __A:

     def __init__(      self,       A,       A      ):





            """simple docstring"""

            _UpperCamelCase              =						graph
            # mapping node to its parent in resulting breadth first tree
            _UpperCamelCase              =						{}
            _UpperCamelCase              =						source_vertex

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						{self.source_vertex}
            _UpperCamelCase              =						None
            _UpperCamelCase              =						[self.source_vertex]  # first in first out queue

            while queue:
                   _UpperCamelCase              =						queue.pop(0      )
                   for adjacent_vertex in self.graph[vertex]:
                          if adjacent_vertex not in visited:
                                 visited.add(A      )
                                 _UpperCamelCase              =						vertex
                                 queue.append(A      )



     def 	_UpperCamelCase     (      self,       A      ):





            """simple docstring"""

            if target_vertex == self.source_vertex:
                   return self.source_vertex

            _UpperCamelCase              =						self.parent.get(A      )
            if target_vertex_parent is None:
                   _UpperCamelCase              =						(
                       F'''No path from vertex: {self.source_vertex} to vertex: {target_vertex}'''
                   )
                   raise ValueError(A      )

            return self.shortest_path(A      ) + F'''->{target_vertex}'''


if __name__ == "__main__":
       lowercase    : Tuple    	=  Graph(graph, """G""")
       g.breath_first_search()
       print(g.shortest_path("""D"""))
       print(g.shortest_path("""G"""))
       print(g.shortest_path("""Foo"""))






