Daily + hard + a lottttt of question grinding from similar questions on BSTs and Islands

Author: Zanger67

README.md

@@ -0,0 +1,91 @@
+# NOTE: Literally on the edge of runtimes lol
+# Passes runtime ~50% of the time, other half it barely fails
+
+
+''' Notes
+
+if you have X _ _ _ X where X=sick and _=not sick, how many ways?
+
+We can count the gaps then multiple the number of ways each gap can do it
+
+1 person --> 1
+2 ppl --> 2
+3 ppl --> 4
+X__ XX_ XXX
+X__ X_X XXX
+__X _XX XXX
+__X X_X XXX
+
+X____ XX__ XXX_ XXXX
+X____ XX__ XX_X XXXX
+X____ XX__ X_XX XXXX
+X____ X__X X_XX XXXX
+X____ X__X XX_X XXXX
+...
+
+2*2*2*1?
+
+Cause we have left and right as a choice each time till the last where they merge
+
+Let n=size of gap
+
+# Ways = 2^(n-1)
+
+
+The leftmost group and rightmost group only have 1 way since they're
+against a wall figuratively speaking
+
+Edge cases (literally):
+X _ _ _ _   only 1 way
+_ X _       2 ways
+_ _ X       1 way
+_ X _ _     3 ways
+
+_ _ X _ _   6 ways
+Right-Left side is 4 choose 2?
+
+m+n choose m? it's a binary string method
+
+This also becomes a multimodal where we have all the groups and we 
+have to figure out how to order our choices
+
+
+FINAL FORMULA: 
+Product of:
+2^(g - 1) for each group surrounded by 2 sick individuals
+(L + R) choose (L) where L and R are the number of not sick people on the edges
+(n!)(a!b!c!...z!) where n=the total number of not sick indivudals 
+                    and a,b,c...= the size of each not sick group
+'''
+
+
+class Solution:
+    def numberOfSequence(self, n: int, sick: List[int]) -> int:
+        minn, maxx = sick[0], sick[-1]
+
+        totalToInfect = 0
+        groupSizes = [(0, 0)]
+        output = 1
+
+        if minn > 0 :
+            totalToInfect += minn
+            groupSizes.append((minn, minn))
+        if n - maxx - 1 > 0 :
+            count = n - maxx - 1
+            totalToInfect += count
+            groupSizes.append((count, count + groupSizes[-1][1]))
+
+        for i in range(1, len(sick)) :
+            numPeople = sick[i] - sick[i - 1] - 1
+            if numPeople > 0 :
+                totalToInfect += numPeople
+                groupSizes.append((numPeople, numPeople + groupSizes[-1][1]))
+                output *= 2 ** (numPeople - 1)
+
+        def multinomial(groups: List[Tuple[int, int]]):
+            modd = 10 ** 9 + 7
+            return math.prod(math.comb(x[1], x[0]) % (modd) for x in groups)
+
+        return (output * multinomial(groupSizes[1:])) % (10 ** 9 + 7)
+
+

my-submissions/h2954.py

@@ -0,0 +1,35 @@
+class Solution:
+    def numEnclaves(self, grid: List[List[int]]) -> int:
+        def removeNonEnclave(row: int, col: int) -> None :
+            if not (0 <= row < len(grid)) or not (0 <= col < len(grid[0])) :
+                return
+            if not grid[row][col] :
+                return
+            
+            grid[row][col] = 0
+
+            removeNonEnclave(row + 1, col)
+            removeNonEnclave(row - 1, col)
+            removeNonEnclave(row, col + 1)
+            removeNonEnclave(row, col - 1)
+
+        for i in range(len(grid)) :
+            if grid[i][0] :
+                removeNonEnclave(i, 0)
+            if grid[i][len(grid[0]) - 1] :
+                removeNonEnclave(i, len(grid[0]) - 1)
+
+        for i in range(1, len(grid[0]) - 1) :
+            if grid[0][i] :
+                removeNonEnclave(0, i)
+            if grid[len(grid) - 1][i] :
+                removeNonEnclave(len(grid) - 1, i)
+        
+
+        counter = 0
+        for row in range(1, len(grid)) :
+            for col in range(len(grid[0])) :
+                if grid[row][col] :
+                    counter += 1
+        
+        return counter

my-submissions/m1020.py

@@ -1,3 +1,5 @@
+// Did this like 3 days before it was a daily question so I just had to resubmit for the daily lol
+
 /**
  * Definition for a binary tree node.
  * struct TreeNode {

my-submissions/m1038.c renamed to my-submissions/m1038 Daily.c

@@ -0,0 +1,36 @@
+class Solution:
+    def closedIsland(self, grid: List[List[int]]) -> int:
+        def deleteIsland(row: int, col: int) -> None :
+            if not (0 <= row < len(grid)) or not (0 <= col < len(grid[0])) :
+                return
+            if grid[row][col] :
+                return
+            
+            grid[row][col] = 1
+
+            deleteIsland(row + 1, col)
+            deleteIsland(row - 1, col)
+            deleteIsland(row, col + 1)
+            deleteIsland(row, col - 1)
+
+        for i in range(len(grid)) :
+            if not grid[i][0] :
+                deleteIsland(i, 0)
+            if not grid[i][len(grid[0]) - 1] :
+                deleteIsland(i, len(grid[0]) - 1)
+
+        for i in range(1, len(grid[0]) - 1) :
+            if not grid[0][i] :
+                deleteIsland(0, i)
+            if not grid[len(grid) - 1][i] :
+                deleteIsland(len(grid) - 1, i)
+
+        counter = 0
+
+        for row in range(len(grid)) :
+            for col in range(len(grid[0])) :
+                if not grid[row][col] :
+                    counter += 1
+                    deleteIsland(row, col)
+        
+        return counter

my-submissions/m1254.py

@@ -0,0 +1,90 @@
+# 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 balanceBST(self, root: TreeNode) -> TreeNode:
+        # Calculate weights of each node
+        weights = defaultdict(int)
+
+        def getWeights(curr: TreeNode) -> int :
+            if not curr :
+                return 0
+            weight = getWeights(curr.left) + getWeights(curr.right) + 1
+            weights[curr] = weight
+            return weight
+
+        getWeights(root)
+
+
+        # Helper methods to get the predecessor and ancestors 
+        def removeNextGreatest(curr: TreeNode) -> TreeNode :
+            if curr.left and curr.left.left :
+                weights[curr] -= 1
+                return removeNextGreatest(curr.left)
+            weights[curr] -= 1
+            output = curr.left
+            curr.left = output.right
+            output.right = None
+            return output
+
+        def removeNextSmaller(curr: TreeNode) -> TreeNode :
+            if curr.right and curr.right.right :
+                weights[curr] -= 1
+                return removeNextSmaller(curr.right)
+            weights[curr] -= 1
+            output = curr.right
+            curr.right = output.left
+            output.left = None
+            return output
+
+
+        # Recursive method to balance each node
+        def balanceBSTHelper(curr: TreeNode) -> TreeNode :
+            if not curr :
+                return None
+
+            if -1 <= weights[curr.left] - weights[curr.right] <= 1 :
+                curr.left = balanceBSTHelper(curr.left)
+                curr.right = balanceBSTHelper(curr.right)
+                weights[curr] = 1 + weights[curr.left] + weights[curr.right]
+                return curr
+            
+            if weights[curr.right] - weights[curr.left] > 0 : # right heavier
+                weights[curr] -= weights[curr.right]
+                if not curr.right.left :
+                    newRoot = curr.right
+                    newRoot.left = curr
+                    curr.right = None
+                    weights[newRoot] += weights[newRoot.left]
+                    return balanceBSTHelper(newRoot)
+
+                newRoot = removeNextGreatest(curr.right)
+                newRoot.right = curr.right
+                newRoot.left = curr
+                newRoot.left.right = None
+                weights[newRoot] = weights[newRoot.left] + weights[newRoot.right] + 1
+
+                return balanceBSTHelper(newRoot)
+            
+            # left heavier
+            weights[curr] -= weights[curr.left]
+            if not curr.left.right :
+                newRoot = curr.left
+                newRoot.right = curr
+                curr.left = None
+                weights[newRoot] += weights[newRoot.right]
+
+                return balanceBSTHelper(newRoot)
+
+            newRoot = removeNextSmaller(curr.left)
+            newRoot.left = curr.left
+            newRoot.right = curr
+            newRoot.right.left = None
+            weights[newRoot] = weights[newRoot.left] + weights[newRoot.right] + 1
+            
+            return balanceBSTHelper(newRoot)
+
+        return balanceBSTHelper(root)

my-submissions/m1382 AVL Method.py

@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head :
+            return None
+            
+        currFast = head
+        currSlow = head
+
+        loop: bool = False
+        while currFast.next and currFast.next.next :
+            currFast = currFast.next.next
+            currSlow = currSlow.next
+
+            if currFast == currSlow :
+                loop = True
+                break
+
+        if not loop :
+            return None
+
+        loopSize = 1
+        currFast = currFast.next
+        while currFast != currSlow :
+            loopSize += 1
+            currFast = currFast.next
+        
+        currRef = head
+        while True :
+            for i in range(loopSize) :
+                currFast = currFast.next
+                if currFast == currRef :
+                    return currRef
+            currRef = currRef.next

my-submissions/m142 v1 O(1) space.py

@@ -0,0 +1,20 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head :
+            return None
+        
+        past = set()
+
+        while head :
+            if head in past :
+                return head
+            
+            past.add(head)
+            head = head.next
+        return None

my-submissions/m142 v2 O(n) runtime.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head :
+            return None
+            
+        currFast = head
+        currSlow = head
+
+        while currFast.next and currFast.next.next :
+            currFast = currFast.next.next
+            currSlow = currSlow.next
+
+            if currFast == currSlow : # Loop found
+                currSlow = head
+                while currSlow != currFast :
+                    currSlow = currSlow.next
+                    currFast = currFast.next
+
+                return currSlow
+        return None

my-submissions/m142 v3 O(1) space O(n) runtime.py

@@ -0,0 +1,35 @@
+# 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 BSTIterator:
+    def __init__(self, root: Optional[TreeNode]):
+        self.val = root.val
+        self.stk = []
+
+        while root :
+            self.stk.append(root)
+            root = root.left
+
+    def next(self) -> int:
+        curr = self.stk.pop()
+        output = curr.val
+
+        if curr.right :
+            curr = curr.right
+            while curr :
+                self.stk.append(curr)
+                curr = curr.left
+        
+        return output
+
+    def hasNext(self) -> bool:
+        return len(self.stk) > 0
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()