Update 494_target_sum.md

Author: Joseph Luce

leetcode/medium/494_target_sum.md

@@ -26,22 +26,20 @@ class Solution:
 ```
 
 ## Iterative Solution with Map
-- Runtime: O(N*U)
-- Space: O(U)
+- Runtime: O(N^2)
+- Space: O(N^2)
 - N = Number of elements in array
-- U = Number of unique sums (Worst case U=2^N)
 
 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, U can be 2^N for the worst case (2,4,8,16,32...).
-Now, you may think this is solution is terrible compared to the previous recursive solution.
-That maybe true but only if we were to always create a unique sum every single time.
-Maybe an input like [1,10,100,1000,10000...]
+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 U is actually less than O(2^N) on most cases while the brute force solution above will always be ran at 2^N.
+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.
 
 ```
 from collections import defaultdict