[main] Added dp problems

cthacker-udel · cthacker-udel · commit b5e48b000ec5 · 2022-11-04T12:19:30.000-04:00
diff --git a/pythonProblems/dp/4sum.py b/pythonProblems/dp/4sum.py
@@ -0,0 +1,48 @@
+from typing import List
+
+
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        # b - c - d = a
+        # a - c - d = b
+        # a - b - d = c
+        # a - b - c = d
+        nums_clone = []
+        pairs = []
+        i, j, k, l = 0, 0, 0, 0
+        while i < len(nums):
+            a = abs(nums[i] - target)
+            nums_clone = nums[0:i] + nums[i + 1:]
+            while j < len(nums_clone):
+                b = a - nums_clone[j]
+                j += 1
+                if b in nums_clone:
+                    b_ind = nums_clone.index(b)
+                    nums_clone = nums_clone[0:b_ind] + nums_clone[b_ind + 1:]
+                    while k < len(nums_clone):
+                        c = nums_clone[k] - b
+                        k += 1
+                        if c in nums_clone:
+                            c_ind = nums_clone.index(c)
+                            nums_clone = nums_clone[0: c_ind] + nums_clone[c_ind:]
+                            while l < len(nums_clone):
+                                d = nums_clone[l] - c
+                                l += 1
+                                if d in nums_clone:
+                                    ## found pair
+                                    if sorted([a, b, c, d]) not in pairs and a + b + c + d == target:
+                                        print(
+                                            a, b, c, d, nums_clone)
+                                        pairs.append(sorted([a, b, c, d]))
+                                        j, k, l = 0, 0, 0
+                                        break
+                            l = 0
+                    k = 0
+            j = 0
+            i += 1
+        return pairs
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.fourSum([2,2,2,2,2], 8))
diff --git a/pythonProblems/dp/climbingstaircase.py b/pythonProblems/dp/climbingstaircase.py
@@ -0,0 +1,11 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0, 1]
+        for i in range(1, n + 1):
+            dp.append(dp[i - 1] + dp[i - 2])
+        print(dp)
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.climbStairs(5))
diff --git a/pythonProblems/dp/cutrod.py b/pythonProblems/dp/cutrod.py
@@ -0,0 +1,30 @@
+import random
+
+
+def memo_cut_rod_aux(p, n, r):
+    q = -1
+    if r[n] >= 0:
+        return r[n]
+    if n == 0:
+        q = 0
+    else:
+        q = -1
+        for i in range(1, n + 1):
+            q = max(q, p[i] + memo_cut_rod_aux(p, n - i, r))
+    r[n] = q
+    return q
+
+
+def memo_cut_rod(p, n):
+    r = [0] * (n + 1)
+    for i in range(n + 1):
+        r[i] = -1
+    return memo_cut_rod_aux(p, n, r)
+
+
+if __name__ == '__main__':
+    range_ = 20
+    prices = {}
+    for i in range(1, range_ + 1):
+        prices[i] = random.randint(10, 200)
+    print(memo_cut_rod(prices, range_))
diff --git a/pythonProblems/dp/divide.py b/pythonProblems/dp/divide.py
@@ -0,0 +1,27 @@
+import math
+
+
+class Solution:
+    neg_lim = -2147483648
+    pos_lim = 2147483648 - 1
+
+    def divide(self, dividend: int, divisor: int) -> int:
+        if divisor == 1:
+            return dividend
+        elif divisor == -1:
+            if dividend < 0:
+                ## flips to positive, account for case
+                return abs(dividend) if abs(dividend) < Solution.pos_lim else Solution.pos_lim
+            else:
+                return -1 * dividend
+        dividend = dividend if dividend >= Solution.neg_lim and dividend <= Solution.pos_lim else Solution.neg_lim if dividend < 0 else Solution.pos_lim
+        is_negative = (dividend < 0 and divisor > 0) or (
+            divisor < 0 and dividend > 0)
+        res = math.exp(math.log(abs(dividend)) -
+                       math.log(abs(divisor))) + 0.0000000001
+        return int(res) if not is_negative else -1 * int(res)
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.divide(-231, 3))
diff --git a/pythonProblems/dp/dominantIndex.py b/pythonProblems/dp/dominantIndex.py
@@ -0,0 +1,7 @@
+from typing import List
+
+
+class Solution:
+    def dominantIndex(self, nums: List[int]) -> int:
+        nums.sort()
+        return nums[-1] >= (nums[-2] * 2)
diff --git a/pythonProblems/dp/fib.py b/pythonProblems/dp/fib.py
@@ -0,0 +1,17 @@
+class Solution:
+    memo = {}
+
+    def fib(self, n: int) -> int:
+        if n in Solution.memo:
+            return Solution.memo[n]
+        elif n == 1 or n == 0:
+            return n
+        else:
+            result = Solution.fib(self, n - 2) + Solution.fib(self, n - 1)
+            Solution.memo[n] = result
+            return result
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    sol.fib(2)
diff --git a/pythonProblems/dp/generateParenthesis.py b/pythonProblems/dp/generateParenthesis.py
@@ -0,0 +1,26 @@
+
+from copy import deepcopy
+from typing import List
+
+
+class Solution:
+    def generateParenthesis(self, n: int, generated_parens: List[str] = None, open_count=0, close_count=0, curr_pair: str = '') -> List[str]:
+        if generated_parens == None:
+            generated_parens = []
+        if open_count == close_count and open_count + close_count == (n * 2):
+            generated_parens.append(curr_pair)
+            return generated_parens
+        else:
+            if close_count > open_count or open_count + close_count > (n * 2):
+                return ['']
+            self.generateParenthesis(n, generated_parens, open_count, close_count + 1,
+                                     curr_pair + ')')
+            self.generateParenthesis(n, generated_parens, open_count + 1, close_count,
+                                     curr_pair + '(')
+        return generated_parens
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.generateParenthesis(2))
+    print(sol.generateParenthesis(1))
diff --git a/pythonProblems/dp/longestsub.py b/pythonProblems/dp/longestsub.py
@@ -0,0 +1,6 @@
+def longest_sub(sub1: str, sub2: str) -> str:
+    print('sub1 = {} and sub2 = {}'.format(sub1, sub2))
+
+
+if __name__ == '__main__':
+    longest_sub('ABCBDAB', 'BDCABA')
diff --git a/pythonProblems/dp/longestvalid.py b/pythonProblems/dp/longestvalid.py
@@ -0,0 +1,21 @@
+class Solution:
+    def longestValidParentheses(self, s: str) -> int:
+        dp = [0] * len(s)
+        for i in range(len(s)):
+            if s[i] == ')':
+                if i - 1 < 0:
+                    continue
+                elif s[i - 1] == '(':
+                    dp[i] = dp[i - 2] + 2
+                elif i - dp[i - 1] - 1 < 0:
+                    continue
+                elif s[i - dp[i - 1] - 1] == '(':
+                    ## matching over the current pair
+                    dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2]
+        return max(dp)
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.longestValidParentheses("(()))())("
+                                      ))
diff --git a/pythonProblems/dp/minOperations.py b/pythonProblems/dp/minOperations.py
@@ -0,0 +1,23 @@
+
+class Solution:
+
+    def __init__(self):
+        self.min_op_hash = {}
+
+    def minOperation(self, n, targ=1, steps=1):
+        if targ in self.min_op_hash:
+            return self.min_op_hash[targ]
+        elif targ > n:
+            self.min_op_hash[targ] = steps + 1
+            return steps + 1
+        elif targ == n:
+            self.min_op_hash[targ] = steps
+            return steps
+        else:
+            print(self.min_op_hash)
+            return min(self.minOperation(n, targ * 2, steps + 1), self.minOperation(n, targ + 1, steps + 1))
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.minOperation(142421))
diff --git a/pythonProblems/dp/mincostClimbingStairs.py b/pythonProblems/dp/mincostClimbingStairs.py
@@ -0,0 +1,32 @@
+from typing import List
+
+
+class Solution:
+    dp = []
+
+    def minCostClimbingStairs(self, cost: List[int], ind=None) -> int:
+        Solution.dp = [-1] * (len(cost) + 1)
+        Solution.minCost(self, cost, len(cost))
+        print(Solution.dp)
+        return Solution.dp[-1]
+
+    def minCost(self, cost: List[int], ind) -> int:
+        if Solution.dp[ind] != -1:
+            return Solution.dp[ind]
+        elif ind <= 1:
+            Solution.dp[ind] = cost[ind]
+            return cost[ind]
+        else:
+            adding_cost = 0
+            if ind != len(cost):
+                adding_cost = cost[ind]
+            result = adding_cost + min(Solution.minCost(
+                self, cost, ind - 1), Solution.minCost(self, cost, ind - 2))
+            Solution.dp[ind] = result
+            return Solution.dp[ind]
+
+
+if __name__ == '__main__':
+    arr = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
+    sol = Solution()
+    print(sol.minCostClimbingStairs(arr))
diff --git a/pythonProblems/dp/numtrees.py b/pythonProblems/dp/numtrees.py
diff --git a/pythonProblems/dp/rightSideView.py b/pythonProblems/dp/rightSideView.py
@@ -0,0 +1,29 @@
+from typing import List, Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    levels = []
+
+    def rightSideView(self, root: Optional[TreeNode], level=0) -> List[int]:
+        if root == None:
+            return []
+        else:
+            if level in Solution.levels:
+                return []
+            result = [root.val] + Solution.rightSideView(
+                self, root.right, level + 1) + Solution.rightSideView(self, root.left, level + 1)
+            Solution.levels.append(len(Solution.levels))
+            return result
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    root = TreeNode(1, None, TreeNode(3))
+    print(sol.rightSideView(root))
diff --git a/pythonProblems/dp/robber.py b/pythonProblems/dp/robber.py
@@ -0,0 +1,28 @@
+from typing import List
+
+
+class Solution:
+
+    dp = []
+
+    def rob(self, nums: List[int]) -> int:
+        Solution.dp = [-1] * (len(nums) + 1)
+        result = Solution.initiate_rob(self, nums, len(nums) - 1)
+        return result
+
+    def initiate_rob(self, nums: List[int], index: int) -> int:
+        if index < 0:
+            return 0
+        elif Solution.dp[index] >= 0:
+            return Solution.dp[index]
+        else:
+            result = max(Solution.initiate_rob(self, nums, index - 2) +
+                         nums[index], Solution.initiate_rob(self, nums, index - 1))
+            Solution.dp[index] = result
+            return result
+
+
+if __name__ == '__main__':
+    arr = [6, 6, 4, 8, 4, 3, 3, 10]
+    sol = Solution()
+    print(sol.rob(arr))
diff --git a/pythonProblems/dp/tribonnaci.py b/pythonProblems/dp/tribonnaci.py
@@ -0,0 +1,16 @@
+class Solution:
+    memo = {}
+    base = {0: 0, 1: 1, 2: 1}
+
+    def tribonacci(self, n: int) -> int:
+        if n < 3:
+            return Solution.base[n]
+        elif n in Solution.memo:
+            return Solution.memo[n]
+        else:
+            return Solution.tribonacci(self, n - 1) + Solution.tribonacci(self, n - 2) + Solution.tribonacci(self, n - 3)
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.tribonacci(4))
diff --git a/pythonProblems/dp/xfast.py b/pythonProblems/dp/xfast.py
