[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)