abc341

Author: reo11

algorithm_libraries/python/data_structure/segtree_base.py

@@ -0,0 +1,144 @@
+from typing import Callable, List
+
+
+class SegTree:
+    def __init__(self, n: int, e: int, op: Callable) -> None:
+        """
+        Args:
+            n (int): 要素数
+            e (int): 単位元
+            op (Callable): 演算
+        """
+        self.n = n
+        self.e = e
+        self.lv = (self.n - 1).bit_length()
+        self.tree_size = 2**self.lv
+        self.tree_value = [self.e] * (2 * self.tree_size)
+        self.tree_lazy = [None] * (2 * self.tree_size)
+        self._op = op
+
+    def gindex(self, l, r):
+        """
+        lazy load
+        Args:
+            l (_type_): _description_
+            r (_type_): _description_
+        Yields:
+            _type_: _description_
+        """
+        L = (l + self.tree_size) >> 1
+        R = (r + self.tree_size) >> 1
+        lc = 0 if l & 1 else (L & -L).bit_length()
+        rc = 0 if r & 1 else (R & -R).bit_length()
+        for i in range((self.n - 1).bit_length()):
+            if rc <= i:
+                yield R
+            if L < R and lc <= i:
+                yield L
+            L >>= 1
+            R >>= 1
+
+    def propagates(self, *ids):
+        """lazy load
+        """
+        for i in reversed(ids):
+            v = self.tree_lazy[i - 1]
+            if v is None:
+                continue
+            self.tree_lazy[2 * i - 1] = self.tree_value[2 * i - 1] = self.tree_lazy[
+                2 * i
+            ] = self.tree_value[2 * i] = v
+            self.tree_lazy[i - 1] = None
+
+    def build(self, init_array: List[int]) -> None:
+        """
+        Use if you have initial values array
+        Args:
+            init_array (List[int]): array
+        """
+        for i in range(len(init_array)):
+            self.tree_value[i + self.tree_size - 1] = init_array[i]
+        # build
+        for i in range(self.tree_size - 2, -1, -1):
+            self.tree_value[i] = self._op(
+                self.tree_value[2 * i + 1], self.tree_value[2 * i + 2]
+            )
+
+    def update(self, x: int, value: int) -> None:
+        """
+        Args:
+            x (int): position x
+            value (int): value
+        """
+        # 更新
+        self.update_range(l=x, r=x, value=value)
+
+    def update_range(self, l: int, r: int, value: int) -> None:
+        """
+        [l, r] range update
+        Args:
+            l (int): left
+            r (int): right
+            value (int): value
+        """
+        r += 1
+        (*ids,) = self.gindex(l, r)
+        self.propagates(*ids)
+        L = self.tree_size + l
+        R = self.tree_size + r
+        while L < R:
+            if R & 1:
+                R -= 1
+                self.tree_value[R - 1] = value
+                self.tree_lazy[R - 1] = value
+            if L & 1:
+                self.tree_value[L - 1] = value
+                self.tree_lazy[L - 1] = value
+                L += 1
+            L >>= 1
+            R >>= 1
+        for i in ids:
+            self.tree_value[i - 1] = self._op(
+                self.tree_value[2 * i - 1], self.tree_value[2 * i]
+            )
+
+    def query(self, l: int, r: int) -> int:
+        """
+        [l, r] range query
+        Args:
+            l (int): left
+            r (int): right
+
+        Returns:
+            int: _description_
+        """
+        self.propagates(*self.gindex(l, r))
+        L = self.tree_size + l
+        R = self.tree_size + r
+
+        s = self.e
+        while L < R:
+            if R & 1:
+                R -= 1
+                s = self._op(s, self.tree_value[R - 1])
+            if L & 1:
+                s = self._op(s, self.tree_value[L - 1])
+                L += 1
+            L >>= 1
+            R >>= 1
+        return s
+
+
+if __name__ == "__main__":
+    n, q = map(int, input().split())
+    a = list(map(int, input().split()))
+    lr = []
+    for _ in range(q):
+        l, r = map(int, input().split())
+        lr.append((l, r))
+    tree = SegTree(n, 10**10, lambda x, y: min(x, y))
+    tree.init(a)
+    ans = []
+    for l, r in lr:
+        ans.append(tree.query(l, r))
+print(*ans, sep="\n")

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

@@ -0,0 +1,9 @@
+n = int(input())
+ans = []
+
+for i in range(n):
+    ans.append(1)
+    ans.append(0)
+ans.append(1)
+
+print(*ans, sep="")

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

@@ -0,0 +1,14 @@
+n = int(input())
+a = list(map(int, input().split()))
+st = []
+for i in range(n - 1):
+    s, t = map(int, input().split())
+    st.append((s, t))
+
+for i in range(n - 1):
+    cnt = a[i] // st[i][0]
+    if cnt > 0:
+        a[i] -= st[i][0] * (cnt)
+        a[i + 1] += st[i][1] * (cnt)
+# print(a)
+print(a[-1])

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

@@ -0,0 +1,30 @@
+h, w, n = map(int, input().split())
+t = list(input())
+
+s = []
+for i in range(h):
+    s.append(list(input()))
+
+# 全探索
+count = 0
+for i in range(1, h - 1):
+    for j in range(1, w - 1):
+        pos = [i, j]
+        flag = 1
+        for ti in t:
+            if s[pos[0]][pos[1]] == "#":
+                flag = 0
+                break
+            if ti == "U":
+                pos[0] -= 1
+            elif ti == "D":
+                pos[0] += 1
+            elif ti == "L":
+                pos[1] -= 1
+            elif ti == "R":
+                pos[1] += 1
+            if s[pos[0]][pos[1]] == "#":
+                flag = 0
+                break
+        count += flag
+print(count)

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

@@ -0,0 +1,25 @@
+import math
+
+n, m, k = map(int, input().split())
+nm = math.lcm(n, m)
+
+
+# x以下の数のnの倍数 + mの倍数 - lcm nmの倍数の数
+def calc(x):
+    v1 = x // n
+    v2 = x // m
+    v3 = x // nm
+    return v1 + v2 - 2 * v3
+
+
+l = 0
+r = 10 ** 19
+
+while r - l > 1:
+    mid = (l + r) // 2
+    if calc(mid) < k:
+        l = mid
+    else:
+        r = mid
+
+print(r)

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

@@ -0,0 +1,130 @@
+from math import gcd
+from typing import List
+
+n, q = map(int, input().split())
+s = list(map(int, list(input())))
+
+queries = []
+
+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 init(self, init_val: List[int]) -> None:
+        # 初期値が指定されている場合
+        # logNの処理をまとめて実行するので、随時追加するのに比べてO(logN)程度高速
+        # updateを使った初期化: O(NlogN)
+        # initを使った初期化: O(N + logN)
+        # set_val
+        for i in range(len(init_val)):
+            self.tree_value[i + self.tree_size - 1] = init_val[i]
+        # built
+        for i in range(self.tree_size - 2, -1, -1):
+            self.tree_value[i] = self._op(
+                self.tree_value[2 * i + 1], self.tree_value[2 * i + 2]
+            )
+
+    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
+
+tree = SegTree(n - 1, "sum")
+
+for i in range(len(s) - 1):
+    if s[i] != s[i + 1]:
+        tree.update(i, 1)
+queries = []
+for _ in range(q):
+    query_type, l, r = map(int, input().split())
+    queries.append((query_type, l - 1, r - 1))
+
+ans = []
+for query_type, l, r in queries:
+    if query_type == 1:
+        if l > 0:
+            vl = tree.query(l - 1, l - 1)
+            tree.update(l - 1, 1 - vl)
+        if r < n - 1:
+            vr = tree.query(r, r)
+            tree.update(r, 1 - vr)
+    else:
+        v = tree.query(l, r - 1)
+        if r - l == v:
+            ans.append("Yes")
+        else:
+            ans.append("No")
+    # print(*out, sep=" ")
+
+print(*ans, sep="\n")