



'''simple docstring'''




from math import pow



def 	a			( lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      ):
			'''simple docstring'''





			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

			A_	:						Optional[int]	=     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
						A_,    A_	:						int	=     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.
						A_,    A_	:						int	=     backtrack(
						    lowerCamelCase__						,      lowerCamelCase__						,      current_number + 1						,      lowerCamelCase__						,      lowerCamelCase__    )
			return current_sum, solutions_count



def 	a			( lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			if not (1 <= needed_sum <= 10_00 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()




'''simple docstring'''




# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

lowerCamelCase							:str				    =					TypeVar('''T''')







class 	_lowerCAmelCase							(			Generic[T] ):


	def __init__(self       ,      lowercase = True							):
				A_	:						dict[T, list[T]]	=     {}  # dictionary of lists
				A_	:						Any	=     directed


	def     _a	(self       ,      lowercase       ,      lowercase							):

				if not self.directed:  # For undirected graphs
							# if both source vertex and destination vertex are both present in the
							# adjacency list, add destination vertex to source vertex list of adjacent
							# vertices and add source vertex to destination vertex list of adjacent
							# vertices.
							if source_vertex in self.adj_list and destination_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										self.adj_list[destination_vertex].append(lowercase							)
							# if only source vertex is present in adjacency list, add destination vertex
							# to source vertex list of adjacent vertices, then create a new vertex with
							# destination vertex as key and assign a list containing the source vertex
							# as it's first adjacent vertex.
							elif source_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										A_	:						Dict	=     [source_vertex]
							# if only destination vertex is present in adjacency list, add source vertex
							# to destination vertex list of adjacent vertices, then create a new vertex
							# with source vertex as key and assign a list containing the source vertex
							# as it's first adjacent vertex.
							elif destination_vertex in self.adj_list:
										self.adj_list[destination_vertex].append(lowercase							)
										A_	:						int	=     [destination_vertex]
							# if both source vertex and destination vertex are not present in adjacency
							# list, create a new vertex with source vertex as key and assign a list
							# containing the destination vertex as it's first adjacent vertex also
							# create a new vertex with destination vertex as key and assign a list
							# containing the source vertex as it's first adjacent vertex.
							else:
										A_	:						Optional[Any]	=     [destination_vertex]
										A_	:						Tuple	=     [source_vertex]
				else:  # For directed graphs
							# if both source vertex and destination vertex are present in adjacency
							# list, add destination vertex to source vertex list of adjacent vertices.
							if source_vertex in self.adj_list and destination_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
							# if only source vertex is present in adjacency list, add destination
							# vertex to source vertex list of adjacent vertices and create a new vertex
							# with destination vertex as key, which has no adjacent vertex
							elif source_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										A_	:						Tuple	=     []
							# if only destination vertex is present in adjacency list, create a new
							# vertex with source vertex as key and assign a list containing destination
							# vertex as first adjacent vertex
							elif destination_vertex in self.adj_list:
										A_	:						Tuple	=     [destination_vertex]
							# if both source vertex and destination vertex are not present in adjacency
							# list, create a new vertex with source vertex as key and a list containing
							# destination vertex as it's first adjacent vertex. Then create a new vertex
							# with destination vertex as key, which has no adjacent vertex
							else:
										A_	:						int	=     [destination_vertex]
										A_	:						List[str]	=     []

				return self


	def __repr__(self							):
				return pformat(self.adj_list							)