## You are given a pizza (perfect circle) that has been cut into $m \cdot n$ equal pieces and you want to have exactly one topping on each slice.

Let $f(m, n)$ denote the number of ways you can have toppings on the pizza with $m$ different toppings ($m \ge 2$), using each topping on exactly $n$ slices ($n \ge 1$).Reflections are considered distinct, rotations are not.

Thus, for instance, $f(2,1) = 1$, $f(2, 2) = f(3, 1) = 2$ and $f(3, 2) = 16$. $f(3, 2)$ is shown below:

Find the sum of all $f(m, n)$ such that $f(m, n) \le 10^{15}$.

### To solve this problem, we can use dynamic programming to calculate the values of $f(m, n)$ for different values of $m$ and $n$. Here’s a step-by-step approach to solving this problem using Python:

1. Create a function `calculate_ways(m, n)` to calculate the number of ways you can have toppings on the pizza with m different toppings, using each topping on exactly n slices.

2. Initialize an empty dictionary `memo` to store the calculated values of `f(m, n)`, where the keys are tuples (m, n).

3. Within the `calculate_ways()` function, add a base case to handle the smallest values of m and n. If m = 2 and n = 1, return 1. If m = 1, return 0.

4. Check if the value of `f(m, n)` has already been calculated and stored in the `memo` dictionary. If it has, return the stored value.

5. If the value of `f(m, n)` is not in the `memo` dictionary, calculate it recursively by considering all possible ways to place the toppings on the pizza. You can do this by making recursive calls to `calculate_ways()` for different values of m and n.

– For each topping, you can choose either to place it on a single slice or on multiple adjacent slices. If you choose to place it on a single slice, reduce the value of m by 1 and the value of n by 1. If you choose to place it on multiple adjacent slices, reduce the value of n by 1 and keep m the same.

– Sum up the number of ways obtained from all possible choices and store it in the `memo` dictionary.

6. Finally, return the calculated value of `f(m, n)`.

7. Initialize a variable `sum_f` to keep track of the sum of all the values of `f(m, n)` that are less than or equal to 10^15.

8. Use nested loops to iterate over values of m and n and calculate `f(m, n)`. Keep adding the calculated values to `sum_f` as long as they are less than or equal to 10^15. Break the loop as soon as a value greater than 10^15 is encountered.

9. Finally, print the value of `sum_f`.

Here’s the Python code that implements this approach:

“`python

def calculate_ways(m, n, memo):

if m == 2 and n == 1:

return 1

if m == 1:

return 0

if (m, n) in memo:

return memo[(m, n)]

ways = 0

for i in range(1, n+1):

ways += calculate_ways(m-1, n-i, memo)

memo[(m, n)] = ways

return ways

sum_f = 0

for m in range(2, 101):

for n in range(1, 101):

ways = calculate_ways(m, n, {})

if ways > 10**15:

break

sum_f += ways

print(sum_f)

“`

The code should output the sum of all `f(m, n)` values less than or equal to 10^15.

##### More Answers:

Linear Combinations of SemiprimesTriangles with Integral Sides and an Integral Angle

Ant and Seeds