Update 494_target_sum.md

Author: Joseph Luce

leetcode/medium/494_target_sum.md

@@ -1,7 +1,7 @@
 # 494. Target Sum
 
 ## Recursive Brute Force
-- Runtime: 2^N
+- Run-time: 2^N
 - Space: 2^N
 - N = Number of elements in array
 
@@ -12,34 +12,42 @@ Noticed how the run-time is not big O of 2^N, its because this brute force will
 class Solution:
     def findTargetSumWays(self, nums: List[int], S: int) -> int:
         
-        def find_sum_ways_helper(nums, curr_sum, start_i):
-            if curr_sum == S and start_i >= len(nums):
+        def sum_helper(curr_sum, idx):
+            if curr_sum == S and idx >= len(nums):
                 return 1
-            elif start_i >= len(nums):
+            if idx >= len(nums):
                 return 0
-            n_sums = 0
-            n_sums += find_sum_ways_helper(nums, curr_sum + nums[start_i], start_i+1)
-            n_sums += find_sum_ways_helper(nums, curr_sum - nums[start_i], start_i+1)
-            return n_sums
+            return sum_helper(curr_sum+nums[idx], idx+1) + sum_helper(curr_sum-nums[idx], idx+1)
         
-        return find_sum_ways_helper(nums, 0, 0)
+        return sum_helper(0, 0)
 ```
 
 ## Iterative Solution with Map
-- Runtime: O(N^2)
-- Space: O(N^2)
+- Run-time: O(2^N)
+- Space: O(2^N)
 - N = Number of elements in array
 
 We can use a dictionary to keep track of the sums and how many paths there are for each sum.
 We just need to maintain a rolling dictionary as we traverse across the numbers.
 Each traversal we will create new sums and add them into a new dictionary.
 We will move the values across from the old dictionary as well.
 
-For the run-time, you may think that the run-time hasn't changed.
-Why is this an improvement?
-An input like [1,10,100,1000,10000...] will achieve N^2 run time.
-However, given any other input, since its add and subtract and not multiply or divide, its unlikely and its more likely we will have overlapping sums.
-So the run time is actually less than O(2^N) on most cases while the brute force solution above will always be ran at 2^N.
+The dictionary is used to exploit the fact that there can be overlapping sums.
+You can imagine the dictionary used for each height/level of the recursion tree, gathering all the sums from the previous summation and reusing it to recalcuate for the current height.
+
+```
+                Sums for each height, Key: sum, Val: n_paths
+       1        {1: 1, -1: 1}
+    +/  \-      
+    1     1     {2: 1, 0: 2, -2: 1}
+  +/ \- +/ \-
+  1  1  1   1   {3: 1, 1: 3, -1: 3, -3: 1}
+```
+
+You may think to yourself that the run-time hasn't changed.
+You are correct, if given a set of numbers that would create unique sums for each height of the tree, this would end up being O(2^N).
+However, since this question is done with addition and subtract, it is more likely there will be overlapping sums.
+So the run-time is actually less than O(2^N) for the average case.
 
 ```
 from collections import defaultdict