Add 494

Author: trung-hn

Readme.md

@@ -160,6 +160,7 @@ https://leetcode.com/jummyegg/
 | 474 | Ones and Zeroes | Medium | O(K\*M\*N) | O(K\*M\*N) | Dynamic Programming | | |
 | 476 | Number Complement | Easy | O(N) | O(1) | Bit Manipulation | | |
 | 478 | Generate Random Point in a Circle | Medium | O(1) | O(1) | Math, Random, Rejection Sampling | | |
+| 494 | Target Sum | Medium | O(N\*T) | O(T) | Dynamic Programming, DFS | Template for DP | |
 | 495 | Teemo Attacking | Medium | O(N) | O(1) | Array | | |
 | 497 | Random Point in Non-overlapping Rectangles | Medium | O(logN) | O(N) | Design, Binary Search | | |
 | 498 | Diagonal Traverse | Medium | O(R\*C) | O(R\*C) | Array | | |

src/1552.magnetic-force-between-two-balls.py

@@ -7,6 +7,8 @@
 # @lc code=start
 # TAGS: Binary Search
 # REVIEWME: Very Tricky problem, Template for Binary Search
+
+
 class Solution:
     """
     Template for Binary Search:
@@ -29,23 +31,25 @@ class Solution:
     """
     # Inspired from https://leetcode.com/problems/magnetic-force-between-two-balls/discuss/794070/Python-Binary-search-solution-with-explanation-and-similar-questions
     # Time: O(NlogN). Space: O(1). This is usually used for bisect_left
+
     def maxDistance(self, position: List[int], m: int) -> int:
         position.sort()
+
         def count(d):
             prev = position[0]
             cnt = 1
             for val in position[1:]:
-                if val - prev >= d: 
-                    cnt += 1 
+                if val - prev >= d:
+                    cnt += 1
                     prev = val
             return cnt
-        
+
         lo, hi = 0, position[-1] - position[0]
         while lo < hi:
             mid = (lo + hi) // 2
-            if count(mid) >= m: # means balls are too tightly packed. we can increase space between them
+            if count(mid) >= m:  # means balls are too tightly packed. we can increase space between them
                 lo = mid + 1
-            else: # means space are too large, we should decrease packing space. 
+            else:  # means space are too large, we should decrease packing space.
                 hi = mid
         if count(lo) == m:
             return lo
@@ -54,22 +58,23 @@ def count(d):
     # 1308 ms, 87.47 %. Similar to bisect_right
     def maxDistance(self, position: List[int], m: int) -> int:
         position.sort()
+
         def count(d):
             prev = position[0]
             cnt = 1
             for val in position[1:]:
-                if val - prev >= d: 
-                    cnt += 1 
+                if val - prev >= d:
+                    cnt += 1
                     prev = val
             return cnt
-        
+
         lo, hi = 0, position[-1] - position[0]
         while lo < hi:
             mid = hi - (hi - lo) // 2
-            if count(mid) >= m: 
+            if count(mid) >= m:
                 lo = mid
             else:
                 hi = mid - 1
         return lo
-    
+
 # @lc code=end

src/494.target-sum.py

@@ -0,0 +1,49 @@
+#
+# @lc app=leetcode id=494 lang=python3
+#
+# [494] Target Sum
+#
+
+# @lc code=start
+# TAGS: Dynamic Programming, DFS
+# REVIEWME: Dynamic Programming, Template for DP
+import collections
+
+
+class Solution:
+    # 256 ms, 68.25%. Time and Space: O(N*T). Top down approach, dfs with memo
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        @cache
+        def dfs(i=0, sofar=0):
+            if i == len(nums):
+                return sofar == target
+            add = dfs(i + 1, sofar + nums[i])
+            sub = dfs(i + 1, sofar - nums[i])
+            return add + sub
+        return dfs()
+
+    # 3120 ms, 5.03%. Time and Space: O(N*T). Bottom Up approach.
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        dp = collections.defaultdict(int)
+        dp[(0, 0)] = 1
+        for i, val in enumerate(nums, 1):
+            # Try all possible sum
+            for sm in range(-1000, 1001):
+                dp[(i, sm + val)] += dp[(i - 1, sm)]
+                dp[(i, sm - val)] += dp[(i - 1, sm)]
+        return dp[len(nums), target]
+
+    # 192 ms, 84.11%. Time: O(N*T). Space: O(T) Bottom up approach with optimized space
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        dp = {0: 1}
+        for i, val in enumerate(nums):
+            nxt = collections.defaultdict(int)
+            # Only try sum that are in dp
+            for sofar in dp:
+                nxt[sofar + val] += dp[sofar]
+                nxt[sofar - val] += dp[sofar]
+            dp = nxt
+        return dp[target]
+
+
+# @lc code=end