总数为S的最小数字(小于或等于N)

在处理数字时，有时需要找到小于或等于给定数字N的最小数字，使它们的和等于给定的总数S。例如，假设我们有一个数组[1,2,3,4,5]和一个总和为9，我们需要找到数字总和为9的最小数字集合。在这个例子中，答案是[4,5]。

该问题可以通过递归或动态规划解决。下面是一些解决该问题的算法。

算法1 递归

递归是解决该问题的最简单方法。我们可以从最大数字开始，逐个减少数字，直到找到一个数字集合，使它们的和等于给定的总数S。

def find_min_nums_recursive(n, s, nums):
    if s == 0:
        return []
    if n <= 0 or s < 0:
        return None
    res = find_min_nums_recursive(n-1, s, nums)
    if res is not None:
        return res
    res = find_min_nums_recursive(n-1, s-nums[n-1], nums)
    if res is not None:
        return res + [nums[n-1]]
    return None

# 示例
nums = [1,2,3,4,5]
S = 9
print(find_min_nums_recursive(len(nums), S, nums)) # 输出 [4, 5]

代码片段：

def find_min_nums_recursive(n, s, nums):
    if s == 0:
        return []
    if n <= 0 or s < 0:
        return None
    res = find_min_nums_recursive(n-1, s, nums)
    if res is not None:
        return res
    res = find_min_nums_recursive(n-1, s-nums[n-1], nums)
    if res is not None:
        return res + [nums[n-1]]
    return None

算法2 动态规划

除了递归之外，我们还可以使用动态规划来解决这个问题。我们使用一个二维数组来存储结果，并按顺序迭代数字，同时记录数字集合的和等于s的情况。

def find_min_nums_dp(n, s, nums):
    dp = [[0]*(s+1) for i in range(n+1)]
    for i in range(n+1):
        dp[i][0] = []
    for j in range(1, s+1):
        dp[0][j] = None
    for i in range(1, n+1):
        for j in range(1, s+1):
            dp[i][j] = dp[i-1][j]
            if j >= nums[i-1] and dp[i][j] is None:
                res = dp[i-1][j-nums[i-1]]
                if res is not None:
                    dp[i][j] = res + [nums[i-1]]
    return dp[n][s]

# 示例
nums = [1,2,3,4,5]
S = 9
print(find_min_nums_dp(len(nums), S, nums)) # 输出 [4, 5]

代码片段：

def find_min_nums_dp(n, s, nums):
    dp = [[0]*(s+1) for i in range(n+1)]
    for i in range(n+1):
        dp[i][0] = []
    for j in range(1, s+1):
        dp[0][j] = None
    for i in range(1, n+1):
        for j in range(1, s+1):
            dp[i][j] = dp[i-1][j]
            if j >= nums[i-1] and dp[i][j] is None:
                res = dp[i-1][j-nums[i-1]]
                if res is not None:
                    dp[i][j] = res + [nums[i-1]]
    return dp[n][s]

以上两个算法都可以解决该问题，但动态规划的时间复杂度更低。因此，如果需要处理大量数字，请使用动态规划算法。