所有等于K的唯一组合

在编程中，经常遇到需要找出所有等于K的组合的问题。本文将介绍如何使用Python解决这个问题，并提供相关代码示例。

问题描述

现有一个整数数组，你需要找出其中所有唯一的组合使其总和等于K。数组中的数字可以重复使用，并且数组中如果有重复数字，则可以重复选取该数字以组成不同的组合。

例如，假设数组为[1, 2, 3]，K为4，则可能的组合为[1, 1, 1, 1], [1, 1, 2], [1, 3], [2, 2]和[3, 1]。 注意，不能将[2, 1, 1]和[1, 1, 2]算作两种不同的组合，它们实际上是相同的组合。

解决方法

方法一：回溯法

回溯法通常用于解决走迷宫、求组合等问题。回溯法的核心思想是在每一步枚举所有的可能性，如果发现不符合条件，则返回上一步重新选择。

在这个问题中，可以使用回溯法来递归地生成所有可能的组合，如果和为K，则将该组合添加到结果中。如果和大于K，则返回上一步重新选择。

def combination_sum(arr, target):
    '''
    返回所有和为target的组合
    '''
    def backtrack(start, path, sum):
        if sum == target:
            ans.append(path[:])
            return
        if sum > target:
            return
        for i in range(start, len(arr)):
            path.append(arr[i])
            backtrack(i, path, sum + arr[i])
            path.pop()

    ans = []
    arr.sort()
    backtrack(0, [], 0)
    return ans

上面代码使用了回溯法来实现，时间复杂度为$O(2^n)$，其中n是数组的长度。

方法二：动态规划

使用动态规划，可以将时间复杂度优化为$O(n^2)$。我们可以定义一个二维数组dp[i][j]，表示在前i个数中选数（可以重复选择）的和等于j的组合数量。状态转移方程为：$$dp[i][j] = dp[i - 1][j] + dp[i][j - arr[i]]$$

其中dp[i - 1][j]表示不使用当前元素arr[i]的情况下，前i-1个元素中和为j的组合数量；dp[i][j - arr[i]]表示使用当前元素arr[i]的情况下，前i个元素中和为j的组合数量。

def combination_sum(arr, target):
    '''
    返回所有和为target的组合
    '''
    n = len(arr)
    dp = [[0] * (target + 1) for _ in range(n + 1)]
    dp[0][0] = 1
    for i in range(1, n + 1):
        for j in range(target + 1):
            dp[i][j] = dp[i - 1][j] + (dp[i][j - arr[i - 1]] if j >= arr[i - 1] else 0)
    ans = []
    def backtrack(start, path, sum):
        if sum == target:
            ans.append(path[:])
            return
        if sum > target:
            return
        for i in range(start, len(arr)):
            path.append(arr[i])
            backtrack(i, path, sum + arr[i])
            path.pop()
    backtrack(0, [], 0)
    return ans

总结

以上两种方法都可以解决该问题，回溯法速度较慢，但可以处理无序数组中的重复项。 动态规划速度更快，但不能处理无序数组中的重复项。