LC 879. Profitable Schemes (Python Mem)

Author: raul-sauco

README.md

@@ -324,6 +324,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [872. Leaf-Similar Trees][lc872]                                                              | 🟢 Easy    | [![python](res/py.png)][lc872py]                                                                      |
 | [875. Koko Eating Bananas][lc875]                                                             | 🟠 Medium  | [![python](res/py.png)][lc875py] [![rust](res/rs.png)][lc875rs]                                       |
 | [876. Middle of the Linked List][lc876]                                                       | 🟢 Easy    | [![python](res/py.png)][lc876py]                                                                      |
+| [879. Profitable Schemes][lc879]                                                              | 🔴 Hard    | [![python](res/py.png)][lc879py]                                                                      |
 | [881. Boats to Save People][lc881]                                                            | 🟠 Medium  | [![python](res/py.png)][lc881py] [![rust](res/rs.png)][lc881rs]                                       |
 | [886. Possible Bipartition][lc886]                                                            | 🟠 Medium  | [![python](res/py.png)][lc886py]                                                                      |
 | [890. Find and Replace Pattern][lc890]                                                        | 🟠 Medium  | [![python](res/py.png)][lc890py]                                                                      |
@@ -1149,6 +1150,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc875rs]: leetcode/koko-eating-bananas.rs
 [lc876]: https://leetcode.com/problems/middle-of-the-linked-list/
 [lc876py]: leetcode/middle-of-the-linked-list.py
+[lc879]: https://leetcode.com/problems/profitable-schemes/
+[lc879py]: leetcode/profitable-schemes.py
 [lc881]: https://leetcode.com/problems/boats-to-save-people/
 [lc881py]: leetcode/boats-to-save-people.py
 [lc881rs]: leetcode/boats-to-save-people.rs

leetcode/profitable-schemes.json

@@ -0,0 +1,26 @@
+[
+  [5, 3, [2, 2], [2, 3], 2],
+  [10, 5, [2, 3, 5], [6, 7, 8], 7],
+  [1, 1, [1, 1, 1, 1, 2, 2, 1, 2, 1, 1], [0, 1, 0, 0, 1, 1, 1, 0, 2, 2], 4],
+  [
+    100,
+    100,
+    [
+      18, 58, 88, 52, 54, 13, 50, 66, 83, 61, 100, 54, 60, 80, 1, 19, 78, 54,
+      67, 20, 57, 46, 12, 6, 14, 43, 64, 81, 30, 60, 48, 53, 86, 71, 51, 23, 71,
+      87, 95, 69, 11, 12, 41, 36, 69, 89, 91, 10, 98, 31, 67, 85, 16, 83, 83,
+      14, 14, 71, 33, 5, 40, 61, 22, 19, 34, 70, 50, 21, 91, 77, 4, 36, 16, 38,
+      56, 23, 68, 51, 71, 38, 63, 52, 14, 47, 25, 57, 95, 35, 58, 32, 1, 39, 48,
+      33, 89, 9, 1, 95, 90, 78
+    ],
+    [
+      96, 77, 37, 98, 66, 44, 18, 37, 47, 9, 38, 82, 74, 12, 71, 31, 80, 64, 15,
+      45, 85, 52, 70, 53, 94, 90, 90, 14, 98, 22, 33, 39, 18, 22, 10, 46, 6, 19,
+      25, 50, 33, 15, 63, 93, 35, 0, 76, 44, 37, 68, 35, 80, 70, 66, 4, 88, 66,
+      93, 49, 19, 25, 90, 21, 59, 17, 40, 46, 79, 5, 41, 2, 37, 27, 92, 0, 53,
+      57, 91, 75, 0, 42, 100, 16, 97, 83, 75, 57, 61, 73, 21, 63, 97, 75, 95,
+      84, 14, 98, 47, 0, 13
+    ],
+    5570822
+  ]
+]

leetcode/profitable-schemes.py

@@ -0,0 +1,88 @@
+# 879. Profitable Schemes
+# 🔴 Hard
+#
+# https://leetcode.com/problems/profitable-schemes/
+#
+# Tags: Array - Dynamic Programming
+
+import json
+import os
+import timeit
+from functools import cache
+from typing import List
+
+
+# Iterate over the indexes of the jobs, gang members and profit,
+# computing the result of doing and skipping this job, if we go over
+# the maximum allowed gang members, we return 0, this combination is
+# not valid, if we reach the end of the array, we return 1 if we
+# achieved the minimum profit and 0 if we didn't.
+#
+# Time complexity: O(n*mp*g) - Where n is the max number of gang members
+# we can choose, mp is the minimum profit we need to make and g is the
+# length of the profit and group arrays, these three are the ranges of
+# the three parameters to the function that we are using to compute the
+# results, since we are memoizing the function, that is the maximum
+# number of times we may call it.
+# Space complexity: O(n*mp*g) - The size of the cache, the call stack
+# can grow to size g.
+#
+# Runtime 3903 ms Beats 26.67%
+# Memory 682.3 MB Beats 5.71%
+class Memoization:
+    def profitableSchemes(
+        self, n: int, minProfit: int, group: List[int], profit: List[int]
+    ) -> int:
+        # Explore the possibilities
+        # idx: the index we are checking.
+        # p: the profit up to that point.
+        # g: the number of people pooled up to that point.
+        # return: the number of profitable schemes of that branch.
+        @cache
+        def dfs(i: int, p: int, g: int) -> int:
+            # Base case, we went over the group size limit.
+            if g > n:
+                return 0
+            # Base case, we run out of indexes.
+            if i == len(group):
+                return int(p == minProfit)
+            return dfs(
+                i + 1, min(minProfit, p + profit[i]), g + group[i]
+            ) + dfs(i + 1, p, g)
+
+        # Return the result of the initial call.
+        return dfs(0, 0, 0) % (10**9 + 7)
+
+
+# TODO: add the dynamic programming solution.
+
+
+def test():
+    executors = [
+        Memoization,
+    ]
+    __location__ = os.path.realpath(
+        os.path.join(os.getcwd(), os.path.dirname(__file__))
+    )
+    filename = os.path.splitext(os.path.basename(__file__))[0] + ".json"
+    with open(os.path.join(__location__, filename)) as json_file:
+        tests = json.load(json_file)
+        for executor in executors:
+            start = timeit.default_timer()
+            for _ in range(1):
+                for col, t in enumerate(tests):
+                    sol = executor()
+                    result = sol.profitableSchemes(t[0], t[1], t[2], t[3])
+                    exp = t[4]
+                    assert result == exp, (
+                        f"\033[93m» {result} <> {exp}\033[91m for"
+                        + f" test {col} using \033[1m{executor.__name__}"
+                    )
+            stop = timeit.default_timer()
+            used = str(round(stop - start, 5))
+            cols = "{0:20}{1:10}{2:10}"
+            res = cols.format(executor.__name__, used, "seconds")
+            print(f"\033[92m» {res}\033[0m")
+
+
+test()