Leetcode submissions

Author: theabbie

132-pattern.py

@@ -0,0 +1,72 @@
+class Solution:
+    def find132pattern(self, nums: List[int]) -> bool:
+        n = len(nums)
+        if n < 3:
+            return False
+        stack = []
+        k = -1
+        for i in range(n - 1, -1, -1):
+            if k > -1 and nums[k] > nums[i]:
+                return True
+            while len(stack) > 0 and nums[i] > nums[stack[-1]]:
+                k = stack.pop()
+            stack.append(i)
+        return False
+
+# class Solution:
+#     def makeSeg(self, arr, i, j):
+#         seg = self.seg
+#         if (i, j) in seg:
+#             return seg[(i, j)]
+#         if i == j:
+#             seg[(i, j)] = arr[i]
+#             return arr[i]
+#         mid = (i + j) // 2
+#         curr = max(self.makeSeg(arr, i, mid), self.makeSeg(arr, mid + 1, j))
+#         seg[(i, j)] = curr
+#         return curr
+    
+#     def getMax(self, arr, i, j, ni, nj):
+#         seg = self.seg
+#         if ni >= i and nj <= j:
+#             return seg[(ni, nj)]
+#         if (ni < i and nj < i) or (ni > j and nj > j):
+#             return float('-inf')
+#         mid = (ni + nj) // 2
+#         return max(self.getMax(arr, i, j, ni, mid), self.getMax(arr, i, j, mid + 1, nj))
+    
+#     def find132pattern(self, nums: List[int]) -> bool:
+#         n = len(nums)
+#         self.seg = {}
+#         self.makeSeg(nums, 0, n - 1)
+#         for i in range(n):
+#             for j in range(i + 2, n):
+#                 if nums[j] > nums[i] and self.getMax(nums, i, j, 0, n - 1) > nums[j]:
+#                     return True
+#         return False
+
+# class Solution:
+#     def find132pattern(self, nums: List[int]) -> bool:
+#         n = len(nums)
+#         next_lowest = [n for i in range(n)]
+#         stack = []
+#         for i in range(n):
+#             while len(stack) > 0 and nums[i] < nums[stack[-1]]:
+#                 curr = stack.pop()
+#                 next_lowest[curr] = i
+#                 for j in range(curr):
+#                     if nums[j] < nums[i]:
+#                         return True
+#             stack.append(i)
+#         return False
+
+# class Solution:
+#     def find132pattern(self, nums: List[int]) -> bool:
+#         currMin = float('inf')
+#         currMax = float('-inf')
+#         for num in nums:
+#             currMin = min(currMin, num)
+#             currMax = max(currMax, num)
+#             if num > currMin and num < currMax:
+#                 return True
+#         return False

2-keys-keyboard.py

@@ -0,0 +1,11 @@
+class Solution:
+    def minSteps(self, n: int, k = 1, clipboard = 0) -> int:
+        if k == n:
+            return 0
+        if k > n:
+            return float('inf')
+        a = float('inf')
+        if clipboard > 0:
+            a = 1 + self.minSteps(n, k + clipboard, clipboard)
+        b = 2 + self.minSteps(n, 2 * k, k)
+        return min(a, b)

3sum-closest.py

@@ -0,0 +1,23 @@
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+        n = len(nums)
+        if n < 3:
+            return []
+        nums = [3 * num - target for num in nums]
+        nums.sort()
+        closest = float('inf')
+        for i in range(n - 2):
+            a = nums[i]
+            start = i + 1
+            end = n - 1
+            while start < end:
+                b = nums[start]
+                c = nums[end]
+                total = a + b + c
+                if abs(total) < abs(closest):
+                    closest = total
+                if total > 0:
+                    end -= 1
+                else:
+                    start += 1
+        return target + closest // 3

3sum-with-multiplicity.py

@@ -0,0 +1,9 @@
+class Solution:
+    def threeSumMulti(self, arr: List[int], target: int) -> int:
+        d = [0] * 300
+        res = 0
+        for i, el in enumerate(arr):
+            res += d[target - el] if target - el >= 0 else 0
+            for j in range(i):
+                d[el + arr[j]] += 1
+        return res % (10 ** 9 + 7)

add-two-numbers-ii.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def add(self, l1, l2, carry = 0):
+        if l1 or l2:
+            l1val = l1.val if l1 else 0
+            l2val = l2.val if l2 else 0
+            currval = l1val + l2val + carry
+            curr = ListNode(val = currval % 10)
+            curr.next = self.add(l1.next if l1 else None, l2.next if l2 else None, carry = currval // 10)
+            return curr
+        else:
+            if carry > 0:
+                return ListNode(val = carry)
+            return None
+        
+    def reverse(self, head):
+        curr = head
+        prev = None
+        while curr:
+            nxt = curr.next
+            curr.next = prev
+            prev = curr
+            curr = nxt
+        return prev
+    
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        l1 = self.reverse(l1)
+        l2 = self.reverse(l2)
+        return self.reverse(self.add(l1, l2, carry = 0))

add-two-numbers.py

@@ -0,0 +1,18 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode], carry=0) -> Optional[ListNode]:
+        if l1 or l2:
+            l1val = l1.val if l1 else 0
+            l2val = l2.val if l2 else 0
+            currval = l1val + l2val + carry
+            curr = ListNode(val = currval % 10)
+            curr.next = self.addTwoNumbers(l1.next if l1 else None, l2.next if l2 else None, carry = currval // 10)
+            return curr
+        else:
+            if carry > 0:
+                return ListNode(val = carry)
+            return None

alert-using-same-key-card-three-or-more-times-in-a-one-hour-period.py

@@ -0,0 +1,27 @@
+import bisect
+
+class Solution:
+    def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
+        n = len(keyName)
+        checkins = {}
+        for i in range(n):
+            name = keyName[i]
+            time = keyTime[i]
+            time = tuple(int(k) for k in time.split(":"))
+            if name in checkins:
+                bisect.insort(checkins[name], time)
+            else:
+                checkins[name] = [time]
+        op = []
+        for name in sorted(checkins.keys()):
+            m = len(checkins[name])
+            alert = False
+            for i in range(m):
+                curr = checkins[name][i]
+                j = bisect.bisect_right(checkins[name], (curr[0] + 1, curr[1]))
+                if j - i >= 3:
+                    alert = True
+                    break
+            if alert:
+                op.append(name)
+        return op

all-ancestors-of-a-node-in-a-directed-acyclic-graph.py

@@ -0,0 +1,17 @@
+class Solution:
+    def getAncestors(self, n: int, edges: List[List[int]]) -> List[List[int]]:
+        graph = {}
+        for a, b in edges:
+            graph[b] = graph.get(b, []) + [a]
+        op = [[] for i in range(n)]
+        for a in graph:
+            visited = set()
+            paths = [a]
+            while len(paths) > 0:
+                curr = paths.pop()
+                for b in graph.get(curr, []):
+                    if b not in visited:
+                        visited.add(b)
+                        paths.append(b)
+            op[a] = sorted(visited)
+        return op

all-possible-full-binary-trees.py

@@ -0,0 +1,21 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def allPossibleFBT(self, n: int) -> List[Optional[TreeNode]]:
+        trees = []
+        if n == 1:
+            return [TreeNode()]
+        for i in range(1, n, 2):
+            lefts = self.allPossibleFBT(i)
+            rights = self.allPossibleFBT(n - i - 1)
+            for left in lefts:
+                for right in rights:
+                    root = TreeNode()
+                    root.left = left
+                    root.right = right
+                    trees.append(root)
+        return trees

append-k-integers-with-minimal-sum.py

@@ -0,0 +1,21 @@
+class Solution:
+    def minimalKSum(self, nums: List[int], k: int) -> int:
+        nums.sort()
+        nums.insert(0, 0)
+        nums.append(float('inf'))
+        print(nums)
+        total = 0
+        n = len(nums)
+        for i in range(n - 1):
+            if k >= nums[i + 1] - nums[i] - 1:
+                if nums[i + 1] - nums[i] > 1:
+                    total += nums[i + 1] * (nums[i + 1] - 1) // 2
+                    total -= nums[i] * (nums[i] + 1) // 2
+                    k -= nums[i + 1] - nums[i] - 1
+            else:
+                end = nums[i] + k
+                beg = nums[i]
+                total += end * (end + 1) // 2
+                total -= beg * (beg + 1) // 2
+                break
+        return total

arithmetic-slices.py

@@ -0,0 +1,26 @@
+class Solution:
+    def numSlicesEndingHere(self, nums, i, n):
+        if i in self.cache:
+            return self.cache[i]
+        if i < 2:
+            return 0
+        if i == 2:
+            if nums[2] - nums[1] == nums[1] - nums[0]:
+                self.cache[i] = 1
+                return 1
+            self.cache[i] = 0
+            return 0
+        if nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]:
+            val = 1 + self.numSlicesEndingHere(nums, i - 1, n)
+            self.cache[i] = val
+            return val
+        self.cache[i] = 0
+        return 0
+    
+    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
+        n = len(nums)
+        self.cache = {}
+        ctr = 0
+        for i in range(n):
+            ctr += self.numSlicesEndingHere(nums, i, n)
+        return ctr

asteroid-collision.py

@@ -0,0 +1,23 @@
+class Solution:
+    def asteroidCollision(self, asteroids: List[int]) -> List[int]:
+        while True:
+            n = len(asteroids)
+            stack = []
+            op = []
+            for i in range(n):
+                if asteroids[i] > 0:
+                    stack.append(i)
+                else:
+                    while len(stack) > 0 and abs(asteroids[stack[-1]]) < abs(asteroids[i]):
+                        stack.pop()
+                    if len(stack) > 0:
+                        if abs(asteroids[stack[-1]]) <= abs(asteroids[i]):
+                            stack.pop()
+                    else:
+                        op.append(i)
+            op = sorted(stack + op)
+            op =  [asteroids[i] for i in op]
+            if asteroids == op:
+                return op
+            else:
+                asteroids = op

baseball-game.py

@@ -0,0 +1,13 @@
+class Solution:
+    def calPoints(self, ops: List[str]) -> int:
+        score = [0]
+        for op in ops:
+            if op == "+":
+                score.append(score[-1] + score[-2])
+            elif op == "C":
+                score.pop()
+            elif op == "D":
+                score.append(score[-1] << 1)
+            else:
+                score.append(int(op))
+        return sum(score)

beautiful-array.py

@@ -0,0 +1,10 @@
+class Solution:
+    def beautifulArray(self, N):
+        memo = {1: [1]}
+        def f(N):
+            if N not in memo:
+                odds = f((N+1)//2)
+                evens = f(N//2)
+                memo[N] = [2*x-1 for x in odds] + [2*x for x in evens]
+            return memo[N]
+        return f(N)

binary-search.py

@@ -0,0 +1,16 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        n = len(nums)
+        beg = 0
+        end = n - 1
+        while beg <= end:
+            mid = (beg + end) // 2
+            if nums[mid] == target:
+                return mid
+            elif beg == end:
+                break
+            elif nums[mid] > target:
+                end = mid
+            else:
+                beg = mid + 1
+        return -1

binary-tree-maximum-path-sum.py

@@ -0,0 +1,19 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def pathsum(self, root):
+        if root:
+            l = self.pathsum(root.left)
+            r = self.pathsum(root.right)
+            self.msum = max(self.msum, root.val, l + root.val, root.val + r, l + root.val + r)
+            return max(root.val, root.val + l, root.val + r)
+        return float('-inf')
+    
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        self.msum = float('-inf')
+        self.pathsum(root)
+        return self.msum