abc352

Author: reo11

atcoder/abc/abc301-400/abc352/a.py

@@ -0,0 +1,11 @@
+n, x, y, z = map(int, input().split())
+
+from_x = min(x, y)
+until_x = max(x, y)
+
+for i in range(from_x, until_x+1):
+    if i == z:
+        print("Yes")
+        exit()
+
+print("No")

atcoder/abc/abc301-400/abc352/b.py

@@ -0,0 +1,20 @@
+from collections import deque
+s = list(input())
+t = list(input())
+
+s = deque(s)
+t = deque(t)
+
+n = len(t)
+cnt = 1
+ans = []
+while len(s) > 0 and len(t) > 0:
+    if s[0] == t[0]:
+        s.popleft()
+        t.popleft()
+        ans.append(cnt)
+    else:
+        t.popleft()
+    cnt += 1
+ans = sorted(ans)
+print(*ans, sep=" ")

atcoder/abc/abc301-400/abc352/c.py

@@ -0,0 +1,14 @@
+n = int(input())
+ab = []
+
+for _ in range(n):
+    a, b = map(int, input().split())
+    ab.append((b - a, a, b))
+
+# (頭の大きさ, 肩までの高さ, 頭までの高さ)
+
+ab.sort(reverse=True)
+
+ans = sum([a for _, a, _ in ab[1:]])
+ans += ab[0][2]
+print(ans)

atcoder/abc/abc301-400/abc352/d.py

@@ -0,0 +1,60 @@
+import heapq
+from collections import defaultdict
+
+class MultiSet:
+    def __init__(self) -> None:
+        self.cnt_dict = defaultdict(int)
+        self.rank_min = []
+        self.rank_max = []
+        self.size = 0
+        self.sum = 0
+
+    def add(self, num: int) -> None:
+        cnt = self.cnt_dict.get(num, 0)
+        self.cnt_dict[num] = cnt + 1
+
+        heapq.heappush(self.rank_min, num)
+        heapq.heappush(self.rank_max, -num)
+        self.size += 1
+        self.sum += num
+
+    def erase(self, num: int, d: int = 1) -> None:
+        cnt = self.cnt_dict.get(num, 0)
+        self.cnt_dict[num] = max(cnt - d, 0)
+        self.size -= d
+        self.sum -= num * d
+
+    def get_max(self) -> int:
+        while self.cnt_dict[-self.rank_max[0]] == 0:
+            -heapq.heappop(self.rank_max)
+        return -self.rank_max[0]
+
+    def get_min(self) -> int:
+        while self.cnt_dict[self.rank_min[0]] == 0:
+            heapq.heappop(self.rank_min)
+        return self.rank_min[0]
+
+    def include(self, num: int) -> bool:
+        return self.cnt_dict.get(num, 0) > 0
+
+n, k = map(int, input().split())
+p = list(map(int, input().split()))
+
+positions = dict()
+
+for i, pi in enumerate(p):
+    positions[pi] = i
+
+multiset = MultiSet()
+
+ans = float("inf")
+for i in range(1, k + 1):
+    multiset.add(positions[i])
+
+ans = multiset.get_max() - multiset.get_min()
+
+for i in range(k + 1, n + 1):
+    multiset.add(positions[i])
+    multiset.erase(positions[i - k])
+    ans = min(ans, multiset.get_max() - multiset.get_min())
+print(ans)

atcoder/abc/abc301-400/abc352/e.py

@@ -0,0 +1,72 @@
+# コストが小さい方から全て採用して全域木を作る
+n, m = map(int, input().split())
+candidates = []
+for _ in range(m):
+    k, weight = map(int, input().split())
+    a = list(map(int, input().split()))
+    a = [x - 1 for x in a]
+    candidates.append((weight, a))
+candidates.sort()
+
+class UnionFind():
+    def __init__(self, n):
+        self.n = n + 1
+        self.parents = [-1] * (n + 1)
+
+    def find(self, x):
+        if self.parents[x] < 0:
+            return x
+        else:
+            self.parents[x] = self.find(self.parents[x])
+            return self.parents[x]
+
+    def union(self, x, y):
+        x = self.find(x)
+        y = self.find(y)
+
+        if x == y:
+            return
+
+        if self.parents[x] > self.parents[y]:
+            x, y = y, x
+
+        self.parents[x] += self.parents[y]
+        self.parents[y] = x
+
+    def size(self, x):
+        return -self.parents[self.find(x)]
+
+    def same(self, x, y):
+        return self.find(x) == self.find(y)
+
+    def members(self, x):
+        root = self.find(x)
+        return [i for i in range(self.n) if self.find(i) == root]
+
+    def roots(self):
+        return [i for i, x in enumerate(self.parents) if x < 0]
+
+    def group_count(self):
+        return len(self.roots())
+
+    def all_group_members(self):
+        return {r: self.members(r) for r in self.roots()}
+
+    def __str__(self):
+        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
+
+tree = UnionFind(n)
+
+cost_sum = 0
+for weight, a in candidates:
+    for i in range(1, len(a)):
+        if not tree.same(a[i - 1], a[i]):
+            cost_sum += weight
+            tree.union(a[i - 1], a[i])
+        else:
+            continue
+
+if tree.size(0) == n:
+    print(cost_sum)
+else:
+    print(-1)

atcoder/abc/abc301-400/abc352/f.py

@@ -0,0 +1,95 @@
+from collections import defaultdict
+n, m = map(int, input().split())
+abc = []
+
+class UnionFind():
+    def __init__(self, n):
+        self.n = n + 1
+        self.parents = [-1] * (n + 1)
+
+    def find(self, x):
+        if self.parents[x] < 0:
+            return x
+        else:
+            self.parents[x] = self.find(self.parents[x])
+            return self.parents[x]
+
+    def union(self, x, y):
+        x = self.find(x)
+        y = self.find(y)
+
+        if x == y:
+            return
+
+        if self.parents[x] > self.parents[y]:
+            x, y = y, x
+
+        self.parents[x] += self.parents[y]
+        self.parents[y] = x
+
+    def size(self, x):
+        return -self.parents[self.find(x)]
+
+    def same(self, x, y):
+        return self.find(x) == self.find(y)
+
+    def members(self, x):
+        root = self.find(x)
+        return [i for i in range(self.n) if self.find(i) == root]
+
+    def roots(self):
+        return [i for i, x in enumerate(self.parents) if x < 0]
+
+    def group_count(self):
+        return len(self.roots())
+
+    def all_group_members(self):
+        return {r: self.members(r) for r in self.roots()}
+
+    def __str__(self):
+        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
+
+groups = UnionFind(n + 1)
+num = defaultdict(lambda: 0)
+
+for _ in range(m):
+    a, b, c = map(int, input().split())
+    abc.append((a, b, c))
+    groups.union(a, b)
+
+group_nums = defaultdict(lambda: defaultdict(lambda: 0))
+for a, b, c in abc:
+    group_id = groups.find(a)
+    if group_nums[group_id][a] != 0:
+        group_nums[group_id][b] = group_nums[group_id][a] - c
+    else:
+        group_nums[group_id][a] = group_nums[group_id][b] + c
+
+candidates = defaultdict(lambda: [])
+
+group_orders = defaultdict(lambda: [])
+for group_id, nums in group_nums.items():
+    min_value = min(nums.values())
+    sorted_nums = list(sorted([[k, v - min_value] for k, v in nums.items()], key=lambda x: x[1]))
+    max_num = sorted_nums[-1][1]
+    for base_num in range(1, n + 1 - max_num):
+        pattern = []
+        for pos, value in sorted_nums:
+            pattern.append((pos, value + base_num))
+        candidates[group_id].append(pattern)
+
+sets = [set() for _ in range(n + 1)]
+
+for cand in candidates.values():
+    for c in cand:
+        for pos, value in c:
+            sets[pos].add(value)
+print(sets)
+
+ans = []
+for ss in sets[1:]:
+    if len(ss) == 1:
+        ans.append(list(ss)[0])
+    else:
+        ans.append(-1)
+print(*ans, sep=" ")