子集和变化，动态规划

Question

I'm trying to do the classic subset sum problem with the caveat that the sum of the subset should get as close as possible to tgt without exceeding it. Here is my recurrence which finds how far away the sum of the subset of numbers is from the number, which is working as expected. The inf is acknowledging that if the sum goes above tgt , we don't want it:

def targetSum(S, i,  tgt):
    # your code here
    k = len(S)
    #base case
    if tgt < 0:
        return float('inf')
    if i >= k and tgt >= 0:
        return tgt
    else:
        return min(targetSum(S, i+1, tgt-S[i]), targetSum(S, i+1, tgt))

For the memo table, here's the instructions:

Memoize your recurrence by using a memo table of the form [(,)] wherein 0≤≤() and 0≤≤. It may be helpful to add a function lookupMemoTable inside your code to help you handle lookups where <0. Assume that the target satisfies tgt >= 0.

I couldn't figure out the function lookupMemoTable (which is probably my problem), but here's my code so far, which works for some examples (a1 = [1, 2, 3, 4, 5, 10], tgt = 15) but not all (a3= [11, 23, 37, 48, 94, 152, 230, 312, 339, 413], tgt = 457):

def memoTargetSum(S, tgt):
    k = len(S)
    assert tgt >= 0
    ## Fill in base case for T[(i,j)] where i == k
    T = {} # Memo table initialized as empty dictionary
    for j in range(tgt+1):
        T[(k,j)] = j
        #print(T[(k,j)], j)
        
    #def lookupMemoTable

    for i in range(k-1, -1, -1):
        for j in range(tgt, -1, -1):
            if T[(i + 1, j)]-S[i] < 0:
                T[(i,j)] = T[(i + 1, j)]
            else:
                T[(i,j)] = T[(i + 1, j)]-S[i]
    print(T)
    return T

Thanks in advance for your help!

Answer 1

I do not think you have to completely change the whole function. The table is used to store calculations that could be used again later. You can add the result of each recursive call to your dict . If the function is called again with the same input you can simply return the value inside the dict . For example, something like this:

a3 = [11, 23, 37, 48, 94, 152, 230, 312, 339, 413]
tgt = 457

mem = {}

def targetSum(S, i,  tgt):
    k = len(S)
    
    # If calculation with this input is already computed return result from mem
    if (i,tgt) in mem:
        print('used mem')
        return mem[(i,tgt)]
    
    if tgt < 0:
        return float('inf')
    if i >= k and tgt >= 0:
        return tgt
    else:        
        minimum =  min(targetSum(S, i+1, tgt-S[i]), targetSum(S, i+1, tgt))
        
        # Store result of current calculation in mem if needed again later
        mem[(i,tgt)] = minimum
        return minimum
        

targetSum(a3, 0, tgt)