abc351

Author: reo11

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

@@ -0,0 +1,4 @@
+a = list(map(int, input().split()))
+b = list(map(int, input().split()))
+
+print(sum(a) - sum(b) + 1)

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

@@ -0,0 +1,14 @@
+n = int(input())
+a = [[i for i in list(str(input()))] for _ in range(n)]
+b = [[i for i in list(str(input()))] for _ in range(n)]
+
+ans = [-1, -1]
+
+for i in range(n):
+    for j in range(n):
+        if a[i][j] != b[i][j]:
+            ans = [i + 1, j + 1]
+            break
+    if ans != [-1, -1]:
+        break
+print(*ans, sep=" ")

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

@@ -0,0 +1,48 @@
+from collections import deque
+n = int(input())
+a = list(map(int, input().split()))
+
+# 右方向から走査と左方向から走査を一回ずつ
+a = deque(a)
+tmp_a = deque()
+
+while a:
+    a_head = a.popleft()
+    if len(tmp_a) > 0 and tmp_a[-1] == a_head:
+        a_head += 1
+        tmp_a.pop()
+        a.appendleft(a_head)
+        continue
+    elif len(a) == 0:
+        tmp_a.append(a_head)
+        break
+    else:
+        if a[0] == a_head:
+            a.popleft()
+            a_head += 1
+            a.appendleft(a_head)
+        else:
+            tmp_a.append(a_head)
+
+a = tmp_a
+tmp_a = deque()
+
+while a:
+    a_tail = a.pop()
+    if len(tmp_a) > 0 and tmp_a[0] == a_tail:
+        a_tail += 1
+        tmp_a.popleft()
+        a.append(a_tail)
+        continue
+    elif len(a) == 0:
+        tmp_a.appendleft(a_tail)
+        break
+    else:
+        if a[-1] == a_tail:
+            a.pop()
+            a_tail += 1
+            a.append(a_tail)
+        else:
+            tmp_a.appendleft(a_tail)
+
+print(len(tmp_a))

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

@@ -0,0 +1,97 @@
+import sys
+from collections import defaultdict, deque
+input = lambda: sys.stdin.readline().rstrip()
+
+h, w = map(int, input().split())
+s = [[i for i in list(str(input()))] for _ in range(h)]
+
+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())
+
+pos_num = defaultdict(lambda: len(pos_num))
+visited = [[False] * w for _ in range(h)]
+dxy = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+def is_magnet_neighbour(y, x):
+    for dy, dx in dxy:
+        ny = y + dy
+        nx = x + dx
+        if 0 <= ny < h and 0 <= nx < w and s[ny][nx] == "#":
+            return True
+    return False
+
+ans = 0
+q = deque()
+for i in range(h):
+    for j in range(w):
+        if s[i][j] == "#":
+            visited[i][j] = True
+            continue
+        elif visited[i][j]:
+            continue
+        else:
+            q = deque([(i, j)])
+            visit_path = set([(i, j)])
+            if not is_magnet_neighbour(i, j):
+                while q:
+                    y, x = q.popleft()
+                    visited[y][x] = True
+                    for dy, dx in dxy:
+                        ny = y + dy
+                        nx = x + dx
+                        if not(0 <= ny < h and 0 <= nx < w):
+                            continue
+                        if s[ny][nx] == "#":
+                            continue
+                        if (ny, nx) in visit_path:
+                            continue
+                        visit_path.add((ny, nx))
+                        if is_magnet_neighbour(ny, nx):
+                            continue
+                        q.append((ny, nx))
+            ans = max(ans, len(visit_path))
+print(ans)

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

@@ -0,0 +1,20 @@
+n = int(input())
+# 座標変換
+convert = lambda x, y: (x + y, x - y)
+
+xy_groups = [[], []]
+for _ in range(n):
+    a, b = map(int, input().split())
+    xy_groups[(a + b) % 2].append(convert(a, b))
+
+ans = 0
+for group_num, xys in enumerate(xy_groups):
+    xs, ys = [], []
+    for x, y in xys:
+        xs.append(x); ys.append(y)
+    xs.sort(); ys.sort()
+    sum_x, sum_y = 0, 0
+    for i in range(len(xys)):
+        ans += (xs[i] * i - sum_x + ys[i] * i - sum_y) // 2
+        sum_x += xs[i]; sum_y += ys[i]
+print(ans)

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

@@ -0,0 +1,106 @@
+from collections import defaultdict
+from math import gcd
+
+n = int(input())
+a = list(map(int, input().split()))
+
+class SegTree:
+    def __init__(self, n: int, mode: str = "min") -> None:
+        self.mode = mode
+        unit_elements = {
+            "min": 10**13,
+            "max": -(10**13),
+            "sum": 0,
+            "mul": 1,
+            "gcd": 0,
+        }
+        self.e = unit_elements[self.mode]  # 単位元
+        self.tree_size = 2 ** (n - 1).bit_length()  # n以上の最小の2のべき乗数
+        self.tree_value = [self.e] * 2 * self.tree_size
+
+    def __str__(self) -> str:
+        if self.tree_size > 2**4:
+            return "Segtree size too big"
+        out = ""
+        i = 0
+        j = 0
+        count = 1
+        while i < self.tree_size - 1:
+            if self.tree_value[i] == self.e:
+                s = "-"
+            else:
+                s = str(self.tree_value[i])
+            s = s.center((self.tree_size * 2) // count, " ")
+            out += s
+            i += 1
+            j += 1
+            if j == count:
+                count *= 2
+                j = 0
+                out += "\n"
+        return out
+
+    def _op(self, a: int, b: int) -> int:
+        if self.mode == "min":
+            return min(a, b)
+        elif self.mode == "max":
+            return max(a, b)
+        elif self.mode == "sum":
+            return a + b
+        elif self.mode == "mul":
+            return a * b
+        elif self.mode == "gcd":
+            return gcd(a, b)
+
+        raise "no method defined"
+
+    def update(self, pos: int, value: int) -> None:
+        pos += self.tree_size - 1
+        self.tree_value[pos] = value
+        while pos:
+            pos = (pos - 1) // 2
+            self.tree_value[pos] = self._op(
+                self.tree_value[pos * 2 + 1], self.tree_value[pos * 2 + 2]
+            )
+
+    def query(self, l: int, r: int) -> int:
+        r += 1
+        if r <= l:
+            return self.e
+        l += self.tree_size - 1
+        r += self.tree_size - 2
+        res = self.e
+        while r - l > 1:
+            if l & 1 == 0:
+                res = self._op(res, self.tree_value[l])
+            if r & 1 == 1:
+                res = self._op(res, self.tree_value[r])
+                r -= 1
+            l = l // 2
+            r = (r - 1) // 2
+        if l == r:
+            res = self._op(res, self.tree_value[l])
+        else:
+            res = self._op(self._op(res, self.tree_value[l]), self.tree_value[r])
+        return res
+
+# 予め座標圧縮 + セグ木
+
+pos_num = defaultdict(lambda: len(pos_num))
+
+for ai in sorted(a):
+    pos_num[ai]
+
+sum_tree = SegTree(n + 1, mode="sum")
+counter_tree = SegTree(n + 1, mode="sum")
+ans = 0
+for ai in a:
+    idx = pos_num[ai]
+
+    # それまでの数値とあれこれする
+    ans += counter_tree.query(0, idx) * ai - sum_tree.query(0, idx)
+    num = sum_tree.query(idx, idx)
+    sum_tree.update(idx, num + ai)
+    cnt = counter_tree.query(idx, idx)
+    counter_tree.update(idx, cnt + 1)
+print(ans)