[Leetcode] DP -- Target Sum

You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.

Find out how many ways to assign symbols to make sum of integers equal to target S.

Example 1:

Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to assign symbols to make the sum of nums be target 3.

Solution:

 

1st use  DFS recursive,  like a binary tree;   Go to left (+1) or right (-1); then  when sum is S  go the upper next。

But it is TLE in python

 

    count = 0
    def findTargetSumWays(self, nums, S):
        def findTargetHelper(nums, index, S):
            if index == len(nums):
                if S == 0:
                    self.count = self.count + 1
                return
             
        
            findTargetHelper(nums, index+1, S - nums[index])         #+1
            findTargetHelper(nums, index+1, S + nums[index])         #-1
        
        findTargetHelper(nums, 0, S)

        return self.count

2.   DP

Refer to the other's idea that I didn't came up with .   

this problem could be transferred to subset sum problem (similar to knapback problem)

if there exist a solution,

P: positive number subset;     N: positive number subset

 then sum(P) - sum(N)  = S;               |P| + |N| = len(nums)

so  sum(P) + sum(N) + sum(P) - sum(N) =  S + sum(P) + sum(N)

         2*sum(P) = S + sum(nums)

            sum(P) = (S + sum(nums))/2

 the original problem  has been changed to a subset sum problem: :

Find a subset P of nums such that sum(P) = (target + sum(nums)) / 2

 

reference:

http://bgmeow.xyz/2017/01/29/LeetCode-494/

 

        def subsetSum(nums, target):
            dp = [0]*(target+1)
            dp[0] = 1
            for num in nums:
                for j in range(target, num-1, -1):
                    dp[j] += dp[j-num]
                    #print ("dp: ", target, j, dp[j])
            return dp[target]
            
        sumN = sum(nums)
        
        if sumN < S or (S+sumN) %2 != 0:
            return 0
        return subsetSum(nums, (S+sumN)>>1)