Leetcode Submissions

Author: theabbie

advantage-shuffle.py

@@ -1,18 +1,23 @@
 class Solution:
     def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:
         n = len(nums1)
-        seq = sorted(range(n), key = lambda x: nums2[x])
-        res = [-1] * n
-        nums1.sort()
-        i = 0
-        unused = []
-        for j in seq:
-            while i < n and nums1[i] <= nums2[j]:
-                unused.append(nums1[i])
-                i += 1
-            if i < n:
-                res[j] = nums1[i]
-                i += 1
+        a = sorted([(nums1[i], i) for i in range(n)])
+        b = sorted([(nums2[i], i) for i in range(n)])
+        beg = 1
+        end = n
+        while beg <= end:
+            mid = (beg + end) // 2
+            pos = True
+            for i in range(mid):
+                if a[-mid + i][0] <= b[i][0]:
+                    pos = False
+                    break
+            if pos:
+                beg = mid + 1
             else:
-                res[j] = unused.pop()
+                end = mid - 1
+        l = beg - 1
+        res = [0] * n
+        for i in range(n):
+            res[b[i][1]] = a[-l+i][0]
         return res

alien-dictionary.py

@@ -0,0 +1,33 @@
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        indegree = Counter()
+        for s in words:
+            for c in s:
+                indegree[c] = 0
+        graph = defaultdict(set)
+        for i in range(len(words) - 1):
+            j = 0
+            while j < len(words[i]) and j < len(words[i + 1]) and words[i][j] == words[i + 1][j]:
+                j += 1
+            if j < len(words[i]):
+                if j == len(words[i + 1]):
+                    return ""
+                graph[words[i][j]].add(words[i + 1][j])
+        for a in graph:
+            for b in graph[a]:
+                indegree[b] += 1
+        q = deque()
+        for c in indegree:
+            if indegree[c] == 0:
+                q.appendleft(c)
+        res = []
+        while q:
+            i = q.pop()
+            res.append(i)
+            for j in graph[i]:
+                indegree[j] -= 1
+                if indegree[j] == 0:
+                    q.appendleft(j)
+        if len(res) < len(indegree):
+            return ""
+        return "".join(res)

allocate-mailboxes.py

@@ -0,0 +1,26 @@
+class Solution:
+    def minDistance(self, houses: List[int], k: int) -> int:
+        n = len(houses)
+        houses.sort()
+        @lru_cache(maxsize = None)
+        def dp(i, rem):
+            if rem < 0:
+                return float('inf')
+            if i >= n:
+                return 0
+            res = float('inf')
+            median = i
+            sv = 2 * houses[i]
+            lv = 2
+            s = 0
+            for j in range(i, n):
+                lv -= 1
+                sv -= houses[j]
+                while median < (i + j) // 2:
+                    median += 1
+                    sv += 2 * houses[median]
+                    lv += 2
+                cost = houses[median] * lv - sv
+                res = min(res, cost + dp(j + 1, rem - 1))
+            return res
+        return dp(0, k)

best-meeting-point.py

@@ -0,0 +1,19 @@
+class Solution:
+    def minTotalDistance(self, grid: List[List[int]]) -> int:
+        m = len(grid)
+        n = len(grid[0])
+        x = []
+        y = []
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    x.append(i)
+                    y.append(j)
+        x.sort()
+        y.sort()
+        res = 0
+        for el in x:
+            res += abs(el - x[len(x) // 2])
+        for el in y:
+            res += abs(el - y[len(y) // 2])
+        return res

binary-search.py

@@ -1,14 +1,12 @@
 class Solution:
-    def search(self, nums: List[int], target: int) -> int:
+    def search(self, nums, target):
         n = len(nums)
-        beg = 0
-        end = n - 1
-        while beg <= end:
-            mid = (beg + end) // 2
-            if nums[mid] == target:
-                return mid
-            if nums[mid] <= target:
-                beg = mid + 1
-            else:
-                end = mid - 1
-        return -1
+        res = -1
+        for p in range(20, -1, -1):
+            pw = 1 << p
+            if res + pw < n and nums[res + pw] < target:
+                res += pw
+        res += 1
+        if res >= n or nums[res] != target:
+            return -1
+        return res

binary-subarrays-with-sum.py

@@ -1,13 +1,15 @@
 class Solution:
     def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
+        n = len(nums)
         def count(x):
             res = 0
-            i = s = 0
-            for j in range(len(nums)):
+            i = 0
+            s = 0
+            for j in range(n):
                 s += nums[j]
                 while i <= j and s > x:
                     s -= nums[i]
                     i += 1
-                res += j - i + 1
+                res += j - i
             return res
         return count(goal) - count(goal - 1)

binary-tree-postorder-traversal.py

@@ -1,9 +1,3 @@
-# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
         if not root:

check-if-dfs-strings-are-palindromes.py

@@ -0,0 +1,34 @@
+class Solution:
+    # s[i : j + 1] is palindrome if P[i + j + 2] >= j - i + 1
+    def manachers(self, s):
+        T = '#'.join('^{}$'.format(s))
+        n = len(T)
+        P = [0] * n
+        C = R = 0
+        for i in range(1, n - 1):
+            if R > i:
+                P[i] = min(R - i, P[2 * C - i])
+            while T[i + 1 + P[i]] == T[i - 1 - P[i]]:
+                P[i] += 1
+            if i + P[i] > R:
+                C, R = i, i + P[i]
+        return P
+    
+    def findAnswer(self, parent: List[int], s: str) -> List[bool]:
+        n = len(parent)
+        graph = [[] for _ in range(n)]
+        for i in range(1, n):
+            graph[parent[i]].append(i)
+        ctr = [0] * n
+        pos = [0] * n
+        v = []
+        def dfs(i):
+            ctr[i] += 1
+            for j in sorted(graph[i]):
+                dfs(j)
+                ctr[i] += ctr[j]
+            v.append(s[i])
+            pos[i] = len(v) - 1
+        dfs(0)
+        pal = self.manachers("".join(v))
+        return [pal[2*pos[i]-ctr[i]+3]>=ctr[i] for i in range(n)]

check-if-two-chessboard-squares-have-the-same-color.py

@@ -0,0 +1,4 @@
+class Solution:
+    def checkTwoChessboards(self, coordinate1: str, coordinate2: str) -> bool:
+        s = lambda p: (ord(p[0]) - ord('a') + int(p[1]) - 1) % 2
+        return s(coordinate1) == s(coordinate2)

checking-existence-of-edge-length-limited-paths-ii.py

@@ -0,0 +1,84 @@
+class DSU:
+    def __init__(self, n):
+        self.parent = list(range(n))
+        self.size = [1] * n
+        
+    def find(self, a):
+        if a == self.parent[a]:
+            return a
+        self.parent[a] = self.find(self.parent[a])
+        return self.parent[a]
+        
+    def union(self, a, b):
+        parent_a = self.find(a)
+        parent_b = self.find(b)
+        if parent_a != parent_b:
+            if self.size[parent_a] < self.size[parent_b]:
+                parent_a, parent_b = parent_b, parent_a
+            self.parent[parent_b] = parent_a
+            self.size[parent_a] += self.size[parent_b]
+
+class DistanceLimitedPathsExist:
+    def __init__(self, n: int, edgeList: List[List[int]]):
+        graph = [[] for _ in range(n)]
+        edgeList.sort(key = lambda p: p[2])
+        dsu = DSU(n)
+        for u, v, w in edgeList:
+            if dsu.find(u) != dsu.find(v):
+                graph[u].append((v, w))
+                graph[v].append((u, w))
+                dsu.union(u, v)
+        LOG = 2
+        p = 1
+        while p <= n:
+            LOG += 1
+            p *= 2
+        depth = [0] * n
+        parent = [[i] * LOG for i in range(n)]
+        mxedge = [[float('-inf')] * LOG for i in range(n)]
+        v = [False] * n
+        for src in range(n):
+            if v[src]:
+                continue
+            stack = [(src, 0, -1)]
+            while stack:
+                i, d, p = stack.pop()
+                depth[i] = d
+                v[i] = True
+                for j, w in graph[i]:
+                    if j != p:
+                        parent[j][0] = i
+                        mxedge[j][0] = w
+                        stack.append((j, d + 1, i))
+        for jump in range(1, LOG):
+            for i in range(n):
+                mxedge[i][jump] = max(mxedge[i][jump - 1], mxedge[parent[i][jump - 1]][jump - 1])
+                parent[i][jump] = parent[parent[i][jump - 1]][jump - 1]
+        self.dsu = dsu
+        self.parent = parent
+        self.mxedge = mxedge
+        self.depth = depth
+        self.LOG = LOG
+
+    def query(self, p: int, q: int, limit: int) -> bool:
+        if self.dsu.find(p) != self.dsu.find(q):
+            return False
+        bigedge = float('-inf')
+        if self.depth[p] > self.depth[q]:
+            p, q = q, p
+        diff = self.depth[q] - self.depth[p]
+        jump = 0
+        while diff:
+            if diff & 1:
+                bigedge = max(bigedge, self.mxedge[q][jump])
+                q = self.parent[q][jump]
+            diff //= 2
+            jump += 1
+        for jump in range(self.LOG - 1, -1, -1):
+            if self.parent[p][jump] != self.parent[q][jump]:
+                bigedge = max(bigedge, self.mxedge[p][jump], self.mxedge[q][jump])
+                p = self.parent[p][jump]
+                q = self.parent[q][jump]
+        if p != q:
+            bigedge = max(bigedge, self.mxedge[p][0], self.mxedge[q][0])
+        return bigedge < limit

closest-node-to-path-in-tree.py

@@ -0,0 +1,40 @@
+class Solution:
+    def closestNode(self, n: int, edges: List[List[int]], query: List[List[int]]) -> List[int]:
+        graph = [[] for _ in range(n)]
+        for u, v in edges:
+            graph[u].append(v)
+            graph[v].append(u)
+        parent = [-1] * n
+        depth = [0] * n
+        stack = [(0, 0, -1)]
+        while stack:
+            i, d, p = stack.pop()
+            parent[i] = p
+            depth[i] = d
+            for j in graph[i]:
+                if j != p:
+                    stack.append((j, d + 1, i))
+        res = []
+        for u, v, target in query:
+            q = deque()
+            vs = set()
+            while u != -1 and v != -1 and u != v:
+                if depth[u] < depth[v]:
+                    u, v = v, u
+                q.appendleft((u, u))
+                vs.add(u)
+                u = parent[u]
+            if u == v and u != -1:
+                if u not in vs:
+                    vs.add(u)
+                    q.appendleft((u, u))
+            while q:
+                src, i = q.pop()
+                if i == target:
+                    res.append(src)
+                    break
+                for j in graph[i]:
+                    if j not in vs:
+                        vs.add(j)
+                        q.appendleft((src, j))
+        return res

construct-the-minimum-bitwise-array-i.py

@@ -0,0 +1,14 @@
+class Solution:
+    def minBitwiseArray(self, nums: List[int]) -> List[int]:
+        for i in range(len(nums)):
+            x = nums[i]
+            b = 0
+            while nums[i] & (1 << b):
+                b += 1
+            if b:
+                x &= ~(1 << (b - 1))
+            if x | (x + 1) == nums[i]:
+                nums[i] = x
+            else:
+                nums[i] = -1
+        return nums

construct-the-minimum-bitwise-array-ii.py

@@ -0,0 +1,14 @@
+class Solution:
+    def minBitwiseArray(self, nums: List[int]) -> List[int]:
+        for i in range(len(nums)):
+            x = nums[i]
+            b = 0
+            while nums[i] & (1 << b):
+                b += 1
+            if b:
+                x &= ~(1 << (b - 1))
+            if x | (x + 1) == nums[i]:
+                nums[i] = x
+            else:
+                nums[i] = -1
+        return nums

convert-date-to-binary.py

@@ -0,0 +1,5 @@
+class Solution:
+    def convertDateToBinary(self, date: str) -> str:
+        y, m, d = map(int, date.split("-"))
+        b = lambda x: "{:0b}".format(x)
+        return f"{b(y)}-{b(m)}-{b(d)}"