使用动态编程从 Python 上的子集总和问题中获取所有子集

Question

I am trying to extract all subsets from a list of elements which add up to a certain value.

Example -

• List = [1,3,4,5,6]
• Sum - 9
• Output Expected = [[3,6],[5,4]]

Have tried different approaches and getting the expected output but on a huge list of elements it is taking a significant amount of time. Can this be optimized using Dynamic Programming or any other technique.

Approach-1

def subset(array, num):
    result = []
    def find(arr, num, path=()):
        if not arr:
            return
        if arr[0] == num:
            result.append(path + (arr[0],))
        else:
            find(arr[1:], num - arr[0], path + (arr[0],))
            find(arr[1:], num, path)
    find(array, num)
    return result

numbers = [2, 2, 1, 12, 15, 2, 3]
x = 7
subset(numbers,x)

Approach-2

def isSubsetSum(arr, subset, N, subsetSize, subsetSum, index , sum):
    global flag
    if (subsetSum == sum):
        flag = 1
        for i in range(0, subsetSize):
            print(subset[i], end = " ")
        print("")
    else:
        for i in range(index, N):
            subset[subsetSize] = arr[i]
            isSubsetSum(arr, subset, N, subsetSize + 1, 
                        subsetSum + arr[i], i + 1, sum)

Answer 1

If you want to output all subsets you can't do better than a sluggish O(2^n) complexity, because in the worst case that will be the size of your output and time complexity is lower-bounded by output size (this is a known NP-Complete problem). But, if rather than returning a list of all subsets, you just want to return a boolean value indicating whether achieving the target sum is possible, or just one subset summing to target (if it exists), you can use dynamic programming for a pseudo-polynomial O(nK) time solution, where n is the number of elements and K is the target integer.

The DP approach involves filling in an (n+1) x (K+1) table, with the sub-problems corresponding to the entries of the table being:

DP[i][k] = subset(A[i:], k) for 0 <= i <= n, 0 <= k <= K

That is, subset(A[i:], k) asks, 'Can I sum to (little) k using the suffix of A starting at index i?' Once you fill in the whole table, the answer to the overall problem, subset(A[0:], K) will be at DP[0][K]

The base cases are for i=n: they indicate that you can't sum to anything except for 0 if you're working with the empty suffix of your array

subset(A[n:], k>0) = False, subset(A[n:], k=0) = True

The recursive cases to fill in the table are:

subset(A[i:], k) = subset(A[i+1:, k) OR (A[i] <= k AND subset(A[i+i:], k-A[i])) 

This simply relates the idea that you can use the current array suffix to sum to k either by skipping over the first element of that suffix and using the answer you already had in the previous row (when that first element wasn't in your array suffix), or by using A[i] in your sum and checking if you could make the reduced sum kA[i] in the previous row. Of course, you can only use the new element if it doesn't itself exceed your target sum.

ex: subset(A[i:] = [3,4,1,6], k = 8) would check: could I already sum to 8 with the previous suffix (A[i+1:] = [4,1,6])? No. Or, could I use the 3 which is now available to me to sum to 8? That is, could I sum to k = 8 - 3 = 5 with [4,1,6]? Yes. Because at least one of the conditions was true, I set DP[i][8] = True

Because all the base cases are for i=n, and the recurrence relation for subset(A[i:], k) relies on the answers to the smaller sub-problems subset(A[i+i:],...), you start at the bottom of the table, where i = n, fill out every k value from 0 to K for each row, and work your way up to row i = 0, ensuring you have the answers to the smaller sub-problems when you need them.

def subsetSum(A: list[int], K: int) -> bool:
  N = len(A)
  DP = [[None] * (K+1) for x in range(N+1)]
  DP[N] = [True if x == 0 else False for x in range(K+1)]

  for i in range(N-1, -1, -1):
    Ai = A[i]
    DP[i] = [DP[i+1][k] or (Ai <=k and DP[i+1][k-Ai]) for k in range(0, K+1)]

  # print result
  print(f"A = {A}, K = {K}")
  print('Ai,k:', *range(0,K+1), sep='\t')
  for (i, row) in enumerate(DP): print(A[i] if i < N else None, *row, sep='\t')
  print(f"DP[0][K] = {DP[0][K]}")
  return DP[0][K]

subsetSum([1,4,3,5,6], 9)

If you want to return an actual possible subset alongside the bool indicating whether or not it's possible to make one, then for every True flag in your DP you should also store the k index for the previous row that got you there (it will either be the current k index or kA[i], depending on which table lookup returned True, which will indicate whether or not A[i] was used). Then you walk backwards from DP[0][K] after the table is filled to get a subset. This makes the code messier but it's definitely do-able. You can't get all subsets this way though (at least not without increasing your time complexity again) because the DP table compresses information.

Answer 2

Here is the optimized solution to the problem with a complexity of O(n^2).

def get_subsets(data: list, target: int):
# initialize final result which is a list of all subsets summing up to target
subsets = []

# records the difference between the target value and a group of numbers
differences = {}

for number in data:
    prospects = []

    # iterate through every record in differences
    for diff in differences:

        # the number complements a record in differences, i.e. a desired subset is found
        if number - diff == 0:
            new_subset = [number] + differences[diff]
            new_subset.sort()
            if new_subset not in subsets:
                subsets.append(new_subset)

        # the number fell short to reach the target; add to prospect instead
        elif number - diff < 0:
            prospects.append((number, diff))

    # update the differences record
    for prospect in prospects:
        new_diff = target - sum(differences[prospect[1]]) - prospect[0]
        differences[new_diff] = differences[prospect[1]] + [prospect[0]]
    differences[target - number] = [number]

return subsets