abc350

Author: reo11

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

@@ -0,0 +1,14 @@
+abc = input()
+abc_sets = set()
+
+for i in range(1, 350):
+    if i == 316:
+        continue
+    num_str = str(i)
+    num_str = "0" * (3 - len(num_str)) + num_str
+    abc_sets.add("ABC" + num_str)
+
+if abc in abc_sets:
+    print("Yes")
+else:
+    print("No")

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

@@ -0,0 +1,12 @@
+n, q = map(int, input().split())
+t = list(map(int, input().split()))
+
+teeth = [True] * n
+
+for ti in t:
+    if teeth[ti - 1]:
+        teeth[ti - 1] = False
+    else:
+        teeth[ti - 1] = True
+
+print(sum(teeth))

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

@@ -0,0 +1,23 @@
+n = int(input())
+a = list(map(int, input().split()))
+
+positions = dict()
+
+for i in range(n):
+    positions[a[i]] = i
+
+ans = []
+
+for i in range(1, n + 1):
+    if a[i - 1] == i:
+        continue
+    else:
+        # swap
+        ans.append(f"{i} {positions[i] + 1}")
+        a[positions[i]] = a[i - 1]
+        positions[a[i - 1]] = positions[i]
+        positions[i] = i - 1
+        a[i - 1] = i
+print(len(ans))
+if len(ans) > 0:
+    print(*ans, sep="\n")

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

@@ -0,0 +1,77 @@
+from collections import defaultdict
+
+n, m = map(int, input().split())
+ab = []
+for _ in range(m):
+    a, b = map(int, input().split())
+    ab.append((a - 1, b - 1))
+
+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())
+
+uf_tree = UnionFind(n=n)
+
+for a, b in ab:
+    uf_tree.union(a, b)
+
+group_counts = defaultdict(int)
+
+for i in range(n):
+    group = uf_tree.find(i)
+    group_counts[group] += 1
+
+path_count = defaultdict(int)
+for a, _ in ab:
+    group = uf_tree.find(a)
+    path_count[group] += 1
+
+ans = 0
+for group in group_counts.keys():
+    ans += group_counts[group] * (group_counts[group] - 1) // 2
+    ans -= path_count[group]
+
+print(ans)

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

@@ -0,0 +1,16 @@
+from collections import defaultdict
+
+n, a, x, y = map(int, input().split())
+size = 5
+dp = [defaultdict(int) for _ in range(size)]
+
+dp[0][n] = 0
+for i in range(1, size):
+    keys = dp[i - 1].keys()
+    for key in keys:
+        dp[i][key] = dp[i - 1][key]
+        dp[i][key // a] += x
+        for j in range(1, 7):
+            dp[i][key // j] += (y / 6)
+
+print(dp)