Codeforces Round 950

Author: MikeAlwaysCode

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PA - Subsegment Reverse.py

@@ -0,0 +1,22 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    n, l, r = mint()
+    ans = list(range(1, l)) + list(range(r, l - 1, -1)) + list(range(r + 1, n + 1))
+    print(*ans)
+
+
+solve()

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PB - Nutrients.py

@@ -0,0 +1,26 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    n, m = mint()
+    nums = ints()
+    for _ in range(n):
+        food = ints()
+        for i, x in enumerate(food):
+            nums[i] -= x
+    print("Yes" if all(x <= 0 for x in nums) else "No")
+
+
+solve()

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PC - Keys.py

@@ -0,0 +1,37 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    n, m, k = mint()
+    keys = [[] for _ in range(m)]
+    R = [False] * m
+    for i in range(m):
+        s = input().split()
+        if s.pop() == 'o':
+            R[i] = True
+        for c in s[1:]:
+            keys[i].append(int(c) - 1)
+    def check(mask: int) -> int:
+        for i in range(m):
+            cnt = 0
+            for j in keys[i]:
+                cnt += (mask >> j) & 1
+            if (cnt >= k) != R[i]:
+                return 0
+        return 1
+    ans = sum(check(mask) for mask in range(1 << n))
+    print(ans)
+
+solve()

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PD - Masked Popcount.py

@@ -0,0 +1,26 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    n, m = mint()
+    ans = 0
+    for bit in range(60):
+        if not (m >> bit) & 1:
+            continue
+        ans = (ans + (n >> (bit + 1) << bit) + ((n >> bit) & 1) * ((n & ((1 << bit) - 1)) + 1)) % MOD
+    print(ans)
+
+
+solve()

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PE - MaxMin.py

@@ -0,0 +1,37 @@
+import sys
+from collections import Counter
+# from bisect import bisect_left
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    n = sint()
+    nums = ints()
+    ans = 0
+    cnt = Counter(nums)
+    mx = max(nums)
+    d = [0] * (mx + 1)
+    for x in set(nums):
+        for j in range(x, mx + 1, x):
+            d[j] += cnt[x]
+    c = 0
+    for i, c1 in enumerate(d):
+        c += c1
+        if cnt[i]:
+            ans += c * cnt[i] - cnt[i] * cnt[i] + cnt[i] * (cnt[i] - 1) // 2
+
+    print(ans)
+
+
+solve()

Diff for: Contests/AtCoderPython/AtCoder Beginner Contest 356/PF - Distance Component Size Query.py

@@ -0,0 +1,176 @@
+import sys
+import math
+from collections import Counter
+from bisect import bisect_left, bisect_right
+from typing import Generic, Iterable, Iterator, List, TypeVar, Union
+
+T = TypeVar('T')
+
+class SortedSet(Generic[T]):
+    BUCKET_RATIO = 50
+    REBUILD_RATIO = 170
+
+    def _build(self, a=None) -> None:
+        "Evenly divide `a` into buckets."
+        if a is None: a = list(self)
+        size = self.size = len(a)
+        bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
+        self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
+    
+    def __init__(self, a: Iterable[T] = []) -> None:
+        "Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
+        a = list(a)
+        if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
+            a = sorted(set(a))
+        self._build(a)
+
+    def __iter__(self) -> Iterator[T]:
+        for i in self.a:
+            for j in i: yield j
+
+    def __reversed__(self) -> Iterator[T]:
+        for i in reversed(self.a):
+            for j in reversed(i): yield j
+    
+    def __len__(self) -> int:
+        return self.size
+    
+    def __repr__(self) -> str:
+        return "SortedSet" + str(self.a)
+    
+    def __str__(self) -> str:
+        s = str(list(self))
+        return "{" + s[1 : len(s) - 1] + "}"
+
+    def _find_bucket(self, x: T) -> List[T]:
+        "Find the bucket which should contain x. self must not be empty."
+        for a in self.a:
+            if x <= a[-1]: return a
+        return a
+
+    def __contains__(self, x: T) -> bool:
+        if self.size == 0: return False
+        a = self._find_bucket(x)
+        i = bisect_left(a, x)
+        return i != len(a) and a[i] == x
+
+    def add(self, x: T) -> bool:
+        "Add an element and return True if added. / O(√N)"
+        if self.size == 0:
+            self.a = [[x]]
+            self.size = 1
+            return True
+        a = self._find_bucket(x)
+        i = bisect_left(a, x)
+        if i != len(a) and a[i] == x: return False
+        a.insert(i, x)
+        self.size += 1
+        if len(a) > len(self.a) * self.REBUILD_RATIO:
+            self._build()
+        return True
+
+    def discard(self, x: T) -> bool:
+        "Remove an element and return True if removed. / O(√N)"
+        if self.size == 0: return False
+        a = self._find_bucket(x)
+        i = bisect_left(a, x)
+        if i == len(a) or a[i] != x: return False
+        a.pop(i)
+        self.size -= 1
+        if len(a) == 0: self._build()
+        return True
+    
+    def lt(self, x: T) -> Union[T, None]:
+        "Find the largest element < x, or None if it doesn't exist."
+        for a in reversed(self.a):
+            if a[0] < x:
+                return a[bisect_left(a, x) - 1]
+
+    def le(self, x: T) -> Union[T, None]:
+        "Find the largest element <= x, or None if it doesn't exist."
+        for a in reversed(self.a):
+            if a[0] <= x:
+                return a[bisect_right(a, x) - 1]
+
+    def gt(self, x: T) -> Union[T, None]:
+        "Find the smallest element > x, or None if it doesn't exist."
+        for a in self.a:
+            if a[-1] > x:
+                return a[bisect_right(a, x)]
+
+    def ge(self, x: T) -> Union[T, None]:
+        "Find the smallest element >= x, or None if it doesn't exist."
+        for a in self.a:
+            if a[-1] >= x:
+                return a[bisect_left(a, x)]
+    
+    def __getitem__(self, x: int) -> T:
+        "Return the x-th element, or IndexError if it doesn't exist."
+        if x < 0: x += self.size
+        if x < 0: raise IndexError
+        for a in self.a:
+            if x < len(a): return a[x]
+            x -= len(a)
+        raise IndexError
+    
+    def index(self, x: T) -> int:
+        "Count the number of elements < x."
+        ans = 0
+        for a in self.a:
+            if a[-1] >= x:
+                return ans + bisect_left(a, x)
+            ans += len(a)
+        return ans
+
+    def index_right(self, x: T) -> int:
+        "Count the number of elements <= x."
+        ans = 0
+        for a in self.a:
+            if a[-1] > x:
+                return ans + bisect_right(a, x)
+            ans += len(a)
+        return ans
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+
+def solve() -> None:
+    ss = SortedSet()
+    q, k = mint()
+    right = Counter()
+    left = Counter()
+    for _ in range(q):
+        t, x = mint()
+        if t == 1:
+            l = ss.lt(x)
+            r = ss.gt(x)
+            if x in ss:
+                ss.discard(x)
+                if l is not None:
+                    right[l] = 0 if r is None or r > l + k else right[r] + 1
+                if r is not None:
+                    left[r] = 0 if l is None or l < r - k else left[l] + 1
+                left[x] = right[x] = 0
+            else:
+                ss.add(x)
+                if l is not None:
+                    right[l] = 0 if x > l + k else 1 if r is None or r > x + k else right[r] + 2
+                if r is not None:
+                    left[r] = 0 if x < r - k else 1 if l is None or l < x - k else left[l] + 1
+                left[x] = 0 if l is None or l < x - k else left[l] + 1
+                right[x] = 0 if r is None or r > x + k else right[r] + 1
+        else:
+            print(left[x] + right[x] + 1)
+
+
+solve()

Diff for: Contests/CodeforcesPython/Codeforces Round 162 Div. 1/A_Escape_from_Stones/A_Escape_from_Stones.py

@@ -0,0 +1,20 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR4 = ((-1, 0), (0, 1), (1, 0), (0, -1)) #URDL
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+def solve() -> None:
+    return
+
+
+for _ in range(int(input())):
+    solve()

Diff for: Contests/CodeforcesPython/Codeforces Round 162 Div. 1/B_Good_Sequences/B_Good_Sequences.py

@@ -0,0 +1,20 @@
+import sys
+
+# region fastio
+input = lambda: sys.stdin.readline().rstrip()
+sint = lambda: int(input())
+mint = lambda: map(int, input().split())
+ints = lambda: list(map(int, input().split()))
+# endregion fastio
+
+# MOD = 998_244_353
+# MOD = 10 ** 9 + 7
+# DIR4 = ((-1, 0), (0, 1), (1, 0), (0, -1)) #URDL
+# DIR8 = ((-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1))
+
+def solve() -> None:
+    return
+
+
+for _ in range(int(input())):
+    solve()