如何判断数字是否可以写为 n 个不同平方的总和？

Question

我知道如何使用蛮力方法检查数字是否可以表示为两个平方和。

def sumSquare( n) :
    i = 1
    while i * i <= n :
        j = 1
        while(j * j <= n) :
            if (i * i + j * j == n) :
                print(i, "^2 + ", j , "^2" )
                return True
            j = j + 1
        i = i + 1

    return False

但是如何为 n 个不同的正整数做到这一点。所以问题是：

检查数字是否可以写为“n”个不同平方之和的函数

我有一些例子。

例如

1. is_sum_of_squares(18, 2) 将是错误的，因为 18 可以写成两个平方的和 (3^2 + 3^2)，但它们并不不同。
2. (38,3) 为真，因为 5^2+3^2+2^2 = 38 和 5!=3!=2。

我无法扩展if 条件以获得更多值。我认为这可以通过递归来完成，但我有问题。

我发现这个函数非常有用，因为它可以找到数字可以分割成的平方数。

def findMinSquares(n):
    T = [0] * (n + 1)
    for i in range(n + 1):
        T[i] = i
        j = 1
        while j * j <= i:
            T[i] = min(T[i], 1 + T[i - j * j])
            j += 1

    return T[n]

但我又不能用递归来做到这一点。可悲的是，我无法绕过它。我们几周前开始学习它（我在高中），它与迭代方法有很大不同。

Answer 1

递归方法：

def is_sum_of_squares(x, n, used=None):
    x_sqrt = int(x**0.5)
    if n == 1:
        if x_sqrt**2 == x:
            return used.union([x_sqrt])
        return None
    used = used or set()
    for i in set(range(max(used, default=0)+1, int((x/n)**0.5))):
        squares = is_sum_of_squares(x-i**2, n-1, used.union([i]))
        if squares:
            return squares
    return None

Answer 2

相当引人注目的练习。我尝试以回溯的形式使用递归来解决它。从一个空列表开始，运行一个 for 循环来添加从 1 到最大可行（目标数的平方根）的数字，并为每个添加的数字继续递归。一旦列表达到所需的大小 n，验证结果。如果结果不正确，则通过删除最后一个数字来回溯。 但不确定它是否 100% 正确。在速度方面，我在 (1000,13) 输入上进行了尝试，并且过程相当快（3-4s）完成。

def is_sum_of_squares(num, count):
    max_num = int(num ** 0.5)
    return backtrack([], num, max_num, count)


def backtrack(candidates, target, max_num, count):
    """
    candidates = list of ints of max length <count>
    target = sum of squares of <count> nonidentical numbers
    max_num =  square root of target, rounded
    count = desired size of candidates list
    """
    result_num = sum([x * x for x in candidates])  # calculate sum of squares
    if result_num > target:  # if sum exceeded target number stop recursion
        return False
    if len(candidates) == count:  # if candidates reach desired length, check if result is valid and return result
        result = result_num == target
        if result:  # print for result sense check, can be removed
            print("Found: ", candidates)
        return result
    for i in range(1, max_num + 1):  # cycle from 1 to max feasible number
        if candidates and i <= candidates[-1]:
            # for non empty list, skip numbers smaller than the last number.
            # allow only ascending order to eliminate duplicates
            continue
        candidates.append(i)  # add number to list
        if backtrack(candidates, target, max_num, count):  # next recursion
            return True
        candidates.pop()  # if combination was not valid then backtrack and remove the last number
    return False


assert(is_sum_of_squares(38, 3))
assert(is_sum_of_squares(30, 3))
assert(is_sum_of_squares(30, 4))
assert(is_sum_of_squares(36, 1))
assert not(is_sum_of_squares(35, 1))
assert not(is_sum_of_squares(18, 2))
assert not(is_sum_of_squares(1000, 13))