contest

Author: A-stick-bug

3386. Button with Longest Push Time.py

@@ -0,0 +1,13 @@
+def buttonWithLongestTime(events) -> int:
+    mx = events[0][1]
+    idx = events[0][0]
+    for i in range(1, len(events)):
+        t = events[i][1] - events[i - 1][1]
+        if t > mx or (t == mx and events[i][0] < idx):
+            idx = events[i][0]
+            mx = t
+    return idx
+
+
+print(buttonWithLongestTime(events=[[1, 2], [2, 5], [3, 9], [1, 15]]))
+print(buttonWithLongestTime(events=[[10, 5], [1, 7]]))

3387. Maximize Amount After Two Days of Conversions.py

@@ -0,0 +1,49 @@
+# https://leetcode.com/problems/maximize-amount-after-two-days-of-conversions
+# Dijkstra's
+# Refer to https://dmoj.ca/problem/dmpg15s6 for optimal solution
+# Note: it's probably faster to invert the second graph and only run it once
+
+from typing import List
+from collections import defaultdict
+from heapq import heappush, heappop
+
+
+def maxAmount(initialCurrency: str, pairs1: List[List[str]], rates1: List[float], pairs2: List[List[str]],
+              rates2: list[float]) -> float:
+    graph1 = defaultdict(list)
+    for (a, b), c in zip(pairs1, rates1):
+        graph1[a].append((b, c))
+        graph1[b].append((a, 1 / c))
+
+    graph2 = defaultdict(list)
+    for (a, b), c in zip(pairs2, rates2):
+        graph2[a].append((b, c))
+        graph2[b].append((a, 1 / c))
+
+    def search(start, val, graph):
+        costs = defaultdict(int)
+        costs[start] = val
+        pq = [(-val, start)]  # make negative for max heap
+        while pq:
+            cost, node = heappop(pq)
+            cost = -cost
+
+            for adj, multi in graph[node]:
+                new_cost = cost * multi
+                if costs[adj] < new_cost:
+                    costs[adj] = new_cost
+                    heappush(pq, (-new_cost, adj))
+        return costs
+
+    day1 = search(initialCurrency, 1, graph1)
+    best = 0
+    for k, val in day1.items():
+        best = max(best, search(k, val, graph2)[initialCurrency])
+
+    return best
+
+
+print(maxAmount(initialCurrency="EUR", pairs1=[["EUR", "USD"], ["USD", "JPY"]], rates1=[2.0, 3.0],
+                pairs2=[["JPY", "USD"], ["USD", "CHF"], ["CHF", "EUR"]], rates2=[4.0, 5.0, 6.0]))
+print(maxAmount(initialCurrency="NGN", pairs1=[["NGN", "EUR"]], rates1=[9.0], pairs2=[["NGN", "EUR"]], rates2=[6.0]))
+print(maxAmount(initialCurrency="USD", pairs1=[["USD", "EUR"]], rates1=[1.0], pairs2=[["EUR", "JPY"]], rates2=[10.0]))

3388. Count Beautiful Splits in an Array.py

@@ -0,0 +1,62 @@
+# https://leetcode.com/problems/count-beautiful-splits-in-an-array
+# Any string matching algorithm works
+# I used hashing because it's the simplest
+# Note: apparently the intended solution is dynamic programming?
+
+from itertools import accumulate
+
+
+def beautifulSplits(nums: list[int]) -> int:
+    n = len(nums)
+    if n < 3:  # edge case: no valid splits
+        return 0
+
+    MOD = 177635683940025046467781066894531
+    p = 53  # p should be greater than max(nums)
+
+    power = [0] * n  # precompute powers of `p`, with MOD
+    power[0] = 1
+    for i in range(1, n):
+        power[i] = (power[i - 1] * p) % MOD
+
+    hash1 = [0] * n  # precompute hashes of each character in `str1`
+    for i in range(n):
+        hash1[i] = (nums[i] * power[n - i - 1]) % MOD
+    psa1 = [0] + list(accumulate(hash1))  # psa for range hash query
+
+    total = 0
+    for end1 in range(n):
+        for end2 in range(end1 + 1, n - 1):
+            # formula for substring hash: (psa1[r1 + 1] - psa1[l1]) * power[l1] % MOD
+
+            # check A is prefix of B
+            l1 = 0
+            r1 = end1
+            l2 = end1 + 1
+            r2 = end2
+            if (r1 - l1) <= (r2 - l2):  # check prefix
+                r2 = l2 + r1
+                hash1 = (psa1[r1 + 1] - psa1[l1]) * power[l1] % MOD  # shift up
+                hash2 = (psa1[r2 + 1] - psa1[l2]) * power[l2] % MOD
+                if hash1 == hash2:
+                    total += 1
+                    continue
+
+            # check B is prefix of C
+            l1 = end1 + 1
+            r1 = end2
+            l2 = end2 + 1
+            r2 = n - 1
+            if (r1 - l1) <= (r2 - l2):  # check prefix
+                r2 = l2 + (r1 - l1 + 1) - 1
+                hash1 = (psa1[r1 + 1] - psa1[l1]) * power[l1] % MOD  # shift up
+                hash2 = (psa1[r2 + 1] - psa1[l2]) * power[l2] % MOD
+                if hash1 == hash2:
+                    total += 1
+
+    return total
+
+
+print(beautifulSplits([2, 3, 2, 2, 1]))
+print(beautifulSplits(nums=[1, 1, 2, 1]))
+print(beautifulSplits(nums=[1, 2, 3, 4]))