contest

Author: A-stick-bug

3375. Minimum Operations to Make Array Values Equal to K.py

@@ -0,0 +1,17 @@
+# simple logic
+
+def minOperations(nums: list[int], k: int) -> int:
+    if any(i < k for i in nums):
+        return -1
+
+    nums.sort()
+    res = list(set([i for i in nums if i >= k]))
+    if k in res:
+        return len(res) - 1
+    else:
+        return len(res)
+
+
+print(minOperations(nums=[5, 2, 5, 4, 5], k=2))
+print(minOperations(nums=[2, 1, 2], k=2))
+print(minOperations(nums=[9, 7, 5, 3], k=1))

3376. Minimum Time to Break Locks I.py

@@ -0,0 +1,21 @@
+# notice the low constraints
+# brute force permutations, optimize each step in `solve` with math just in case
+
+from itertools import permutations
+
+
+def findMinimumTime(strength: list[int], K: int) -> int:
+    def solve(arr):
+        inc = 1
+        time = 0
+        for i in range(len(arr)):
+            moves = (arr[i] + inc - 1) // inc  # ceil division
+            time += moves
+            inc += K
+        return time
+
+    return min(solve(p) for p in permutations(strength))
+
+
+print(findMinimumTime(strength=[3, 4, 1], K=1))
+print(findMinimumTime(strength=[2, 5, 4], K=2))

3377. Digit Operations to Make Two Integers Equal.py

@@ -0,0 +1,50 @@
+# https://leetcode.com/problems/digit-operations-to-make-two-integers-equal
+# Dijkstra's algorithm on a custom graph
+# note: apparently digits that become 0 don't count anymore...
+
+from heapq import heappush, heappop
+
+MN = 10 ** 5 + 1
+is_prime = [True] * MN
+is_prime[0] = is_prime[1] = False
+for i in range(2, MN):
+    if is_prime[i]:
+        for j in range(i * i, MN, i):
+            is_prime[j] = False
+
+
+def minOperations(n: int, m: int) -> int:
+    if is_prime[m] or is_prime[n]:
+        return -1
+
+    def get_adj(num):
+        res = []
+        for i in range(len(str(num))):
+            d = int(str(num)[-i - 1])
+            if d != 0:
+                res.append(num - 10 ** i)
+            if d != 9:
+                res.append(num + 10 ** i)
+        return res
+
+    q = [(n, n)]
+    vis = {n: n}
+    while q:
+        dist, cur = heappop(q)
+        if cur == m:
+            return dist
+
+        for adj in get_adj(cur):
+            if is_prime[adj] or (adj in vis and vis[adj] <= dist + adj):
+                continue
+            heappush(q, (dist + adj, adj))
+            vis[adj] = dist + adj
+
+    return -1
+
+
+print(minOperations(10, 12))
+print(minOperations(4, 8))
+print(minOperations(6, 2))
+print(minOperations(36, 50))
+print(minOperations(5637, 2034))

3378. Count Connected Components in LCM Graph.py

@@ -0,0 +1,55 @@
+# https://leetcode.com/problems/count-connected-components-in-lcm-graph
+# When only connectivity matters and the number of edges are too high, consider
+# using a disjoint set and only connecting necessary edges
+#
+# - first filter numbers >threshold since the LCM of 2 numbers is at least their maximum
+# - loop through all possible divisors <=threshold as the GCD and calculate LCM based on this
+# - lcm(a,b) = a*b/gcd(a,b)
+
+class DisjointSet:
+    def __init__(self, N):
+        self.parent = [i for i in range(N)]
+        self.size = [1] * N
+
+    def find(self, node):
+        if self.parent[node] != node:  # go up until we reach the root
+            # attach everything on our way to the root (path compression)
+            self.parent[node] = self.find(self.parent[node])
+        return self.parent[node]
+
+    def union(self, a, b):
+        root_a = self.find(a)
+        root_b = self.find(b)
+        if root_a == root_b:
+            return
+        if self.size[root_b] > self.size[root_a]:  # join the smaller to the larger
+            root_a, root_b = root_b, root_a  # swap
+        self.parent[root_b] = root_a
+        self.size[root_a] += self.size[root_b]
+
+
+def countComponents(nums: list[int], threshold: int) -> int:
+    original_n = len(nums)
+    nums = [i for i in nums if i <= threshold]
+    nums = set(nums)
+    n = len(nums)
+
+    ds = DisjointSet(threshold + 1)
+
+    for div in range(1, threshold + 1):  # loop divisors
+        res = []
+        for mul in range(div, threshold + 1, div):  # loop multiples of divisors
+            if mul in nums:
+                res.append(mul)
+        for i in range(1, len(res)):  # join divisors if LCM < threshold
+            if res[0] * res[i] <= threshold * div:
+                ds.union(res[0], res[i])
+            else:  # exceeded threshold, break since res is ascending
+                break
+
+    # count components and single nodes that were filtered out
+    return sum(ds.find(i) == i for i in nums) + (original_n - n)
+
+
+print(countComponents(nums=[2, 4, 8, 3, 9], threshold=5))
+print(countComponents(nums=[2, 4, 8, 3, 9, 12], threshold=10))