494. Target Sum

Author: Partho Biswas

README.md

@@ -511,6 +511,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 
 
 ### 16. [Dynamic Programming](https://www.educative.io/courses/grokking-dynamic-programming-patterns-for-coding-interviews)
+**Follow [this](https://tinyurl.com/vmmaxbe) golden rule to approach any DP problem.**
 <details><summary>Leetcode problems with solutions and tutorials/videos</summary>
 <p>
 
@@ -539,7 +540,8 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 |21| **[198. House Robber](https://leetcode.com/problems/house-robber/)**| [Python](https://tinyurl.com/wu6rdaw/198_House_Robber.py)| **[Must](https://tinyurl.com/vp9v27d)** | Easy | A Gold Mine |
 |22| [213. House Robber II](https://leetcode.com/problems/house-robber-ii/)| [Python](https://tinyurl.com/wu6rdaw/213_House_Robber_II.py)| [Art 1](https://tinyurl.com/wwza8d5), [Art 2](https://tinyurl.com/qtqwcl4) | Medium | --- |
 |23| [337. House Robber III](https://leetcode.com/problems/house-robber-iii/)| [Python](https://tinyurl.com/wu6rdaw/337_House_Robber_III.py)| **[Art 1](https://tinyurl.com/yd8zjvvj)** | Medium | **[Another gold mine](https://tinyurl.com/yd8zjvvj)**, hidden greedy and DFS |
-|24| [416. Partition Equal Subset Sum](https://tinyurl.com/rmf5upz)| [Python](https://tinyurl.com/wu6rdaw/416_Partition_Equal_Subset_Sum.py)| **[educative.io](https://tinyurl.com/wpxxyjy)**, [Art 1](https://tinyurl.com/we99l2n), [Vid 1](https://tinyurl.com/vvtavaw), [Vid 2](https://tinyurl.com/wabhu46), [Vid 3](https://tinyurl.com/sk89wa3), [Vid 4](https://tinyurl.com/z352yjj) | Medium | **0/1 Knapsack**, Very important |
+|24| **[416. Partition Equal Subset Sum](https://tinyurl.com/rmf5upz)** | [Python](https://tinyurl.com/wu6rdaw/416_Partition_Equal_Subset_Sum.py)| **[educative.io](https://tinyurl.com/wpxxyjy)**, [Art 1](https://tinyurl.com/we99l2n), [Vid 1](https://tinyurl.com/vvtavaw), [Vid 2](https://tinyurl.com/wabhu46), [Vid 3](https://tinyurl.com/sk89wa3), [Vid 4](https://tinyurl.com/z352yjj) | Medium | **0/1 Knapsack**, Very important |
+|25| **[494. Target Sum](https://tinyurl.com/ro8wdkz)** | [Python](https://tinyurl.com/wu6rdaw/494_Target_Sum.py)| **[educative.io](https://tinyurl.com/wfhzh29)**, **[MUST MUST READ](https://tinyurl.com/vmmaxbe)** | Medium | **0/1 Knapsack**, Very important |
 
 </p>
 </details>

leetcode.com/python/494_Target_Sum.py

@@ -0,0 +1,53 @@
+class Solution(object):
+    def findTargetSumWays(self, nums, S):
+        """
+        :type nums: List[int]
+        :type S: int
+        :rtype: int
+        """
+        totalSum = sum(nums)
+
+        # if 's + totalSum' is odd, we can't find a subset with sum equal to '(s + totalSum) / 2'
+        if totalSum < S or (S + totalSum) % 2 == 1:
+            return 0
+
+        return self.findTargetSumWaysHelper(nums, int((S + totalSum) / 2))
+
+
+    def findTargetSumWaysHelper(self, nums, S):
+        numsLen = len(nums)
+        dp = [[0 for _ in range(S + 1)] for _ in range(numsLen)]
+
+        # populate the sum = 0 columns, as we will always have an empty set for zero sum
+        for i in range(numsLen):
+            dp[i][0] = 1
+
+        # with only one number, we can form a subset only when the required sum is
+        # equal to the number
+        for s in range(1, S + 1):
+            dp[0][s] = 1 if nums[0] == s else 0
+
+        # process all subsets for all sums
+        for i in range(1, numsLen):
+            for j in range(1, S + 1):
+                dp[i][j] = dp[i - 1][j]     # exclude the number
+                if S >= nums[i]:            # include the number, if it does not exceed the sum
+                    # positive = dp[i][j] + dp[i - 1][j - nums[i]]
+                    # negative = dp[i][j] + dp[i - 1][j - nums[i]]
+
+                    positive = j + i
+                    negative = j + (-i)
+                    dp[i][j] = positive + negative
+
+                    # dp[i][j] = dp[i][j] + dp[i - 1][j - nums[i]]
+
+        # the bottom-right corner will have our answer.
+        return dp[numsLen - 1][S]
+
+
+
+sol = Solution()
+nums = [0,0,0,0,0,0,0,0,1]
+S = 1
+out = sol.findTargetSumWays(nums, S)
+print("Res: ", out)

leetcode.com/python/698_Partition_to_K_Equal_Sum_Subsets.py

@@ -0,0 +1,124 @@
+# Naive solution using simple backtracking. Time Limit Exceeded
+class Solution(object):
+    def canPartitionKSubsets(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: bool
+        """
+        sumOfItems = sum(nums)
+        if sumOfItems % k != 0:              # if 's' is a an odd number, we can't have two subsets with equal sum
+            return False
+        if k == 1:
+            return True
+        return self.canPartitionHelper(nums, sumOfItems/k, 0)
+
+
+    def canPartitionHelper(self, nums, sumOfItems, currentIndex):
+        if sumOfItems == 0:            # base check
+            return True
+        numsLen = len(nums)
+        if numsLen == 0 or currentIndex >= numsLen:
+            return False
+
+        # recursive call after choosing the number at the `currentIndex`
+        # if the number at `currentIndex` exceeds the sum, we shouldn't process this
+        if nums[currentIndex] <= sumOfItems:
+            if self.canPartitionHelper(nums, sumOfItems - nums[currentIndex], currentIndex + 1):
+                return True # Backtrack
+
+        # recursive call after excluding the number at the 'currentIndex'
+        return self.canPartitionHelper(nums, sumOfItems, currentIndex + 1)
+
+
+
+
+#
+#
+#
+# # Solution using simple backtracking and memoization. Dynamic Programming on Top-Down approach. Accepted
+# class Solution(object):
+#     def canPartitionKSubsets(self, nums, k):
+#         """
+#         :type nums: List[int]
+#         :type k: int
+#         :rtype: bool
+#         """
+#         s = sum(nums)
+#         if s % k != 0:              # if 's' is a an odd number, we can't have two subsets with equal sum
+#             return False
+#         dp = [[-1 for _ in range(int(s/k) + 1)] for _ in nums]
+#         return True if self.canPartitionHelper(nums, s/k, 0, dp) == 1 else False
+#
+#
+#     def canPartitionHelper(self, nums, sum, currentIndex, dp):
+#         if sum == 0:            # base check
+#             return 1
+#         numsLen = len(nums)
+#         if numsLen == 0 or currentIndex >= numsLen:
+#             return 0
+#
+#         # if we have not already processed a similar problem
+#         if dp[currentIndex][sum] == -1:
+#             # recursive call after choosing the number at the `currentIndex`
+#             # if the number at `currentIndex` exceeds the sum, we shouldn't process this
+#             if nums[currentIndex] <= sum:
+#                 if self.canPartitionHelper(nums, sum - nums[currentIndex], currentIndex + 1, dp):
+#                     dp[currentIndex][sum] = 1
+#                     return 1 # Backtrack
+#
+#             # recursive call after excluding the number at the 'currentIndex'
+#             dp[currentIndex][sum] = self.canPartitionHelper(nums, sum, currentIndex + 1, dp)
+#         return dp[currentIndex][sum]
+#
+#
+#
+#
+#
+# # Solution using Dynamic Programming on Bottom-up approach. Accepted
+# class Solution(object):
+#     def canPartitionKSubsets(self, nums, k):
+#         """
+#         :type nums: List[int]
+#         :type k: int
+#         :rtype: bool
+#         """
+#         if k == 1: return True
+#         s = sum(nums)
+#         if s % k != 0:  # if 's' is a an odd number, we can't have two subsets with equal sum
+#             return False
+#
+#         # we are trying to find a subset of given numbers that has a total sum of 's/2'.
+#         s = int(s / k)
+#
+#         numsLen = len(nums)
+#         dp = [[False for _ in range(int(s) + 1)] for _ in range(numsLen)]
+#
+#
+#         # populate the s=0 columns, as we can always for '0' sum with an empty set
+#         for i in range(numsLen):
+#             dp[i][0] = True
+#
+#         # with only one number, we can form a subset only when the required sum is
+#         # equal to its value
+#         for j in range(1, s + 1):
+#             dp[0][j] = nums[0] == j
+#
+#         # process all subsets for all sums
+#         for i in range(1, numsLen):
+#             for j in range(1, s + 1):
+#                 if dp[i - 1][j]:  # if we can get the sum 'j' without the number at index 'i'
+#                     dp[i][j] = dp[i - 1][j]
+#                 elif j >= nums[i]:  # else if we can find a subset to get the remaining sum
+#                     dp[i][j] = dp[i - 1][j - nums[i]]
+#
+#         return dp[numsLen - 1][s]
+#
+
+
+
+sol = Solution()
+nums = [2,2,2,2,3,4,5]
+k = 4
+out = sol.canPartitionKSubsets(nums, k)
+print("Result: ", out)