'''simple docstring'''




# This Python program implements an optimal binary search tree (abbreviated BST)
# building dynamic programming algorithm that delivers O(n^2) performance.
#
# The goal of the optimal BST problem is to build a low-cost BST for a
# given set of nodes, each with its own key and frequency. The frequency
# of the node is defined as how many time the node is being searched.
# The search cost of binary search tree is given by this formula:
#
# cost(1, n) = sum{i = 1 to n}((depth(node_i) + 1) * node_i_freq)
#
# where n is number of nodes in the BST. The characteristic of low-cost
# BSTs is having a faster overall search time than other implementations.
# The reason for their fast search time is that the nodes with high
# frequencies will be placed near the root of the tree while the nodes
# with low frequencies will be placed near the leaves of the tree thus
# reducing search time in the most frequent instances.
import sys
from random import randint




class 					a__   :






     def __init__(				self	:	Any						,       a	:	Optional[int]						,       a	:	List[Any]					):





         """simple docstring"""



         __lowerCamelCase						=						key
         __lowerCamelCase						=						freq






     def __str__(				self	:	Tuple					):





         """simple docstring"""



         return f"""Node(key={self.key}, freq={self.freq})"""






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       )			->					Optional[int]:
    if i > j or i < 0 or j > len(UpperCamelCase__       ) - 1:
        return

    __lowerCamelCase						=						root[i][j]
    if parent == -1:  # root does not have a parent
        print(f"""{key[node]} is the root of the binary search tree."""       )
    elif is_left:
        print(f"""{key[node]} is the left child of key {parent}."""       )
    else:
        print(f"""{key[node]} is the right child of key {parent}."""       )

    print_binary_search_tree(UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						node - 1       ,						key[node]       ,						UpperCamelCase__       )
    print_binary_search_tree(UpperCamelCase__       ,						UpperCamelCase__       ,						node + 1       ,						UpperCamelCase__       ,						key[node]       ,						UpperCamelCase__       )






def __lowerCAmelCase				(							UpperCamelCase__       )			->					Tuple:
    nodes.sort(key=lambda UpperCamelCase__       : node.key       )

    __lowerCamelCase						=						len(UpperCamelCase__       )

    __lowerCamelCase						=						[nodes[i].key for i in range(UpperCamelCase__       )]
    __lowerCamelCase						=						[nodes[i].freq for i in range(UpperCamelCase__       )]

    # This 2D array stores the overall tree cost (which's as minimized as possible);
    # for a single key, cost is equal to frequency of the key.
    __lowerCamelCase						=						[[freqs[i] if i == j else 0 for j in range(UpperCamelCase__       )] for i in range(UpperCamelCase__       )]
    # sum[i][j] stores the sum of key frequencies between i and j inclusive in nodes
    # array
    __lowerCamelCase						=						[[freqs[i] if i == j else 0 for j in range(UpperCamelCase__       )] for i in range(UpperCamelCase__       )]
    # stores tree roots that will be used later for constructing binary search tree
    __lowerCamelCase						=						[[i if i == j else 0 for j in range(UpperCamelCase__       )] for i in range(UpperCamelCase__       )]

    for interval_length in range(2       ,						n + 1       ):
        for i in range(n - interval_length + 1       ):
            __lowerCamelCase						=						i + interval_length - 1

            __lowerCamelCase						=						sys.maxsize  # set the value to "infinity"
            __lowerCamelCase						=						total[i][j - 1] + freqs[j]

            # Apply Knuth's optimization
            # Loop without optimization: for r in range(i, j + 1):
            for r in range(root[i][j - 1]       ,						root[i + 1][j] + 1       ):  # r is a temporal root
                __lowerCamelCase						=						dp[i][r - 1] if r != i else 0  # optimal cost for left subtree
                __lowerCamelCase						=						dp[r + 1][j] if r != j else 0  # optimal cost for right subtree
                __lowerCamelCase						=						left + total[i][j] + right

                if dp[i][j] > cost:
                    __lowerCamelCase						=						cost
                    __lowerCamelCase						=						r

    print('''Binary search tree nodes:'''       )
    for node in nodes:
        print(UpperCamelCase__       )

    print(f"""\nThe cost of optimal BST for given tree nodes is {dp[0][n - 1]}."""       )
    print_binary_search_tree(UpperCamelCase__       ,						UpperCamelCase__       ,						0       ,						n - 1       ,						-1       ,						UpperCamelCase__       )






def __lowerCAmelCase				(							)			->					List[Any]:
    # A sample binary search tree
    __lowerCamelCase						=						[Node(UpperCamelCase__       ,						randint(1       ,						50       )       ) for i in range(10       ,						0       ,						-1       )]
    find_optimal_binary_search_tree(UpperCamelCase__       )


if __name__ == "__main__":
  main()

'''simple docstring'''




__UpperCAmelCase  							=1_0**8






def __lowerCAmelCase				(							UpperCamelCase__       )			->					bool:
    if n % 10 == 0:
        return False
    __lowerCamelCase						=						str(UpperCamelCase__       )
    return s == s[::-1]






def __lowerCAmelCase				(							)			->					int:
    __lowerCamelCase						=						set()
    __lowerCamelCase						=						1
    __lowerCamelCase						=						5
    while sum_squares < LIMIT:
        __lowerCamelCase						=						first_square + 1
        while sum_squares < LIMIT:
            if is_palindrome(UpperCamelCase__       ):
                answer.add(UpperCamelCase__       )
            last_square += 1
            sum_squares += last_square**2
        first_square += 1
        __lowerCamelCase						=						first_square**2 + (first_square + 1) ** 2

    return sum(UpperCamelCase__       )


if __name__ == "__main__":
  print(solution())
