dp

Author: lexiconium

leetcode/last_stone_weight_ii.py

@@ -0,0 +1,45 @@
+# https://leetcode.com/problems/last-stone-weight-ii/
+
+
+class Solution:
+    # brute force 1
+    def lastStoneWeightII(self, stones: list[int]) -> int:
+        def dfs(weights: tuple[int]) -> int:
+            if len(weights) == 1:
+                return weights[0]
+
+            return min(
+                dfs(
+                    weights[:i]
+                    + weights[i + 1 : j]
+                    + weights[j + 1 :]
+                    + (abs(m - weights[j]),)
+                )
+                for i, m in enumerate(weights)
+                for j in range(i + 1, len(weights))
+            )
+
+        return dfs(tuple(stones))
+
+    # brute force 2
+    def lastStoneWeightII(self, stones: list[int]) -> int:
+        n = len(stones)
+        total_weight = sum(stones)
+
+        def get_weight(group: int) -> int:
+            return sum(stones[i] for i in range(n) if (1 << i) & group)
+
+        return min(
+            abs(total_weight - 2 * get_weight(group))
+            for group in range((1 << n) // 2 + 1)
+        )
+
+    # dp
+    def lastStoneWeightII(self, stones: list[int]) -> int:
+        total_weight = sum(stones)
+        dp = {0}
+
+        for stone in stones:
+            dp |= {stone + weight for weight in dp}
+
+        return min(abs(total_weight - 2 * weight) for weight in dp)

leetcode/longest_arithmetic_subsequence_of_given_difference.py

@@ -0,0 +1,28 @@
+# https://leetcode.com/problems/longest-arithmetic-subsequence-of-given-difference/
+
+from collections import defaultdict
+
+
+class Solution:
+    # brute force
+    def longestSubsequence(self, arr: list[int], difference: int) -> int:
+        dp = [1] * (n := len(arr))
+
+        for i in reversed(range(n - 1)):
+            dp[i] = max(
+                [1 + dp[j] for j in range(i + 1, n) if arr[j] - arr[i] == difference],
+                default=1,
+            )
+
+        return max(dp)
+
+    # dp
+    def longestSubsequence(self, arr: list[int], difference: int) -> int:
+        dp = defaultdict(int)
+        longest = 1
+
+        for n in reversed(arr):
+            dp[n] = dp[n + difference] + 1
+            longest = max(dp[n], longest)
+
+        return longest

leetcode/longest_increasing_subsequence.py

@@ -0,0 +1,47 @@
+# https://leetcode.com/problems/longest-increasing-subsequence/
+
+
+import bisect
+
+
+class Solution:
+    # brute force
+    def lengthOfLIS(self, nums: list[int]) -> int:
+        def dfs(begin: int, n: int) -> int:
+            if begin == len(nums):
+                return 0
+
+            cnt = 0
+
+            for i in range(begin, len(nums)):
+                if nums[i] <= n:
+                    continue
+
+                cnt = max(1 + dfs(i + 1, nums[i]), cnt)
+
+            return cnt
+
+        return dfs(0, float("-inf"))
+
+    # dp
+    def lengthOfLIS(self, nums: list[int]) -> int:
+        dp = [1] * (n := len(nums))
+
+        for i in reversed(range(n - 1)):
+            for j in range(i + 1, n):
+                if nums[j] > nums[i]:
+                    dp[i] = max(1 + dp[j], dp[i])
+
+        return max(dp)
+
+    # binary search
+    def lengthOfLIS(self, nums: list[int]) -> int:
+        tails = []
+
+        for n in nums:
+            if (index := bisect.bisect_left(tails, n)) == len(tails):
+                tails.append(n)
+            else:
+                tails[index] = n
+
+        return len(tails)

leetcode/solving_questions_with_brainpower.py

@@ -0,0 +1,26 @@
+# https://leetcode.com/problems/solving-questions-with-brainpower/
+
+
+class Solution:
+    # brute force
+    def mostPoints(self, questions: list[list[int]]) -> int:
+        def dfs(i: int = 0) -> int:
+            if i >= len(questions):
+                return 0
+
+            return max(questions[i][0] + dfs(i + 1 + questions[i][1]), dfs(i + 1))
+
+        return dfs()
+
+    # tabulation
+    def mostPoints(self, questions: list[list[int]]) -> int:
+        dp = [0] * (n := len(questions))
+
+        for i in reversed(range(n)):
+            p, bp = questions[i]
+            dp[i] = max(
+                p + (dp[i + 1 + bp] if i + 1 + bp < n else 0),
+                dp[i + 1] if i + 1 < n else 0,
+            )
+
+        return dp[0]