id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_1101
|
a,b,c,d,e,f,x=map(int,input().split())
ta=(x//(a+c))*a*b+min(x%(a+c),a)*b
ao=(x//(d+f))*d*e+min(x%(d+f),d)*e
if ta>ao:
print("takahashi")
elif ao>ta:
print("Aoki")
else:
print("Draw")
a,b,c,d,e,f,x=map(int,input().split())
ta=(x//(a+c))*a*b+min(x%(a+c),a)*b
ao=(x//(d+f))*d*e+min(x%(d+f),d)*e
if ta>ao:
print("Takahashi")
elif ao>ta:
print("Aoki")
else:
print("Draw")
|
ConDefects/ConDefects/Code/abc249_a/Python/45229228
|
condefects-python_data_1102
|
a,b,c,d,e,f,x = map(int, input().split())
xbk = x
y, z = 0, 0
y += x // (a + c) * a * b
x -= x // (a + c) * (a + c)
if x - a >= 0:
y += a * b
else:
y += x * b
x = xbk
z += x // (d + f) * d * e
z -= x // (d + f) * (d + f)
if x - d >= 0:
z += d * e
else:
z += x * e
print("Takahashi" if y > z else "Aoki" if y < z else "Draw")
a,b,c,d,e,f,x = map(int, input().split())
xbk = x
y, z = 0, 0
y += x // (a + c) * a * b
x -= x // (a + c) * (a + c)
if x - a >= 0:
y += a * b
else:
y += x * b
x = xbk
z += x // (d + f) * d * e
x -= x // (d + f) * (d + f)
if x - d >= 0:
z += d * e
else:
z += x * e
print("Takahashi" if y > z else "Aoki" if y < z else "Draw")
|
ConDefects/ConDefects/Code/abc249_a/Python/45778141
|
condefects-python_data_1103
|
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd, sin ,cos
from copy import deepcopy
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce, cmp_to_key
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def tuple_row_list(N): return [tuple(map(int,input().split())) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
#sys. setrecursionlimit( 10** 6) # 再帰関数の時に必要。テスト実行ではREが発生する。
INF = float('inf')
MOD = pow(10,9) + 7
'''
# 誤差があるとき（精度が求められる時）の対策
- 割り算ではなく掛け算ができるか
- Decemal('数字の文字列')を使う。Pythonで提出する。
- A/B ≒ A*(10**20)//B として考えてみる。
- 小数点以下切り捨ては1で割った商でできる。
# 分数で誤差なしソート
- sorted() 関数の key 引数に functools.cmp_to_key(cmp) を渡してやる(例: https://qiita.com/nishizumi_noob/items/7a1323c45cf6ce56a368 )
'''
a,b,c,d,e,f,x = i_map()
t_times = x//(a+c)
a_times = x//(d+f)
t_mod = x%(a+c)
a_mod = x%(d+f)
judge = t_times*a*b
if t_mod >= a:
judge += a*b
else:
judge += t_mod*b
judge -= a_times*d*e
if a_mod >= d:
judge -= d*e
else:
judge -= a_mod*f
if judge > 0:
print('Takahashi')
elif judge == 0:
print('Draw')
else:
print("Aoki")
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd, sin ,cos
from copy import deepcopy
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce, cmp_to_key
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def tuple_row_list(N): return [tuple(map(int,input().split())) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
#sys. setrecursionlimit( 10** 6) # 再帰関数の時に必要。テスト実行ではREが発生する。
INF = float('inf')
MOD = pow(10,9) + 7
'''
# 誤差があるとき（精度が求められる時）の対策
- 割り算ではなく掛け算ができるか
- Decemal('数字の文字列')を使う。Pythonで提出する。
- A/B ≒ A*(10**20)//B として考えてみる。
- 小数点以下切り捨ては1で割った商でできる。
# 分数で誤差なしソート
- sorted() 関数の key 引数に functools.cmp_to_key(cmp) を渡してやる(例: https://qiita.com/nishizumi_noob/items/7a1323c45cf6ce56a368 )
'''
a,b,c,d,e,f,x = i_map()
t_times = x//(a+c)
a_times = x//(d+f)
t_mod = x%(a+c)
a_mod = x%(d+f)
judge = t_times*a*b
if t_mod >= a:
judge += a*b
else:
judge += t_mod*b
judge -= a_times*d*e
if a_mod >= d:
judge -= d*e
else:
judge -= a_mod*e
if judge > 0:
print('Takahashi')
elif judge == 0:
print('Draw')
else:
print("Aoki")
|
ConDefects/ConDefects/Code/abc249_a/Python/45104462
|
condefects-python_data_1104
|
def d(a, b, c, x):
t = x // (a + c)
return t * (a * b) + (x - ((a + c) * t)) * b
A, B, C, D, E, F, X = map(int, input().split())
if d(A, B, C, X) > d(D, E, F, X):
print("Takahashi")
elif d(A, B, C, X) < d(D, E, F, X):
print("Aoki")
else:
print("Draw")
def d(a, b, c, x):
t = x // (a + c)
return t * (a * b) + min(a, (x - ((a + c) * t))) * b
A, B, C, D, E, F, X = map(int, input().split())
if d(A, B, C, X) > d(D, E, F, X):
print("Takahashi")
elif d(A, B, C, X) < d(D, E, F, X):
print("Aoki")
else:
print("Draw")
|
ConDefects/ConDefects/Code/abc249_a/Python/44441991
|
condefects-python_data_1105
|
#https://atcoder.jp/contests/ARC173/tasks/ARC173_d
import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline
from collections import defaultdict, deque, Counter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right
from math import gcd, lcm
from itertools import permutations
n = int(input())
p = list(map(int,input().split()))
left = [i for i in range(n)]
ans = [-1]*(n)
now = 3
while left:
new = []
for i in left:
med = 1
x = now//2
c = p[i]
if i-x >= 0 and i+x < n:
l = p[i-x]
r = p[i+x]
med &= (l<c<r) or (r<c<l)
if i + (now-1) < n:
l = p[i+now-2]
r = p[i+now-1]
med &= (l<c<r) or (r<c<l)
if i - (now-1) >= 0:
l = p[i-(now-1)]
r = p[i-(now-2)]
med &= (l<c<r) or (r<c<l)
if now >= 5:
if i + (now-2) < n:
l = p[i+now-3]
r = p[i+now-2]
med &= (l<c<r) or (r<c<l)
if i - (now-2) >= 0:
l = p[i-(now-2)]
r = p[i-(now-3)]
med &= (l<c<r) or (r<c<l)
if med:
new.append(i)
else:
ans[i] = now
now += 2
left = new
if now > n:
break
print(*ans)
#https://atcoder.jp/contests/ARC173/tasks/ARC173_d
import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline
from collections import defaultdict, deque, Counter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right
from math import gcd, lcm
from itertools import permutations
n = int(input())
p = list(map(int,input().split()))
left = [i for i in range(n)]
ans = [-1]*(n)
now = 3
while left:
new = []
for i in left:
med = 1
x = now//2
c = p[i]
if i-x >= 0 and i+x < n:
l = p[i-x]
r = p[i+x]
med &= (l<c<r) or (r<c<l)
if i + (now-1) < n:
l = p[i+now-2]
r = p[i+now-1]
med &= (l<c<r) or (r<c<l)
if i - (now-1) >= 0:
l = p[i-(now-1)]
r = p[i-(now-2)]
med &= (l<c<r) or (r<c<l)
if now >= 5 and 1 <= i <= n-2:
if i + (now-2) < n:
l = p[i+now-3]
r = p[i+now-2]
med &= (l<c<r) or (r<c<l)
if i - (now-2) >= 0:
l = p[i-(now-2)]
r = p[i-(now-3)]
med &= (l<c<r) or (r<c<l)
if med:
new.append(i)
else:
ans[i] = now
now += 2
left = new
if now > n:
break
print(*ans)
|
ConDefects/ConDefects/Code/arc173_c/Python/51460321
|
condefects-python_data_1106
|
from operator import add, eq
class SegmentTreeInjectable:
"""
単位元生成関数 identity_factory と二項演算関数 func を外部注入するセグメント木
[生成]
SegmentTreeInjectable(n, identity_factory, func)
SegmentTreeInjectable.from_array(array, identity_factory, func) # 既存の配列より作成
[関数]
add(i, x) Aiにxを加算
update(i, x) Aiをxに書き換え
get_range(a, b) [a, b) の集約値を得る
get_all() 全ての集約値を得る
get_point(i) Aiを得る
leftmost(a, b, x, ev) [a, b) の範囲で、ev(x, Ai)=True となる最も左の i を得る（前提条件あり）
rightmost(a, b, x, ev) [a, b) の範囲で、ev(x, Ai)=True となる最も右の i を得る（前提条件あり）
debug_print() 深さ毎に整形して出力する
"""
def __init__(self, n, identity_factory, func):
n2 = 1 << (n - 1).bit_length()
self.offset = n2
self.tree = [identity_factory() for _ in range(n2 << 1)]
self.func = func
self.idf = identity_factory
@classmethod
def from_array(cls, arr, identity_factory, func):
""" 既存の配列から生成 """
ins = cls(len(arr), identity_factory, func)
ins.tree[ins.offset:ins.offset + len(arr)] = arr
for i in range(ins.offset - 1, 0, -1):
l = i << 1
r = l + 1
ins.tree[i] = func(ins.tree[l], ins.tree[r])
return ins
def add(self, i, x):
"""
Aiにxを加算
:param i: index (0-indexed)
:param x: add value
"""
i += self.offset
self.tree[i] = self.func(self.tree[i], x)
self.__upstream(i)
def update(self, i, x):
"""
Aiの値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.offset
self.tree[i] = x
self.__upstream(i)
def __upstream(self, i):
tree = self.tree
func = self.func
while i > 1:
i >>= 1
lch = i << 1
rch = lch | 1
tree[i] = func(tree[lch], tree[rch])
def get_range(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
tree = self.tree
func = self.func
result_l = self.idf()
result_r = self.idf()
l = a + self.offset
r = b + self.offset
while l < r:
if r & 1:
result_r = func(tree[r - 1], result_r)
if l & 1:
result_l = func(result_l, tree[l])
l += 1
l >>= 1
r >>= 1
return func(result_l, result_r)
def get_all(self):
return self.tree[1]
def get_point(self, i):
return self.tree[i + self.offset]
def leftmost(self, a, b, x, ev):
"""
[a, b) の範囲で、ev(x, 値) = True となる最初の index を得る。存在しない場合は-1。
使用できる条件:
[l, r) の集約値を y としたとき、ev(x, y)=True となることが、
l <= i < r 内に ev(x, Ai)=True となる要素があることと等しい。（(func, ev) = (min,ge), (max,le) など）
"""
tree = self.tree
l = a + self.offset
r = b + self.offset
r_found = -1
while l < r:
if l & 1:
if ev(x, tree[l]):
return self._leftmost_sub(l, x, ev)
l += 1
if r & 1:
if ev(x, tree[r - 1]):
r_found = r - 1
l >>= 1
r >>= 1
if r_found == -1:
return -1
return self._leftmost_sub(r_found, x, ev)
def _leftmost_sub(self, i, x, ev):
"""
tree-index i が示す範囲で、ev(x, Aj)=True となる最も左のarray-index j を得る
（tree[i] が示す範囲には条件を満たすものが必ず存在する前提とする）
"""
tree = self.tree
while i < self.offset:
l = i << 1
if ev(x, tree[l]):
i = l
else:
i = l + 1
return i - self.offset
def rightmost(self, a, b, x, ev):
"""
[a, b) の範囲で、ev(x, 値) = True となる最後の index を得る。存在しない場合は-1。
使用できる条件:
[l, r) の集約値を y としたとき、ev(x, y)=True となることが、
l <= i < r 内に ev(x, Ai)=True となる要素があることと等しい。（(func, ev) = (min,ge), (max,le) など）
"""
tree = self.tree
l = a + self.offset
r = b + self.offset
l_found = -1
while l < r:
if r & 1:
if ev(x, tree[r - 1]):
return self._rightmost_sub(r - 1, x, ev)
if l & 1:
if ev(x, tree[l]):
l_found = l
l += 1
l >>= 1
r >>= 1
if l_found == -1:
return -1
return self._rightmost_sub(l_found, x, ev)
def _rightmost_sub(self, i, x, ev):
"""
tree-index i が示す範囲で、ev(x, Aj)=True となる最も右のarray-index j を得る
（tree[i] が示す範囲には条件を満たすものが必ず存在する前提とする）
"""
tree = self.tree
while i < self.offset:
l = i << 1
if ev(x, tree[l + 1]):
i = l + 1
else:
i = l
return i - self.offset
def debug_print(self):
i = 1
while i <= self.offset:
print(self.tree[i:i * 2])
i <<= 1
n = int(input())
aaa = list(map(int, input().split()))
aaa = [a - 1 for a in aaa]
# import random
#
# n = 100
# aaa = list(range(n))
# random.shuffle(aaa)
# print(aaa)
pos = [0] * n
for i, a in enumerate(aaa, start=1):
pos[a] = i
def sgt_update(i):
b = aaa[i - 1]
if i > 1:
a = aaa[i - 2]
if a < b:
sgt.update(i - 1, 1)
else:
sgt.update(i - 1, 0)
if i < n:
c = aaa[i]
if b > c:
sgt.update(i, 1)
else:
sgt.update(i, 0)
def pattern_left():
j = 1
over = 0
under = 0
try:
while True:
if b < aaa[j]:
over += 1
else:
under += 1
j += 1
if b < aaa[j]:
over += 1
else:
under += 1
j += 1
if over != under:
return j
except:
return -1
def pattern_right():
j = n - 2
over = 0
under = 0
try:
while j >= 2:
if b < aaa[j]:
over += 1
else:
under += 1
j -= 1
if b < aaa[j]:
over += 1
else:
under += 1
j -= 1
if over != under:
return n - j - 1
else:
return -1
except:
return -1
sgt = SegmentTreeInjectable.from_array([1] * (n + 2), lambda: 1, max)
ans = [0] * n
INF = 1 << 60
for b in range(n):
i = pos[b]
if i == 1:
ans[i - 1] = pattern_left()
sgt_update(i)
continue
if i == n:
ans[i - 1] = pattern_right()
sgt_update(i)
continue
a = aaa[i - 2]
c = aaa[i]
if (a < b) == (b > c):
ans[i - 1] = 3
sgt_update(i)
# print(f'{b=} {i=}')
# sgt.debug_print()
continue
l = sgt.rightmost(0, i - 1, 1, eq)
r = sgt.leftmost(i + 1, n + 2, 1, eq)
# print(b, l, i, r, aaa[l - 1:r + 1])
tmp = INF
if l > 0:
tmp = min(tmp, (i - l + 1) // 2 * 2 + 1)
if r < n:
tmp = min(tmp, (r - i + 2) // 2 * 2 + 1)
if tmp == INF:
tmp = -1
ans[i - 1] = tmp
sgt_update(i)
# print(f'{b=} {i=} {tmp=}')
# sgt.debug_print()
print(*ans)
from operator import add, eq
class SegmentTreeInjectable:
"""
単位元生成関数 identity_factory と二項演算関数 func を外部注入するセグメント木
[生成]
SegmentTreeInjectable(n, identity_factory, func)
SegmentTreeInjectable.from_array(array, identity_factory, func) # 既存の配列より作成
[関数]
add(i, x) Aiにxを加算
update(i, x) Aiをxに書き換え
get_range(a, b) [a, b) の集約値を得る
get_all() 全ての集約値を得る
get_point(i) Aiを得る
leftmost(a, b, x, ev) [a, b) の範囲で、ev(x, Ai)=True となる最も左の i を得る（前提条件あり）
rightmost(a, b, x, ev) [a, b) の範囲で、ev(x, Ai)=True となる最も右の i を得る（前提条件あり）
debug_print() 深さ毎に整形して出力する
"""
def __init__(self, n, identity_factory, func):
n2 = 1 << (n - 1).bit_length()
self.offset = n2
self.tree = [identity_factory() for _ in range(n2 << 1)]
self.func = func
self.idf = identity_factory
@classmethod
def from_array(cls, arr, identity_factory, func):
""" 既存の配列から生成 """
ins = cls(len(arr), identity_factory, func)
ins.tree[ins.offset:ins.offset + len(arr)] = arr
for i in range(ins.offset - 1, 0, -1):
l = i << 1
r = l + 1
ins.tree[i] = func(ins.tree[l], ins.tree[r])
return ins
def add(self, i, x):
"""
Aiにxを加算
:param i: index (0-indexed)
:param x: add value
"""
i += self.offset
self.tree[i] = self.func(self.tree[i], x)
self.__upstream(i)
def update(self, i, x):
"""
Aiの値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.offset
self.tree[i] = x
self.__upstream(i)
def __upstream(self, i):
tree = self.tree
func = self.func
while i > 1:
i >>= 1
lch = i << 1
rch = lch | 1
tree[i] = func(tree[lch], tree[rch])
def get_range(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
tree = self.tree
func = self.func
result_l = self.idf()
result_r = self.idf()
l = a + self.offset
r = b + self.offset
while l < r:
if r & 1:
result_r = func(tree[r - 1], result_r)
if l & 1:
result_l = func(result_l, tree[l])
l += 1
l >>= 1
r >>= 1
return func(result_l, result_r)
def get_all(self):
return self.tree[1]
def get_point(self, i):
return self.tree[i + self.offset]
def leftmost(self, a, b, x, ev):
"""
[a, b) の範囲で、ev(x, 値) = True となる最初の index を得る。存在しない場合は-1。
使用できる条件:
[l, r) の集約値を y としたとき、ev(x, y)=True となることが、
l <= i < r 内に ev(x, Ai)=True となる要素があることと等しい。（(func, ev) = (min,ge), (max,le) など）
"""
tree = self.tree
l = a + self.offset
r = b + self.offset
r_found = -1
while l < r:
if l & 1:
if ev(x, tree[l]):
return self._leftmost_sub(l, x, ev)
l += 1
if r & 1:
if ev(x, tree[r - 1]):
r_found = r - 1
l >>= 1
r >>= 1
if r_found == -1:
return -1
return self._leftmost_sub(r_found, x, ev)
def _leftmost_sub(self, i, x, ev):
"""
tree-index i が示す範囲で、ev(x, Aj)=True となる最も左のarray-index j を得る
（tree[i] が示す範囲には条件を満たすものが必ず存在する前提とする）
"""
tree = self.tree
while i < self.offset:
l = i << 1
if ev(x, tree[l]):
i = l
else:
i = l + 1
return i - self.offset
def rightmost(self, a, b, x, ev):
"""
[a, b) の範囲で、ev(x, 値) = True となる最後の index を得る。存在しない場合は-1。
使用できる条件:
[l, r) の集約値を y としたとき、ev(x, y)=True となることが、
l <= i < r 内に ev(x, Ai)=True となる要素があることと等しい。（(func, ev) = (min,ge), (max,le) など）
"""
tree = self.tree
l = a + self.offset
r = b + self.offset
l_found = -1
while l < r:
if r & 1:
if ev(x, tree[r - 1]):
return self._rightmost_sub(r - 1, x, ev)
if l & 1:
if ev(x, tree[l]):
l_found = l
l += 1
l >>= 1
r >>= 1
if l_found == -1:
return -1
return self._rightmost_sub(l_found, x, ev)
def _rightmost_sub(self, i, x, ev):
"""
tree-index i が示す範囲で、ev(x, Aj)=True となる最も右のarray-index j を得る
（tree[i] が示す範囲には条件を満たすものが必ず存在する前提とする）
"""
tree = self.tree
while i < self.offset:
l = i << 1
if ev(x, tree[l + 1]):
i = l + 1
else:
i = l
return i - self.offset
def debug_print(self):
i = 1
while i <= self.offset:
print(self.tree[i:i * 2])
i <<= 1
n = int(input())
aaa = list(map(int, input().split()))
aaa = [a - 1 for a in aaa]
# import random
#
# n = 100
# aaa = list(range(n))
# random.shuffle(aaa)
# print(aaa)
pos = [0] * n
for i, a in enumerate(aaa, start=1):
pos[a] = i
def sgt_update(i):
b = aaa[i - 1]
if i > 1:
a = aaa[i - 2]
if a < b:
sgt.update(i - 1, 1)
else:
sgt.update(i - 1, 0)
if i < n:
c = aaa[i]
if b > c:
sgt.update(i, 1)
else:
sgt.update(i, 0)
def pattern_left():
j = 1
over = 0
under = 0
try:
while True:
if b < aaa[j]:
over += 1
else:
under += 1
j += 1
if b < aaa[j]:
over += 1
else:
under += 1
j += 1
if over != under:
return j
except:
return -1
def pattern_right():
j = n - 2
over = 0
under = 0
try:
while j >= 1:
if b < aaa[j]:
over += 1
else:
under += 1
j -= 1
if b < aaa[j]:
over += 1
else:
under += 1
j -= 1
if over != under:
return n - j - 1
else:
return -1
except:
return -1
sgt = SegmentTreeInjectable.from_array([1] * (n + 2), lambda: 1, max)
ans = [0] * n
INF = 1 << 60
for b in range(n):
i = pos[b]
if i == 1:
ans[i - 1] = pattern_left()
sgt_update(i)
continue
if i == n:
ans[i - 1] = pattern_right()
sgt_update(i)
continue
a = aaa[i - 2]
c = aaa[i]
if (a < b) == (b > c):
ans[i - 1] = 3
sgt_update(i)
# print(f'{b=} {i=}')
# sgt.debug_print()
continue
l = sgt.rightmost(0, i - 1, 1, eq)
r = sgt.leftmost(i + 1, n + 2, 1, eq)
# print(b, l, i, r, aaa[l - 1:r + 1])
tmp = INF
if l > 0:
tmp = min(tmp, (i - l + 1) // 2 * 2 + 1)
if r < n:
tmp = min(tmp, (r - i + 2) // 2 * 2 + 1)
if tmp == INF:
tmp = -1
ans[i - 1] = tmp
sgt_update(i)
# print(f'{b=} {i=} {tmp=}')
# sgt.debug_print()
print(*ans)
|
ConDefects/ConDefects/Code/arc173_c/Python/51137292
|
condefects-python_data_1107
|
n,m=map(int,input().split())
cps=[]
for i in range(n):
tmp=list(map(int,input().split()))
cps.append(tmp)
INF=1001001001001
dp=[INF]*(m+1)
dp[0]=0
for i in range(1,m+1):
for lst in cps:
c=lst[0]
p=lst[1]
s=lst[2:]
zr=0
now=0
for j in s:
if j==0:
zr+=1
num=p-zr
for j in s:
id=max(0,i-j)
now+=dp[id]/num
#if i==1:print("now",c,zr,now,num)
dp[i]=min(dp[i],now+c*p/num)
print(dp[m])
#print(dp)
n,m=map(int,input().split())
cps=[]
for i in range(n):
tmp=list(map(int,input().split()))
cps.append(tmp)
INF=1001001001001
dp=[INF]*(m+1)
dp[0]=0
for i in range(1,m+1):
for lst in cps:
c=lst[0]
p=lst[1]
s=lst[2:]
zr=0
now=0
for j in s:
if j==0:
zr+=1
num=p-zr
for j in s:
id=max(0,i-j)
if j>0:now+=dp[id]/num
#if i==1:print("now",c,zr,now,num)
dp[i]=min(dp[i],now+c*p/num)
print(dp[m])
#print(dp)
|
ConDefects/ConDefects/Code/abc314_e/Python/45808089
|
condefects-python_data_1108
|
N, M = map(int, input().split())
S = input()
C = list(map(int, input().split()))
ans = list(S)
Cs = [[] for _ in range(M+1)]
for i in range(N):
Cs[C[i]].append(i)
for i in range(M):
for j in range(len(Cs[i])):
ans[Cs[i][j]] = S[Cs[i][j-1]]
print(*ans, sep="")
N, M = map(int, input().split())
S = input()
C = list(map(int, input().split()))
ans = list(S)
Cs = [[] for _ in range(M+1)]
for i in range(N):
Cs[C[i]].append(i)
for i in range(1,M+1):
for j in range(len(Cs[i])):
ans[Cs[i][j]] = S[Cs[i][j-1]]
print(*ans, sep="")
|
ConDefects/ConDefects/Code/abc314_c/Python/55161312
|
condefects-python_data_1109
|
n,m=map(int,input().split())
s=input()
c=list(map(int,input().split()))
color=[[] for i in range(n+1)]
for i in range(n):
color[c[i]].append(i)
ans=[0]*n
for i in range(1,n+1):
l=len(color[i])
for j in range(l):
ans[color[i][j]]=color[i][(j+1)%l]
for i in range(n):
ans[i]=s[ans[i]]
print(*ans,sep="")
n,m=map(int,input().split())
s=input()
c=list(map(int,input().split()))
color=[[] for i in range(n+1)]
for i in range(n):
color[c[i]].append(i)
ans=[0]*n
for i in range(1,n+1):
l=len(color[i])
for j in range(l):
ans[color[i][j]]=color[i][(j-1)%l]
for i in range(n):
ans[i]=s[ans[i]]
print(*ans,sep="")
|
ConDefects/ConDefects/Code/abc314_c/Python/54238800
|
condefects-python_data_1110
|
n,m=map(int,input().split())
s=input()
c=list(map(int,input().split()))
color=[[] for i in range(m+1)]
for i in range(n):
color[c[i]].append(i)
ans=[0]*n
for i in range(1,m+1):
l=len(color[i])
for j in range(l):
ans[color[i][j]]=color[i][(j+1)%l]
for i in range(n):
ans[i]=s[ans[i]]
print(*ans,sep="")
n,m=map(int,input().split())
s=input()
c=list(map(int,input().split()))
color=[[] for i in range(m+1)]
for i in range(n):
color[c[i]].append(i)
ans=[0]*n
for i in range(1,m+1):
l=len(color[i])
for j in range(l):
ans[color[i][j]]=color[i][(j-1)%l]
for i in range(n):
ans[i]=s[ans[i]]
print(*ans,sep="")
|
ConDefects/ConDefects/Code/abc314_c/Python/54938051
|
condefects-python_data_1111
|
# ABC-314-C-Rotate_Colored_Subsequence_2
N, M = map(int, input().split())
S = input()
S = list(S)
C = list(map(int, input().split()))
# 連想配列のlist版
from collections import defaultdict
m = defaultdict(list)
for i in range(N):
m[C[i]].append([S[i], i])
print(m)
# 8 3
# apzbqrcs
# 1 2 3 1 2 2 1 2
# ↓
# {1: [['a', 0], ['b', 3], ['c', 6]], 2: [['p', 1], ['q', 4], ['r', 5], ['s', 7]], 3: [['z', 2]]}
node = [0]*N
for i in m:
for j in range(len(m[i])):
node[m[i][j][1]] = m[i][j - 1][0] # ここが良くわからない
#print(node)
print(''.join(node))
# ABC-314-C-Rotate_Colored_Subsequence_2
N, M = map(int, input().split())
S = input()
S = list(S)
C = list(map(int, input().split()))
# 連想配列のlist版
from collections import defaultdict
m = defaultdict(list)
for i in range(N):
m[C[i]].append([S[i], i])
#print(m)
# 8 3
# apzbqrcs
# 1 2 3 1 2 2 1 2
# ↓
# {1: [['a', 0], ['b', 3], ['c', 6]], 2: [['p', 1], ['q', 4], ['r', 5], ['s', 7]], 3: [['z', 2]]}
node = [0]*N
for i in m:
for j in range(len(m[i])):
node[m[i][j][1]] = m[i][j - 1][0] # ここが良くわからない
#print(node)
print(''.join(node))
|
ConDefects/ConDefects/Code/abc314_c/Python/54038840
|
condefects-python_data_1112
|
n=int(input())
l=list(input())
lacnt=[]
lbcnt=[]
a=0
b=0
for i in l:
if i == "A":
a += 1
if i == "B":
b += 1
lacnt.append(a)
lbcnt.append(b)
for i in range(1,n+1):
if lacnt[i] >= lbcnt[i]:
print("Arice")
else:
print("Bob")
n=int(input())
l=list(input())
lacnt=[]
lbcnt=[]
a=0
b=0
for i in l:
if i == "A":
a += 1
if i == "B":
b += 1
lacnt.append(a)
lbcnt.append(b)
for i in range(1,n+1):
if lacnt[i] >= lbcnt[i]:
print("Alice")
else:
print("Bob")
|
ConDefects/ConDefects/Code/agc063_a/Python/44148214
|
condefects-python_data_1113
|
n,m,k = map(int,input().split())
l = [list(map(int,input().split())) for i in range(m)]
e = list(map(int,input().split()))
dp = [float('inf')] * (n+1)
dp[1] = 0
for i in range(k):
a,b,c = l[e[i]-1]
if dp[a] != float('inf'):
dp[b] = min(dp[b],dp[a]+c)
print(dp[n])
n,m,k = map(int,input().split())
l = [list(map(int,input().split())) for i in range(m)]
e = list(map(int,input().split()))
dp = [float('inf')] * (n+1)
dp[1] = 0
for i in range(k):
a,b,c = l[e[i]-1]
if dp[a] != float('inf'):
dp[b] = min(dp[b],dp[a]+c)
print(dp[n] if dp[n] != float('inf') else -1)
|
ConDefects/ConDefects/Code/abc271_e/Python/45981596
|
condefects-python_data_1114
|
import sys
input = sys.stdin.readline
def ii(): return int(input())
def fi(): return float(input())
def si(): return input().rstrip()
def mii(): return map(int, input().split())
def fii(): return map(float, input().split())
def mii1(): return map(lambda x: int(x)-1, input().split())
def lii(): return list(map(int, input().split()))
def lii1(): return list(map(lambda x: int(x)-1, input().split()))
def lfi(): return list(map(float, input().split()))
def lsi(): return list(input().rstrip())
def lmsi(): return list(map(str, input().split()))
def iir(n): return [int(input()) for _ in range(n)]
def fir(n): return [float(input()) for _ in range(n)]
def sir(n): return [input().rstrip() for _ in range(n)]
def liir(n): return [list(map(int, input().split())) for _ in range(n)]
def lii1r(n): return [list(map(lambda x: int(x)-1, input().split())) for _ in range(n)]
def lfir(n): return [list(map(float, input().split())) for _ in range(n)]
def lsir(n): return [list(input().rstrip()) for _ in range(n)]
def lmsir(n): return [list(map(str, input().split())) for _ in range(n)]
def lii_alp(): return list(map(lambda x: ord(x)-97, input().rstrip()))
def lii_ALP(): return list(map(lambda x: ord(x)-65, input().rstrip()))
around = [[-1,0],[0,1],[1,0],[0,-1]]
from copy import deepcopy
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right, insort
from heapq import heapify, heappop, heappush
from math import ceil, floor, gcd, sin, cos, radians, log, sqrt, inf
from itertools import product, combinations, permutations, accumulate, groupby
from decimal import Decimal, ROUND_HALF_UP
sys.setrecursionlimit(10**7)
mod = 998244353
n,m = mii()
s = lii()
if n <= m+1:
ans = 1
for i in range(n):
if s[i] == 0:
ans *= m
ans %= mod
else:
continue
print(ans)
exit()
dp = [[0]*(m+2) for i in range(n)]
if s[0] == 0:
dp[0][1] = m
else:
dp[0][1] = 1
for i in range(n-1):
for j in range(1,m+2):
if s[i+1] == 0:
dp[i+1][j] += dp[i][j]*j
dp[i+1][j] %= mod
if m-j >= 1 :
dp[i+1][j+1] += dp[i][j]*(m-j)
dp[i+1][j+1] %= mod
else:
if j <= m:
dp[i+1][j+1] += dp[i][j]
dp[i+1][j+1] %= mod
ans = 0
for i in range(1,m+2):
ans += dp[-1][i]
#print(dp)
print(ans)
import sys
input = sys.stdin.readline
def ii(): return int(input())
def fi(): return float(input())
def si(): return input().rstrip()
def mii(): return map(int, input().split())
def fii(): return map(float, input().split())
def mii1(): return map(lambda x: int(x)-1, input().split())
def lii(): return list(map(int, input().split()))
def lii1(): return list(map(lambda x: int(x)-1, input().split()))
def lfi(): return list(map(float, input().split()))
def lsi(): return list(input().rstrip())
def lmsi(): return list(map(str, input().split()))
def iir(n): return [int(input()) for _ in range(n)]
def fir(n): return [float(input()) for _ in range(n)]
def sir(n): return [input().rstrip() for _ in range(n)]
def liir(n): return [list(map(int, input().split())) for _ in range(n)]
def lii1r(n): return [list(map(lambda x: int(x)-1, input().split())) for _ in range(n)]
def lfir(n): return [list(map(float, input().split())) for _ in range(n)]
def lsir(n): return [list(input().rstrip()) for _ in range(n)]
def lmsir(n): return [list(map(str, input().split())) for _ in range(n)]
def lii_alp(): return list(map(lambda x: ord(x)-97, input().rstrip()))
def lii_ALP(): return list(map(lambda x: ord(x)-65, input().rstrip()))
around = [[-1,0],[0,1],[1,0],[0,-1]]
from copy import deepcopy
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right, insort
from heapq import heapify, heappop, heappush
from math import ceil, floor, gcd, sin, cos, radians, log, sqrt, inf
from itertools import product, combinations, permutations, accumulate, groupby
from decimal import Decimal, ROUND_HALF_UP
sys.setrecursionlimit(10**7)
mod = 998244353
n,m = mii()
s = lii()
if n <= m+1:
ans = 1
for i in range(n):
if s[i] == 0:
ans *= m
ans %= mod
else:
continue
print(ans)
exit()
dp = [[0]*(m+2) for i in range(n)]
if s[0] == 0:
dp[0][1] = m
else:
dp[0][1] = 1
for i in range(n-1):
for j in range(1,m+2):
if s[i+1] == 0:
dp[i+1][j] += dp[i][j]*j
dp[i+1][j] %= mod
if m-j >= 1 :
dp[i+1][j+1] += dp[i][j]*(m-j)
dp[i+1][j+1] %= mod
else:
if j <= m:
dp[i+1][j+1] += dp[i][j]
dp[i+1][j+1] %= mod
ans = 0
for i in range(1,m+2):
ans += dp[-1][i]
#print(dp)
print(ans%mod)
|
ConDefects/ConDefects/Code/arc170_c/Python/51377709
|
condefects-python_data_1115
|
'''2023年12月17日14:57:16, ac上抄的'''
'''cf的 py3.8 没有cache'''
# from sortedcontainers import * #cf没有
# from math import * #pow出现问题 math.pow里没有mod
from heapq import *
from collections import *
from bisect import *
from itertools import *
from functools import lru_cache
from copy import *
import sys
# sys.setrecursionlimit(2147483647) #pypy mle
sys.setrecursionlimit(17483647)
def main():
# from math import gcd, floor, ceil, sqrt, isclose, pi, sin, cos, tan, asin, acos, atan, atan2, hypot, degrees, radians, log, log2, log10
# from heapq import heappush, heappop, heapify, heappushpop, heapreplace, nlargest, nsmallest
# from itertools import count, cycle, accumulate, chain, groupby, islice, product, permutations, combinations, combinations_with_replacement
inf = 3074457345618258602 # 注意一下
mod = 998244353 # ac
def py():
print("Yes") # ac严谨
def pn():
print("No")
# 按照输入的行, 一行一行的取值,每行得到的值都是列表.
il = lambda: list(map(int, input().split())) # 单个 n = i()[0] 列表 l = i() #input_list
ix = lambda: il()[0] # 单个数字 #input_x
# 列表输出数字串, 例子 [1,2,3] printout: 1 2 3
pl = lambda a: print(" ".join(map(str, a))) # print_list
en = enumerate
'''代码'''
# t = ix()
# for _ in range(t):
n,m = il()
s = il()
if m >= n-1 and n >= 2:
print(pow(m, s.count(0), mod))
return
dp = [[0]*(m+2) for _ in range(n+1)]
dp = [[0]*(n+1) for _ in range(n+1)]
# dp = [[0] * (N + 1) for _ in range(N + 1)]
# dp[0][0] = 1
# for i in range(N):
# s = S[i]
# if s == 1:
# for j in range(min(M + 1, N)):
# dp[i + 1][j + 1] += dp[i][j]
# dp[i + 1][j + 1] %= MOD99
# else:
# for j in range(min(M, N)):
# dp[i + 1][j + 1] += (dp[i][j] * (M - j)) % MOD99
# dp[i + 1][j + 1] %= MOD99
# for j in range(1, min(M + 2, N)):
# dp[i + 1][j] += (dp[i][j] * j) % MOD99
# dp[i + 1][j] %= MOD99
# # print(dp)
# print(sum(dp[-1]) % MOD99)
dp[0][0] = 1
for i,v in en(s):
if v == 1:
# for j in range(0, m+1):
for j in range(min(m+1, n)):
dp[i+1][j+1] += dp[i][j]
dp[i + 1][j + 1] %= mod
else:
# for j in range(0, m):
for j in range(min(m,n)):
dp[i+1][j+1] = (dp[i+1][j+1] + dp[i][j]*(m-j)) % mod
# for j in range(1,m+2):
for j in range(1,min(m+2, n)):
dp[i+1][j] += (dp[i][j] * j)
dp[i + 1][j] %= mod
print(dp)
print(sum(dp[-1])%mod)
'''test
10 1000
0 0 1 0 0 0 1 0 1 0
329696899
'''
''''''
main()
'''
'''
'''2023年12月17日14:57:16, ac上抄的'''
'''cf的 py3.8 没有cache'''
# from sortedcontainers import * #cf没有
# from math import * #pow出现问题 math.pow里没有mod
from heapq import *
from collections import *
from bisect import *
from itertools import *
from functools import lru_cache
from copy import *
import sys
# sys.setrecursionlimit(2147483647) #pypy mle
sys.setrecursionlimit(17483647)
def main():
# from math import gcd, floor, ceil, sqrt, isclose, pi, sin, cos, tan, asin, acos, atan, atan2, hypot, degrees, radians, log, log2, log10
# from heapq import heappush, heappop, heapify, heappushpop, heapreplace, nlargest, nsmallest
# from itertools import count, cycle, accumulate, chain, groupby, islice, product, permutations, combinations, combinations_with_replacement
inf = 3074457345618258602 # 注意一下
mod = 998244353 # ac
def py():
print("Yes") # ac严谨
def pn():
print("No")
# 按照输入的行, 一行一行的取值,每行得到的值都是列表.
il = lambda: list(map(int, input().split())) # 单个 n = i()[0] 列表 l = i() #input_list
ix = lambda: il()[0] # 单个数字 #input_x
# 列表输出数字串, 例子 [1,2,3] printout: 1 2 3
pl = lambda a: print(" ".join(map(str, a))) # print_list
en = enumerate
'''代码'''
# t = ix()
# for _ in range(t):
n,m = il()
s = il()
if m >= n-1 and n >= 2:
print(pow(m, s.count(0), mod))
return
dp = [[0]*(m+2) for _ in range(n+1)]
dp = [[0]*(n+1) for _ in range(n+1)]
# dp = [[0] * (N + 1) for _ in range(N + 1)]
# dp[0][0] = 1
# for i in range(N):
# s = S[i]
# if s == 1:
# for j in range(min(M + 1, N)):
# dp[i + 1][j + 1] += dp[i][j]
# dp[i + 1][j + 1] %= MOD99
# else:
# for j in range(min(M, N)):
# dp[i + 1][j + 1] += (dp[i][j] * (M - j)) % MOD99
# dp[i + 1][j + 1] %= MOD99
# for j in range(1, min(M + 2, N)):
# dp[i + 1][j] += (dp[i][j] * j) % MOD99
# dp[i + 1][j] %= MOD99
# # print(dp)
# print(sum(dp[-1]) % MOD99)
dp[0][0] = 1
for i,v in en(s):
if v == 1:
# for j in range(0, m+1):
for j in range(min(m+1, n)):
dp[i+1][j+1] += dp[i][j]
dp[i + 1][j + 1] %= mod
else:
# for j in range(0, m):
for j in range(min(m,n)):
dp[i+1][j+1] = (dp[i+1][j+1] + dp[i][j]*(m-j)) % mod
# for j in range(1,m+2):
for j in range(1,min(m+2, n)):
dp[i+1][j] += (dp[i][j] * j)
dp[i + 1][j] %= mod
# print(dp)
print(sum(dp[-1])%mod)
'''test
10 1000
0 0 1 0 0 0 1 0 1 0
329696899
'''
''''''
main()
'''
'''
|
ConDefects/ConDefects/Code/arc170_c/Python/50130200
|
condefects-python_data_1116
|
# import io
# import sys
# _INPUT = """\
# 10 1000000000
# 0 0 1 0 0 0 1 0 1 0
# """
# sys.stdin = io.StringIO(_INPUT)
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
from collections import defaultdict, deque
import heapq
import bisect
import math
n, m = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
if n<=m-1:
print(pow(m, A.count(0), mod))
else:
dp = [0]*(m+2)
dp[0] = 1
for a in A:
dp_ = [0]*(m+2)
if a==1:
for i in range(m+1):
dp_[i+1] = dp[i]
else:
for i in range(m+1):
dp_[i] += dp[i]*i
dp_[i] %= mod
dp_[i+1] += dp[i]*(m-i)
dp_[i+1] %= mod
# print(m-i)
dp_[m+1] += dp[m+1]*m
dp_[m+1] %= mod
dp = dp_
# print(dp)
print(sum(dp)%mod)
# import io
# import sys
# _INPUT = """\
# 10 1000000000
# 0 0 1 0 0 0 1 0 1 0
# """
# sys.stdin = io.StringIO(_INPUT)
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
from collections import defaultdict, deque
import heapq
import bisect
import math
n, m = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
if n<=m-1:
print(pow(m, A.count(0), mod))
else:
dp = [0]*(m+2)
dp[0] = 1
for a in A:
dp_ = [0]*(m+2)
if a==1:
for i in range(m+1):
dp_[i+1] = dp[i]
else:
for i in range(m+1):
dp_[i] += dp[i]*i
dp_[i] %= mod
dp_[i+1] += dp[i]*(m-i)
dp_[i+1] %= mod
# print(m-i)
dp_[m+1] += dp[m+1]*(m+1)
dp_[m+1] %= mod
dp = dp_
# print(dp)
print(sum(dp)%mod)
|
ConDefects/ConDefects/Code/arc170_c/Python/52698796
|
condefects-python_data_1117
|
MOD = 998244353
n,m = map(int, input().split())
s = list(map(int, input().split()))
if m == 0:
ok = True
for i in range(n):
if i == 0:
if s[i] == 0:
ok = False
break
else:
if s[i] == 1:
ok = False
break
if ok:
print(1)
else:
print(0)
exit()
dp = [[0 for i in range(n+1)] for i in range(n+1)]
dp[0][0] = 1
for i in range(n):
if s[i] == 0:
for j in range(n):
dp[i+1][j] += dp[i][j] * j
dp[i+1][j] %= MOD
dp[i+1][j+1] += dp[i][j] * max(m-j, 0)
dp[i+1][j+1] %= MOD
dp[i+1][n] += dp[i][n] * n
dp[i+1][n] %= MOD
else:
for j in range(n):
dp[i+1][j+1] += dp[i][j]
# print(dp)
ans = 0
for j in range(1,n+1):
ans += dp[n][j]
ans %= MOD
print(ans)
MOD = 998244353
n,m = map(int, input().split())
s = list(map(int, input().split()))
if m == 0:
ok = True
for i in range(n):
if i == 0:
if s[i] == 0:
ok = False
break
else:
if s[i] == 1:
ok = False
break
if ok:
print(1)
else:
print(0)
exit()
dp = [[0 for i in range(n+1)] for i in range(n+1)]
dp[0][0] = 1
for i in range(n):
if s[i] == 0:
for j in range(n):
dp[i+1][j] += dp[i][j] * j
dp[i+1][j] %= MOD
dp[i+1][j+1] += dp[i][j] * max(m-j, 0)
dp[i+1][j+1] %= MOD
dp[i+1][n] += dp[i][n] * n
dp[i+1][n] %= MOD
else:
for j in range(n):
if j == (m+1):
break
dp[i+1][j+1] += dp[i][j]
# print(dp)
ans = 0
for j in range(1,n+1):
ans += dp[n][j]
ans %= MOD
print(ans)
|
ConDefects/ConDefects/Code/arc170_c/Python/49600906
|
condefects-python_data_1118
|
############################################################################################
import bisect,collections,copy,heapq,itertools,math,string,sys,queue,time,random
from decimal import Decimal
def I(): return input()
def IS(): return input().split()
def II(): return int(input())
def IIS(): return list(map(int,input().split()))
def LIIS(): return list(map(int,input().split()))
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
import math
def prime_numbers(n):
prime = [True for i in range(n+1)]
prime[0] = False
prime[1] = False
sqrt_n = math.ceil(math.sqrt(n))
for i in range(2, sqrt_n):
if prime[i]:
for j in range(2*i, n+1, i):
prime[j] = False
numbers=[]
for i in range(2,n+1):
if prime[i]:
numbers.append(i)
return numbers
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
INF=10**18
MOD=998244353
MOD2=10**9+7
#sys.setrecursionlimit(500005)
def bit_count(x):
return bin(x).count("1")
def yesno(f):
if f:print("Yes")
else:print("No")
####################################################
n,m=IIS()
li=[-1]*(m+1)
idx=1
st=set()
for i in range(n):
a,b=IIS()
li[a]=b
st.add(b)
idx=max(idx,a)
cnt=[]
cnt.append((m-idx+1,m))
for i in range(1,m):
if i in st:break
idx=max(idx,li[i])
idx=max(i+1,idx)
cnt.append((m-idx+1,m-i))
ans=[0]*(m+1)
for i,j in cnt:
ans[j]+=1
ans[j-i]-=1
cnt=0
for i in range(1,m+1)[::-1]:
cnt+=ans[i]
ans[i]=cnt
print(*ans[1:])
############################################################################################
import bisect,collections,copy,heapq,itertools,math,string,sys,queue,time,random
from decimal import Decimal
def I(): return input()
def IS(): return input().split()
def II(): return int(input())
def IIS(): return list(map(int,input().split()))
def LIIS(): return list(map(int,input().split()))
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
import math
def prime_numbers(n):
prime = [True for i in range(n+1)]
prime[0] = False
prime[1] = False
sqrt_n = math.ceil(math.sqrt(n))
for i in range(2, sqrt_n):
if prime[i]:
for j in range(2*i, n+1, i):
prime[j] = False
numbers=[]
for i in range(2,n+1):
if prime[i]:
numbers.append(i)
return numbers
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
INF=10**18
MOD=998244353
MOD2=10**9+7
#sys.setrecursionlimit(500005)
def bit_count(x):
return bin(x).count("1")
def yesno(f):
if f:print("Yes")
else:print("No")
####################################################
n,m=IIS()
li=[-1]*(m+1)
idx=1
st=set()
for i in range(n):
a,b=IIS()
li[a]=max(li[a],b)
st.add(b)
idx=max(idx,a)
cnt=[]
cnt.append((m-idx+1,m))
for i in range(1,m):
if i in st:break
idx=max(idx,li[i])
idx=max(i+1,idx)
cnt.append((m-idx+1,m-i))
ans=[0]*(m+1)
for i,j in cnt:
ans[j]+=1
ans[j-i]-=1
cnt=0
for i in range(1,m+1)[::-1]:
cnt+=ans[i]
ans[i]=cnt
print(*ans[1:])
|
ConDefects/ConDefects/Code/abc260_e/Python/44419168
|
condefects-python_data_1119
|
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def f(u, v, w):
return u << 40 ^ v << 20 ^ w
def get_segment0(s, t):
s, t = s ^ l1, t ^ l1
while s <= t:
if s & 1:
yield s
s += 1
s >>= 1
if not t & 1:
yield t
t -= 1
t >>= 1
def get_segment(s, t):
s, t = s ^ l1, t ^ l1
u, v = [], []
while s <= t:
if s & 1:
u.append(s)
s += 1
s >>= 1
if not t & 1:
v.append(t)
t -= 1
t >>= 1
return u + v[::-1]
def update():
i = 4
while i:
j = i >> 2
if tree[i]:
tree[i ^ 1], tree[i ^ 2] = tree[i ^ 2], tree[i ^ 1]
if not j & l1:
tree[i << 1] ^= 1
tree[i << 1 ^ 4] ^= 1
tree[i] = 0
if j & l1:
nx = j >> 1 << 2
elif color[j << 1]:
nx = i << 1
elif color[j << 1 ^ 1]:
nx = i << 1 ^ 4
else:
nx = j >> 1 << 2
if nx < i:
color[j] = 0
if not j & l1:
j, k = i << 1, i << 1 ^ 4
sj, sk = tree[j ^ 3], tree[k ^ 3]
for l in x:
u = tree[j ^ l] if not tree[j] else tree[j ^ l ^ 3]
v = tree[k ^ l] if not tree[k] else tree[k ^ l ^ 3]
lj, rj, mj = u >> 40, (u >> 20) & 0xfffff, u & 0xfffff
lk, rk, mk = v >> 40, (v >> 20) & 0xfffff, v & 0xfffff
mi = max(mj, mk, rj + lk)
li = lj if lj ^ sj else lj + lk
ri = rk if rk ^ sk else rk + rj
tree[i ^ l] = f(li, ri, mi)
i = nx
return
def get_ans():
l0, r0, m0, s0 = 0, 0, 0, 0
for i in seg:
u = tree[i << 2 ^ 2] if not tree[i << 2] else tree[i << 2 ^ 1]
li, ri, mi, si = u >> 40, (u >> 20) & 0xfffff, u & 0xfffff, tree[i << 2 ^ 3]
m0 = max(m0, mi, r0 + li)
l0 = l0 if l0 ^ s0 else l0 + li
r0 = ri if ri ^ si else ri + r0
s0 += si
return m0
n, m = map(int, input().split())
s = list(input().rstrip())
s = [i & 1 for i in s]
x = [1, 2]
y = [0] * (n + 1)
ans = []
color = [0] * (n << 3)
color[0] = 1
for v in range((m >> 16) + min(m & 0xffff, 1)):
u = set([0, n])
q0 = [0] * (1 << 16)
for i in range(v << 16, min((v + 1) << 16, m)):
t, l, r = map(int, input().split())
u.add(l - 1)
u.add(r)
q0[i & 0xff] = f(t, l - 1, r)
u = list(u)
u.sort()
z = [0] * len(u)
l1 = pow(2, (len(u) + 1).bit_length())
l2 = 2 * l1
tree = [0] * (l2 << 2)
for i in range(len(u) - 1):
y[u[i]] = i
now, c, m0, m1 = s[u[i]], 0, 0, 0
l0, l1, r0, r1 = 0, 0, 0, 0
for j in range(u[i], u[i + 1]):
if s[j] ^ now:
if l0 == l1 == 0:
if not now:
l0 = c
else:
l1 = c
if not now and m0 < c:
m0 = c
elif now and m1 < c:
m1 = c
c = 0
now ^= 1
c += 1
if not now:
r0, m0 = c, max(m0, c)
else:
r1, m1 = c, max(m1, c)
if l0 == l1 == 0:
l0, l1 = r0, r1
k = (i ^ (l2 >> 1)) << 2
tree[k ^ 1], tree[k ^ 2], tree[k ^ 3] = f(l0, r0, m0), f(l1, r1, m1), u[i + 1] - u[i]
y[n] = len(u) - 1
l1 = l2 >> 1
for i in range((l1 - 1) << 2, 0, -4):
j, k = i << 1, i << 1 ^ 4
sj, sk = tree[j ^ 3], tree[k ^ 3]
tree[i ^ 3] = sj + sk
for l in x:
tj, tk = tree[j ^ l], tree[k ^ l]
lj, rj, mj = tj >> 40, (tj >> 20) & 0xfffff, tj & 0xfffff
lk, rk, mk = tk >> 40, (tk >> 20) & 0xfffff, tk & 0xfffff
mi = max(mj, mk, rj + lk)
li = lj if lj ^ sj else lj + lk
ri = rk if rk ^ sk else rk + rj
tree[i ^ l] = f(li, ri, mi)
u0 = set()
for q1 in q0:
if not q1:
break
l, r = y[(q1 >> 20) & 0xfffff], y[q1 & 0xfffff]
if q1 >> 40 == 1:
if not l in u0:
u0.add(l)
else:
u0.remove(l)
if not r in u0:
u0.add(r)
else:
u0.remove(r)
z[l] ^= 1
z[r] ^= 1
else:
u0 = list(u0)
u0.sort()
for i in range(len(u0) >> 1):
for j in get_segment0(u0[2 * i], u0[2 * i + 1] - 1):
tree[j << 2] ^= 1
k = j >> 1
while not color[k]:
color[k] = 1
k >>= 1
seg = get_segment(l, r - 1)
for j in seg:
k = j
while not color[k]:
color[k] = 1
k >>= 1
u0 = set()
update()
ans0 = get_ans()
ans.append(ans0)
for i in range(len(u) - 1):
if not z[i]:
continue
for j in range(u[i], u[i + 1]):
s[j] ^= 1
z[i + 1] ^= 1
sys.stdout.write("\n".join(map(str, ans)))
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def f(u, v, w):
return u << 40 ^ v << 20 ^ w
def get_segment0(s, t):
s, t = s ^ l1, t ^ l1
while s <= t:
if s & 1:
yield s
s += 1
s >>= 1
if not t & 1:
yield t
t -= 1
t >>= 1
def get_segment(s, t):
s, t = s ^ l1, t ^ l1
u, v = [], []
while s <= t:
if s & 1:
u.append(s)
s += 1
s >>= 1
if not t & 1:
v.append(t)
t -= 1
t >>= 1
return u + v[::-1]
def update():
i = 4
while i:
j = i >> 2
if tree[i]:
tree[i ^ 1], tree[i ^ 2] = tree[i ^ 2], tree[i ^ 1]
if not j & l1:
tree[i << 1] ^= 1
tree[i << 1 ^ 4] ^= 1
tree[i] = 0
if j & l1:
nx = j >> 1 << 2
elif color[j << 1]:
nx = i << 1
elif color[j << 1 ^ 1]:
nx = i << 1 ^ 4
else:
nx = j >> 1 << 2
if nx < i:
color[j] = 0
if not j & l1:
j, k = i << 1, i << 1 ^ 4
sj, sk = tree[j ^ 3], tree[k ^ 3]
for l in x:
u = tree[j ^ l] if not tree[j] else tree[j ^ l ^ 3]
v = tree[k ^ l] if not tree[k] else tree[k ^ l ^ 3]
lj, rj, mj = u >> 40, (u >> 20) & 0xfffff, u & 0xfffff
lk, rk, mk = v >> 40, (v >> 20) & 0xfffff, v & 0xfffff
mi = max(mj, mk, rj + lk)
li = lj if lj ^ sj else lj + lk
ri = rk if rk ^ sk else rk + rj
tree[i ^ l] = f(li, ri, mi)
i = nx
return
def get_ans():
l0, r0, m0, s0 = 0, 0, 0, 0
for i in seg:
u = tree[i << 2 ^ 2] if not tree[i << 2] else tree[i << 2 ^ 1]
li, ri, mi, si = u >> 40, (u >> 20) & 0xfffff, u & 0xfffff, tree[i << 2 ^ 3]
m0 = max(m0, mi, r0 + li)
l0 = l0 if l0 ^ s0 else l0 + li
r0 = ri if ri ^ si else ri + r0
s0 += si
return m0
n, m = map(int, input().split())
s = list(input().rstrip())
s = [i & 1 for i in s]
x = [1, 2]
y = [0] * (n + 1)
ans = []
color = [0] * (n << 3)
color[0] = 1
for v in range((m >> 16) + min(m & 0xffff, 1)):
u = set([0, n])
q0 = [0] * (1 << 16)
for i in range(v << 16, min((v + 1) << 16, m)):
t, l, r = map(int, input().split())
u.add(l - 1)
u.add(r)
q0[i & 0xffff] = f(t, l - 1, r)
u = list(u)
u.sort()
z = [0] * len(u)
l1 = pow(2, (len(u) + 1).bit_length())
l2 = 2 * l1
tree = [0] * (l2 << 2)
for i in range(len(u) - 1):
y[u[i]] = i
now, c, m0, m1 = s[u[i]], 0, 0, 0
l0, l1, r0, r1 = 0, 0, 0, 0
for j in range(u[i], u[i + 1]):
if s[j] ^ now:
if l0 == l1 == 0:
if not now:
l0 = c
else:
l1 = c
if not now and m0 < c:
m0 = c
elif now and m1 < c:
m1 = c
c = 0
now ^= 1
c += 1
if not now:
r0, m0 = c, max(m0, c)
else:
r1, m1 = c, max(m1, c)
if l0 == l1 == 0:
l0, l1 = r0, r1
k = (i ^ (l2 >> 1)) << 2
tree[k ^ 1], tree[k ^ 2], tree[k ^ 3] = f(l0, r0, m0), f(l1, r1, m1), u[i + 1] - u[i]
y[n] = len(u) - 1
l1 = l2 >> 1
for i in range((l1 - 1) << 2, 0, -4):
j, k = i << 1, i << 1 ^ 4
sj, sk = tree[j ^ 3], tree[k ^ 3]
tree[i ^ 3] = sj + sk
for l in x:
tj, tk = tree[j ^ l], tree[k ^ l]
lj, rj, mj = tj >> 40, (tj >> 20) & 0xfffff, tj & 0xfffff
lk, rk, mk = tk >> 40, (tk >> 20) & 0xfffff, tk & 0xfffff
mi = max(mj, mk, rj + lk)
li = lj if lj ^ sj else lj + lk
ri = rk if rk ^ sk else rk + rj
tree[i ^ l] = f(li, ri, mi)
u0 = set()
for q1 in q0:
if not q1:
break
l, r = y[(q1 >> 20) & 0xfffff], y[q1 & 0xfffff]
if q1 >> 40 == 1:
if not l in u0:
u0.add(l)
else:
u0.remove(l)
if not r in u0:
u0.add(r)
else:
u0.remove(r)
z[l] ^= 1
z[r] ^= 1
else:
u0 = list(u0)
u0.sort()
for i in range(len(u0) >> 1):
for j in get_segment0(u0[2 * i], u0[2 * i + 1] - 1):
tree[j << 2] ^= 1
k = j >> 1
while not color[k]:
color[k] = 1
k >>= 1
seg = get_segment(l, r - 1)
for j in seg:
k = j
while not color[k]:
color[k] = 1
k >>= 1
u0 = set()
update()
ans0 = get_ans()
ans.append(ans0)
for i in range(len(u) - 1):
if not z[i]:
continue
for j in range(u[i], u[i + 1]):
s[j] ^= 1
z[i + 1] ^= 1
sys.stdout.write("\n".join(map(str, ans)))
|
ConDefects/ConDefects/Code/abc322_f/Python/52703822
|
condefects-python_data_1120
|
import os
import sys
import numpy as np
def solve(inp):
def mod_pow(x, a, MOD):
ret = 1
cur = x
while a > 0:
if a & 1:
ret = ret * cur % MOD
cur = cur * cur % MOD
a >>= 1
return ret
def prepare_factorials(n, MOD):
factorials = np.ones(n + 1, np.int64)
for m in range(1, n + 1):
factorials[m] = factorials[m - 1] * m % MOD
inversions = np.ones(n + 1, np.int64)
inversions[n] = mod_pow(factorials[n], MOD - 2, MOD)
for m in range(n, 1, -1):
inversions[m - 1] = inversions[m] * m % MOD
return factorials, inversions
n, m = inp
MOD = 998244353
INV2 = 499122177
facts, finvs = prepare_factorials(n * n, MOD)
def ncr(n, r):
if n < r:
return 0
return facts[n] * finvs[r] % MOD * finvs[n - r] % MOD
n2 = min(m, (n // 2) * (n - n // 2))
# i 頂点 j 辺 の単純二部グラフ、各頂点が属するグループも区別
dp1 = np.zeros((n + 1, n2 + 1), np.int64)
# i 頂点 j 辺 の単純連結二部グラフ、各頂点が属するグループも区別
dp2 = np.zeros((n + 1, n2 + 1), np.int64)
dp2[1, 0] = 2
for i in range(1, n + 1):
dp1[i, 0] = mod_pow(2, i, MOD)
for j in range(1, n2 + 1):
tmp = 0
for k in range(1, i):
tmp += ncr(i, k) * ncr(k * (i - k), j) % MOD
dp1[i, j] = tmp
for k in range(1, i):
for l in range(j + 1):
tmp -= dp2[k, l] * dp1[i - k, j - l] % MOD * ncr(i - 1, k - 1)
tmp %= MOD
dp2[i, j] = tmp % MOD
# i 頂点 j 辺 の単純連結二部グラフ、各頂点が属するグループは区別しない場合に変換
dp2 *= INV2
dp2 %= MOD
# i 頂点 j 辺 の単純二部グラフ、各頂点が属するグループは区別しない
# 残っている最も頂点番号の小さい頂点は必ず選ぶようにして、追加していく
dp3 = np.zeros((n + 1, n2 + 1), np.int64)
dp3[0, 0] = 1
for i in range(n): # 遷移元 i
for j in range(n2 + 1): # 遷移元 j
if dp3[i, j] == 0:
continue
for k in range(1, n - i + 1): # 何個選ぶか
for l in range(n2 - j + 1): # 何辺選ぶか
dp3[i + k, j + l] += dp3[i, j] * dp2[k, l] % MOD * ncr(n - i - 1, k - 1)
dp3[i + k, j + l] %= MOD
# i 個の無向辺を少なくとも全て1つ以上選びつつ、区別できる M 個の主体が、向きを決めてそれぞれ1つずつ選ぶ方法の個数
dp4 = np.zeros(n2 + 1, np.int64)
for i in range(1, n2 + 1):
res = 0
coef = 1
for j in range(i, 0, -1):
res += coef * mod_pow(j * 2, m, MOD) * ncr(i, j)
res %= MOD
coef *= -1
dp4[i] = res
ans = 0
for j in range(1, n2 + 1):
ans += dp4[j] * dp3[n, j]
ans %= MOD
return ans
SIGNATURE = '(i8[:],)'
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', SIGNATURE)(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit(SIGNATURE, cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print(ans)
import os
import sys
import numpy as np
def solve(inp):
def mod_pow(x, a, MOD):
ret = 1
cur = x
while a > 0:
if a & 1:
ret = ret * cur % MOD
cur = cur * cur % MOD
a >>= 1
return ret
def prepare_factorials(n, MOD):
factorials = np.ones(n + 1, np.int64)
for m in range(1, n + 1):
factorials[m] = factorials[m - 1] * m % MOD
inversions = np.ones(n + 1, np.int64)
inversions[n] = mod_pow(factorials[n], MOD - 2, MOD)
for m in range(n, 1, -1):
inversions[m - 1] = inversions[m] * m % MOD
return factorials, inversions
n, m = inp
MOD = 998244353
INV2 = 499122177
facts, finvs = prepare_factorials(n * n, MOD)
def ncr(n, r):
if n < r:
return 0
return facts[n] * finvs[r] % MOD * finvs[n - r] % MOD
n2 = min(m, (n // 2) * (n - n // 2))
# i 頂点 j 辺 の単純二部グラフ、各頂点が属するグループも区別
dp1 = np.zeros((n + 1, n2 + 1), np.int64)
# i 頂点 j 辺 の単純連結二部グラフ、各頂点が属するグループも区別
dp2 = np.zeros((n + 1, n2 + 1), np.int64)
dp2[1, 0] = 2
for i in range(1, n + 1):
dp1[i, 0] = mod_pow(2, i, MOD)
for j in range(1, n2 + 1):
tmp = 0
for k in range(1, i):
tmp += ncr(i, k) * ncr(k * (i - k), j) % MOD
dp1[i, j] = tmp % MOD
for k in range(1, i):
for l in range(j + 1):
tmp -= dp2[k, l] * dp1[i - k, j - l] % MOD * ncr(i - 1, k - 1)
tmp %= MOD
dp2[i, j] = tmp % MOD
# i 頂点 j 辺 の単純連結二部グラフ、各頂点が属するグループは区別しない場合に変換
dp2 *= INV2
dp2 %= MOD
# i 頂点 j 辺 の単純二部グラフ、各頂点が属するグループは区別しない
# 残っている最も頂点番号の小さい頂点は必ず選ぶようにして、追加していく
dp3 = np.zeros((n + 1, n2 + 1), np.int64)
dp3[0, 0] = 1
for i in range(n): # 遷移元 i
for j in range(n2 + 1): # 遷移元 j
if dp3[i, j] == 0:
continue
for k in range(1, n - i + 1): # 何個選ぶか
for l in range(n2 - j + 1): # 何辺選ぶか
dp3[i + k, j + l] += dp3[i, j] * dp2[k, l] % MOD * ncr(n - i - 1, k - 1)
dp3[i + k, j + l] %= MOD
# i 個の無向辺を少なくとも全て1つ以上選びつつ、区別できる M 個の主体が、向きを決めてそれぞれ1つずつ選ぶ方法の個数
dp4 = np.zeros(n2 + 1, np.int64)
for i in range(1, n2 + 1):
res = 0
coef = 1
for j in range(i, 0, -1):
res += coef * mod_pow(j * 2, m, MOD) * ncr(i, j)
res %= MOD
coef *= -1
dp4[i] = res
ans = 0
for j in range(1, n2 + 1):
ans += dp4[j] * dp3[n, j]
ans %= MOD
return ans
SIGNATURE = '(i8[:],)'
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', SIGNATURE)(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit(SIGNATURE, cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print(ans)
|
ConDefects/ConDefects/Code/abc327_g/Python/47668625
|
condefects-python_data_1121
|
class FenwickTreeInjectable:
def __init__(self, n, identity_factory, func):
self.size = n
self.tree = [identity_factory() for _ in range(n + 1)]
self.func = func
self.idf = identity_factory
self.depth = n.bit_length()
def add(self, i, x):
i += 1
tree = self.tree
func = self.func
while i <= self.size:
tree[i] = func(tree[i], x)
i += i & -i
def sum(self, i):
i += 1
s = self.idf()
tree = self.tree
func = self.func
while i > 0:
s = func(s, tree[i])
i -= i & -i
return s
def lower_bound(self, x, lt):
"""
累積和がx以上になる最小のindexと、その直前までの累積和
:param lt: lt(a, b) で a < b ならTrueを返す関数
"""
total = self.idf()
pos = 0
tree = self.tree
func = self.func
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k > self.size:
continue
new_total = func(total, tree[k])
if lt(new_total, x):
total = new_total
pos += 1 << i
return pos + 1, total
def debug_print(self):
prev = 0
arr = []
for i in range(self.size):
curr = self.sum(i)
arr.append(curr - prev)
prev = curr
print(arr)
n, k, c = list(map(int, input().split()))
MOD = 998244353
# DP[i] = A[i] 以降まで決まった数列で、最後の色の連続の左端indexが i であるものの個数
fwt = FenwickTreeInjectable(n + 1, int, lambda x, y: (x + y) % MOD)
# 0→i の遷移: iに限らず c*(c-1) （特殊なのでDF配列では管理せず外側で持つ）
# (j=1～i-k+1)→i の遷移: DP[j]*(c-1)
# (j=i-k+2～i-1)→i の遷移: DP[j]*1
for i in range(1, n):
s = fwt.sum(i)
t = fwt.sum(i - k + 1) if i - k + 1 > 0 else 0
s -= t
tmp = s + t * (c - 1) + c * (c - 1)
fwt.add(i, tmp % MOD)
ans = fwt.sum(n) + c
print(ans)
class FenwickTreeInjectable:
def __init__(self, n, identity_factory, func):
self.size = n
self.tree = [identity_factory() for _ in range(n + 1)]
self.func = func
self.idf = identity_factory
self.depth = n.bit_length()
def add(self, i, x):
i += 1
tree = self.tree
func = self.func
while i <= self.size:
tree[i] = func(tree[i], x)
i += i & -i
def sum(self, i):
i += 1
s = self.idf()
tree = self.tree
func = self.func
while i > 0:
s = func(s, tree[i])
i -= i & -i
return s
def lower_bound(self, x, lt):
"""
累積和がx以上になる最小のindexと、その直前までの累積和
:param lt: lt(a, b) で a < b ならTrueを返す関数
"""
total = self.idf()
pos = 0
tree = self.tree
func = self.func
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k > self.size:
continue
new_total = func(total, tree[k])
if lt(new_total, x):
total = new_total
pos += 1 << i
return pos + 1, total
def debug_print(self):
prev = 0
arr = []
for i in range(self.size):
curr = self.sum(i)
arr.append(curr - prev)
prev = curr
print(arr)
n, k, c = list(map(int, input().split()))
MOD = 998244353
# DP[i] = A[i] 以降まで決まった数列で、最後の色の連続の左端indexが i であるものの個数
fwt = FenwickTreeInjectable(n + 1, int, lambda x, y: (x + y) % MOD)
# 0→i の遷移: iに限らず c*(c-1) （特殊なのでDF配列では管理せず外側で持つ）
# (j=1～i-k+1)→i の遷移: DP[j]*(c-1)
# (j=i-k+2～i-1)→i の遷移: DP[j]*1
for i in range(1, n):
s = fwt.sum(i)
t = fwt.sum(i - k + 1) if i - k + 1 > 0 else 0
s -= t
tmp = s + t * (c - 1) + c * (c - 1)
fwt.add(i, tmp % MOD)
ans = (fwt.sum(n) + c) % MOD
print(ans)
|
ConDefects/ConDefects/Code/abc279_g/Python/37231890
|
condefects-python_data_1122
|
n, k, c = list(map(int, input().split()))
MOD = 998244353
# DP[i] = A[i] 以降まで決まった数列で、最後の色の連続の左端indexが i であるものの個数
dp = [0]
# 0→i の遷移: iに限らず c*(c-1) （特殊なのでDF配列では管理せず外側で持つ）
# (j=1～i-k+1)→i の遷移: DP[j]*(c-1)
# (j=i-k+2～i-1)→i の遷移: DP[j]*1
for i in range(1, n):
s = dp[-1]
t = dp[i - k + 1] if i - k + 1 > 0 else 0
s -= t
tmp = s + t * (c - 1) + c * (c - 1)
dp.append((dp[-1] + tmp) % MOD)
ans = dp[-1] + c
print(ans)
n, k, c = list(map(int, input().split()))
MOD = 998244353
# DP[i] = A[i] 以降まで決まった数列で、最後の色の連続の左端indexが i であるものの個数
dp = [0]
# 0→i の遷移: iに限らず c*(c-1) （特殊なのでDF配列では管理せず外側で持つ）
# (j=1～i-k+1)→i の遷移: DP[j]*(c-1)
# (j=i-k+2～i-1)→i の遷移: DP[j]*1
for i in range(1, n):
s = dp[-1]
t = dp[i - k + 1] if i - k + 1 > 0 else 0
s -= t
tmp = s + t * (c - 1) + c * (c - 1)
dp.append((dp[-1] + tmp) % MOD)
ans = (dp[-1] + c) % MOD
print(ans)
|
ConDefects/ConDefects/Code/abc279_g/Python/37231957
|
condefects-python_data_1123
|
from sortedcontainers import SortedList
N, K, Q = map(int, input().split())
XY = [tuple(map(int, input().split())) for _ in range(Q)]
A = [0] * N
lows = SortedList([0] * (N - K))
highs = SortedList([0] * K)
high_sum = 0
answers = []
for x, y in XY:
x -= 1
prev = A[x]
A[x] = y
if prev in lows:
lows.discard(prev)
lows.add(y)
else:
highs.discard(A[x])
highs.add(y)
high_sum += y - prev
if lows and highs:
max_lows = lows[-1]
min_highs = highs[0]
if max_lows > min_highs:
high_sum += max_lows - min_highs
lows.discard(max_lows)
lows.add(min_highs)
highs.discard(min_highs)
highs.add(max_lows)
answers.append(high_sum)
print(*answers, sep="\n")
from sortedcontainers import SortedList
N, K, Q = map(int, input().split())
XY = [tuple(map(int, input().split())) for _ in range(Q)]
A = [0] * N
lows = SortedList([0] * (N - K))
highs = SortedList([0] * K)
high_sum = 0
answers = []
for x, y in XY:
x -= 1
prev = A[x]
A[x] = y
if prev in lows:
lows.discard(prev)
lows.add(y)
else:
highs.discard(prev)
highs.add(y)
high_sum += y - prev
if lows and highs:
max_lows = lows[-1]
min_highs = highs[0]
if max_lows > min_highs:
high_sum += max_lows - min_highs
lows.discard(max_lows)
lows.add(min_highs)
highs.discard(min_highs)
highs.add(max_lows)
answers.append(high_sum)
print(*answers, sep="\n")
|
ConDefects/ConDefects/Code/abc306_e/Python/46138524
|
condefects-python_data_1124
|
MOD = 998244353
N = int(input())
A = list(map(lambda x:int(x)-1, input().split()))
memo = [[] for _ in range(N)]
#print(A)
for i in range(N):
if A[i] < i:
exit(print(0))
memo[A[i]].append(i)
#print(memo)
st = set(range(N))
y = []
for i in range(N):
if len(memo[i]):
y.append(i)
for j in range(1,len(memo[i])):
st.remove(memo[i][j])
x = sorted(st)
#print(x,y)
# https://atcoder.jp/contests/arc171/submissions/50005878
idx = 0
m = len(x)
ans = 1
for i in range(m):
while idx < m and x[idx] <= y[i]:
idx += 1
ans *= (idx - i)
ans %= MOD
print(ans)
MOD = 998244353
N = int(input())
A = list(map(lambda x:int(x)-1, input().split()))
memo = [[] for _ in range(N)]
#print(A)
for i in range(N):
if A[i] < i or A[A[i]] != A[i]:
exit(print(0))
memo[A[i]].append(i)
#print(memo)
st = set(range(N))
y = []
for i in range(N):
if len(memo[i]):
y.append(i)
for j in range(1,len(memo[i])):
st.remove(memo[i][j])
x = sorted(st)
#print(x,y)
# https://atcoder.jp/contests/arc171/submissions/50005878
idx = 0
m = len(x)
ans = 1
for i in range(m):
while idx < m and x[idx] <= y[i]:
idx += 1
ans *= (idx - i)
ans %= MOD
print(ans)
|
ConDefects/ConDefects/Code/arc171_b/Python/50136893
|
condefects-python_data_1125
|
#!/usr/bin/env python3
import sys
import math
import bisect
from heapq import heapify, heappop, heappush
from collections import deque, defaultdict, Counter
from functools import lru_cache
from fractions import Fraction
from itertools import accumulate, combinations, permutations, product
from sortedcontainers import SortedSet, SortedList, SortedDict
mod = 998244353
n = int(input())
a = list(map(lambda x: int(x)-1, input().split()))
m = 998244353
for i in range(n):
if a[i]<i :
print(0)
exit()
cnt = 0
ans = 1
s = set()
for i in range(n):
if a[i] not in s:
s.add(a[i])
cnt += 1
if i == a[i]:
ans *= cnt
ans %= m
cnt -= 1
print(ans)
#!/usr/bin/env python3
import sys
import math
import bisect
from heapq import heapify, heappop, heappush
from collections import deque, defaultdict, Counter
from functools import lru_cache
from fractions import Fraction
from itertools import accumulate, combinations, permutations, product
from sortedcontainers import SortedSet, SortedList, SortedDict
mod = 998244353
n = int(input())
a = list(map(lambda x: int(x)-1, input().split()))
m = 998244353
for i in range(n):
if a[i]<i or a[a[i]] != a[i]:
print(0)
exit()
cnt = 0
ans = 1
s = set()
for i in range(n):
if a[i] not in s:
s.add(a[i])
cnt += 1
if i == a[i]:
ans *= cnt
ans %= m
cnt -= 1
print(ans)
|
ConDefects/ConDefects/Code/arc171_b/Python/50078211
|
condefects-python_data_1126
|
def main():
# write code here.
N = II()
A = LM()
#最終的に i になる数字たち group[i]
group = [[] for _ in range(N+1)]
for i in range(N):
if A[i] < i+1:
print(0)
exit()
group[A[i]].append(i+1)
bigs = []
smalls = []
for i in range(1,N+1):
if group[i]:
bigs.append(i)
smalls.append(min(group[i]))
smalls.sort()
bigs.sort()
L = len(bigs)
assert len(smalls)==len(bigs)==len(set(smalls))==len(set(bigs))
ans = 1
for i in range(L):
assert BSR(smalls, bigs[i]) - i > 0
ans *= (BSR(smalls, bigs[i]) - i) % MOD
ans %= MOD
print(ans%MOD)
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(bound_included1, bound_included2, coeff1, coeff0):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
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)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
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 __eq__(self, other) -> bool:
return list(self) == list(other)
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 _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(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, b, i = self._position(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.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= 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
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
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 __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= 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
class UnionFind:
"""
二次元の時は、初期化時に (H,W) のように二次元配列の高さと幅を入力.
引数一個の root とか size は (r,c) みたいに.
引数二個の unite とか same は ((ra,ca),(rb,cb)) みたいに引数入れる.
"""
def __init__(self,*N):
if not isinstance(N[0],int):
N = N[0]
if len(N)==1:
N=N[0]
elif len(N)==2:
self.H, self.W = N[0], N[1]
N = self.H * self.W
self.par = [ i for i in range(N) ]
self.tree_size = [ 1 for i in range(N) ]
def root(self,*x):
x = self._dimCheck1(x)
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
self.par[rx] = ry
self.tree_size[ry] += self.tree_size[rx]
def same(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
return rx == ry
def size(self,*x):
x = self._dimCheck1(x)
rx = self.root(x)
return self.tree_size[rx]
def _dimCheck1(self,x):
if len(x)==1: return x[0]
if len(x)==2: return x[0]*self.W + x[1]
def _dimCheck2(self,xy):
if isinstance(xy[0],int): return xy[0],xy[1]
return xy[0][0]*self.W + xy[0][1], xy[1][0]*self.W + xy[1][1]
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main()
def main():
# write code here.
N = II()
A = LM()
#最終的に i になる数字たち group[i]
group = [[] for _ in range(N+1)]
for i in range(N):
if A[i] < i+1 or group[i+1] and A[i] != i+1:
print(0)
exit()
group[A[i]].append(i+1)
bigs = []
smalls = []
for i in range(1,N+1):
if group[i]:
bigs.append(i)
smalls.append(min(group[i]))
smalls.sort()
bigs.sort()
L = len(bigs)
assert len(smalls)==len(bigs)==len(set(smalls))==len(set(bigs))
ans = 1
for i in range(L):
assert BSR(smalls, bigs[i]) - i > 0
ans *= (BSR(smalls, bigs[i]) - i) % MOD
ans %= MOD
print(ans%MOD)
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(bound_included1, bound_included2, coeff1, coeff0):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
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)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
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 __eq__(self, other) -> bool:
return list(self) == list(other)
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 _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(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, b, i = self._position(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.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= 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
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
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 __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= 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
class UnionFind:
"""
二次元の時は、初期化時に (H,W) のように二次元配列の高さと幅を入力.
引数一個の root とか size は (r,c) みたいに.
引数二個の unite とか same は ((ra,ca),(rb,cb)) みたいに引数入れる.
"""
def __init__(self,*N):
if not isinstance(N[0],int):
N = N[0]
if len(N)==1:
N=N[0]
elif len(N)==2:
self.H, self.W = N[0], N[1]
N = self.H * self.W
self.par = [ i for i in range(N) ]
self.tree_size = [ 1 for i in range(N) ]
def root(self,*x):
x = self._dimCheck1(x)
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
self.par[rx] = ry
self.tree_size[ry] += self.tree_size[rx]
def same(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
return rx == ry
def size(self,*x):
x = self._dimCheck1(x)
rx = self.root(x)
return self.tree_size[rx]
def _dimCheck1(self,x):
if len(x)==1: return x[0]
if len(x)==2: return x[0]*self.W + x[1]
def _dimCheck2(self,xy):
if isinstance(xy[0],int): return xy[0],xy[1]
return xy[0][0]*self.W + xy[0][1], xy[1][0]*self.W + xy[1][1]
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main()
|
ConDefects/ConDefects/Code/arc171_b/Python/51120581
|
condefects-python_data_1127
|
n = int(input())
for i in range(n+1):
for j in range(n+1):
for k in range(n+1):
if i + j + k <= 3:
print(i,j,k)
n = int(input())
for i in range(n+1):
for j in range(n+1):
for k in range(n+1):
if i + j + k <= n:
print(i,j,k)
|
ConDefects/ConDefects/Code/abc335_b/Python/54952141
|
condefects-python_data_1128
|
n = int(input())
for x in range(n+1):
for y in range(n+1):
for z in range(n+1):
if x + y + z == n:
print(x, y, z)
n = int(input())
for x in range(n+1):
for y in range(n+1):
for z in range(n+1):
if x + y + z <= n:
print(x, y, z)
|
ConDefects/ConDefects/Code/abc335_b/Python/54708241
|
condefects-python_data_1129
|
N = int(input())
for x in range(N+1):
for y in range(N+1):
for z in range(N+1):
if x + y + z == N:
print(x,y,z)
N = int(input())
for x in range(N+1):
for y in range(N+1):
for z in range(N+1):
if x + y + z <= N:
print(x,y,z)
|
ConDefects/ConDefects/Code/abc335_b/Python/54517250
|
condefects-python_data_1130
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
print(2 * N)
ans = '4' * (N // 4)
if N % 4:
ans += str(N % 4)
print(ans)
if __name__ == '__main__':
main()
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
print(2 * N)
ans = '4' * (N // 4)
if N % 4:
ans = str(N % 4) + ans
print(ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc144_a/Python/42090105
|
condefects-python_data_1131
|
N=int(input())
M=2*N
print(M)
tmp=M
X=[]
tmp1=M//8
tmp2=M%8
for i in range(tmp1):
X.append(8)
tmp3=tmp2//6
tmp4=tmp2%6
for i in range(tmp3):
X.append(6)
tmp5=tmp4//4
tmp6=tmp4%4
for i in range(tmp5):
X.append(4)
tmp7=tmp6//2
for i in range(tmp7):
X.append(1)
X.sort()
ans2=str()
for i in X:
ans2+=str(i)
ansex=int(ans2)
print(ansex//2)
N=int(input())
M=2*N
print(M)
tmp=M
X=[]
tmp1=M//8
tmp2=M%8
for i in range(tmp1):
X.append(8)
tmp3=tmp2//6
tmp4=tmp2%6
for i in range(tmp3):
X.append(6)
tmp5=tmp4//4
tmp6=tmp4%4
for i in range(tmp5):
X.append(4)
tmp7=tmp6//2
for i in range(tmp7):
X.append(2)
X.sort()
ans2=str()
for i in X:
ans2+=str(i)
ansex=int(ans2)
print(ansex//2)
|
ConDefects/ConDefects/Code/arc144_a/Python/39176273
|
condefects-python_data_1132
|
N = int(input())
M = 2 * N
xstr = str(((N - 1) % 4) + 1) + "4" * ((N - 1) // 4)
N = int(input())
M = 2 * N
xstr = str(((N - 1) % 4) + 1) + "4" * ((N - 1) // 4)
print(M)
print(xstr)
|
ConDefects/ConDefects/Code/arc144_a/Python/41487232
|
condefects-python_data_1133
|
n = int(input())
m = 2*n
x = []
while n > 4:
x.append('4')
n -= 4
if n == 3:
x.append('3')
if n == 2:
x.append('2')
if n == 1:
x.append('1')
x.sort()
x = ''.join(x)
print(m)
print(x)
n = int(input())
m = 2*n
x = []
while n > 4:
x.append('4')
n -= 4
if n == 4:
x.append('4')
if n == 3:
x.append('3')
if n == 2:
x.append('2')
if n == 1:
x.append('1')
x.sort()
x = ''.join(x)
print(m)
print(x)
|
ConDefects/ConDefects/Code/arc144_a/Python/39069759
|
condefects-python_data_1134
|
white,black = map(int,input().split())
sum = white + black
part_list = []
str_S = 'wbwbwwbwbwbw' #12
S_list = list(str_S)
S_list_sum = 12
while sum > S_list_sum:
S_list.extend(str_S)
S_list_sum += 12
S_list.extend(str_S)
S_list_sum += 12
for x in range(S_list_sum):
part_list = S_list[x:x+sum + 1]
white_count = part_list.count('w')
black_count = part_list.count('b')
if white_count == white and black_count == black:
print('Yes')
exit()
print('No')
white,black = map(int,input().split())
sum = white + black
part_list = []
str_S = 'wbwbwwbwbwbw' #12
S_list = list(str_S)
S_list_sum = 12
while sum > S_list_sum:
S_list.extend(str_S)
S_list_sum += 12
S_list.extend(str_S)
S_list_sum += 12
for x in range(S_list_sum):
part_list = S_list[x:x+sum]
white_count = part_list.count('w')
black_count = part_list.count('b')
if white_count == white and black_count == black:
print('Yes')
exit()
print('No')
|
ConDefects/ConDefects/Code/abc346_b/Python/54925895
|
condefects-python_data_1135
|
W,B = map(int,input().split())
wb = 'wbwbwwbwbwbw'
wball = wb*(200//len(wb)+4)
n = len(wball)
for i in range(n-(W+B)):
if wball[i:(W+B+1)].count('w') == W and wball[i:(W+B+1)].count('b') == B:
print('Yes')
exit()
print('No')
W,B = map(int,input().split())
wb = 'wbwbwwbwbwbw'
wball = wb*(200//len(wb)+4)
n = len(wball)
for i in range(n-(W+B)):
if wball[i:(i+W+B)].count('w') == W and wball[i:(i+W+B)].count('b') == B:
print('Yes')
exit()
print('No')
|
ConDefects/ConDefects/Code/abc346_b/Python/54883700
|
condefects-python_data_1136
|
white, black = map(int,input().split())
while white > 6 and black > 4 :
white -= 7
black -= 5
#print(white, black)
if abs(white - black) >= 4:
print("No")
exit()
#print(white,black)
s = "wbwbwwbwbwbwwbwbwwbwbwbw"
S = list(s)
S_dict = {"w":0, "b":0}
for wb in range(white + black):
S_dict[S[wb]] += 1
#print(S_dict)
for wb in range(24 - white - black):
if S_dict["w"] == white and S_dict["b"] == black:
print("Yes")
exit()
S_dict[S[wb]] -= 1
S_dict[S[wb + white + black]] += 1
print(S_dict)
print("No")
white, black = map(int,input().split())
while white > 6 and black > 4 :
white -= 7
black -= 5
#print(white, black)
if abs(white - black) >= 4:
print("No")
exit()
#print(white,black)
s = "wbwbwwbwbwbwwbwbwwbwbwbw"
S = list(s)
S_dict = {"w":0, "b":0}
for wb in range(white + black):
S_dict[S[wb]] += 1
#print(S_dict)
for wb in range(24 - white - black):
if S_dict["w"] == white and S_dict["b"] == black:
print("Yes")
exit()
S_dict[S[wb]] -= 1
S_dict[S[wb + white + black]] += 1
#print(S_dict)
print("No")
|
ConDefects/ConDefects/Code/abc346_b/Python/55019091
|
condefects-python_data_1137
|
W,B=map(int,input().split())
can_l=[]
Ans="No"
piano="wbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbw"
piano=list(piano)
for i in range(len(piano)):#何文字とるか
i+=1
for j in range(len(piano)-i):#何文字目からとるか
A=[0,0]
for k in range(i):#i文字のうち何文字目をとるか
k+=1
if piano[j+k]=="w":
A[0]+=1
if piano[j+k]=="b":
A[1]+=1
#print(i,j,k)
if A not in can_l:
can_l.append(A)
print(can_l)
test_l=[W,B]
if test_l in can_l:
Ans="Yes"
print(Ans)
W,B=map(int,input().split())
can_l=[]
Ans="No"
piano="wbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbw"
piano=list(piano)
for i in range(len(piano)):#何文字とるか
i+=1
for j in range(len(piano)-i):#何文字目からとるか
A=[0,0]
for k in range(i):#i文字のうち何文字目をとるか
k+=1
if piano[j+k]=="w":
A[0]+=1
if piano[j+k]=="b":
A[1]+=1
#print(i,j,k)
if A not in can_l:
can_l.append(A)
#print(can_l)
test_l=[W,B]
if test_l in can_l:
Ans="Yes"
print(Ans)
|
ConDefects/ConDefects/Code/abc346_b/Python/55138933
|
condefects-python_data_1138
|
M=998244353
n,m,k=map(int,input().split())
q=[0]*(k+1)
q[0]=1
for i in range(n):
nq=[0]*(k+1)
for j in range(k):
nq[j+1]+=q[j]
for j in range(k):
nq[j+1]+=nq[j]
nq[j+1]%=M
q=nq
print(sum(q)%M)
M=998244353
n,m,k=map(int,input().split())
q=[0]*(k+1)
q[0]=1
for i in range(n):
nq=[0]*(k+1)
for j in range(k):
nq[j+1]+=q[j]
if j+m+1<=k:
nq[j+m+1]-=q[j]
for j in range(k):
nq[j+1]+=nq[j]
nq[j+1]%=M
q=nq
print(sum(q)%M)
|
ConDefects/ConDefects/Code/abc248_c/Python/45110543
|
condefects-python_data_1139
|
import math
import sys
sys.setrecursionlimit(500_000)
from collections import defaultdict
N, Q = map(int, input().split())
g = [[] for _ in range(N + 1)]
for _ in range(Q):
l, r = map(int, input().split())
l -= 1
g[l].append(r)
g[r].append(l)
visited = [False] * (N + 1)
q = [0]
visited[0] = True
while len(q) > 0:
i = q.pop()
for j in g[i]:
if not visited[j]:
visited[j] = True
q.append(j)
if all(visited):
print('Yes')
else:
print('No')
import math
import sys
sys.setrecursionlimit(500_000)
from collections import defaultdict
N, Q = map(int, input().split())
g = [[] for _ in range(N + 1)]
for _ in range(Q):
l, r = map(int, input().split())
l -= 1
g[l].append(r)
g[r].append(l)
visited = [False] * (N + 1)
q = [0]
visited[0] = True
while len(q) > 0:
i = q.pop()
for j in g[i]:
if not visited[j]:
visited[j] = True
q.append(j)
if visited[-1]:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc238_e/Python/52795863
|
condefects-python_data_1140
|
N,M=map(int,input().split(' '))
A=list(map(int,input().split(' ')))
sumlist=[]
nolist=[]
result=[]
for i in range(N):
temp=input()
sum=0
nokai=[]
for index,e in enumerate(temp):
if e=="o":
sum+=A[index]
else:
nokai.append(A[index])
sort_nokai =sorted(nokai, reverse=True)
nolist.append(sort_nokai)
if sum>0:
sumlist.append(sum+(i+1))
else:
sumlist.append(sum+(i+1))
maxsum=max(sumlist)
print(maxsum,sumlist,nolist)
k=0
for iindex,ee in enumerate(sumlist):
sabun=maxsum-ee
k=0
if sabun>0:
while sabun>0:
if k==0 and ee==0:
#sabun=sabun-nolist[iindex][k]-(iindex+1)
sabun=sabun-nolist[iindex][k]
else:
sabun=sabun-nolist[iindex][k]
k+=1
result.append(k)
elif maxsum==0:
result.append(1)
else:
result.append(0)
for eee in result:
print(eee)
N,M=map(int,input().split(' '))
A=list(map(int,input().split(' ')))
sumlist=[]
nolist=[]
result=[]
for i in range(N):
temp=input()
sum=0
nokai=[]
for index,e in enumerate(temp):
if e=="o":
sum+=A[index]
else:
nokai.append(A[index])
sort_nokai =sorted(nokai, reverse=True)
nolist.append(sort_nokai)
if sum>0:
sumlist.append(sum+(i+1))
else:
sumlist.append(sum+(i+1))
maxsum=max(sumlist)
# print(maxsum,sumlist,nolist)
k=0
for iindex,ee in enumerate(sumlist):
sabun=maxsum-ee
k=0
if sabun>0:
while sabun>0:
if k==0 and ee==0:
#sabun=sabun-nolist[iindex][k]-(iindex+1)
sabun=sabun-nolist[iindex][k]
else:
sabun=sabun-nolist[iindex][k]
k+=1
result.append(k)
elif maxsum==0:
result.append(1)
else:
result.append(0)
for eee in result:
print(eee)
|
ConDefects/ConDefects/Code/abc323_c/Python/54680187
|
condefects-python_data_1141
|
n, m = map(int, input().split())
A = list(map(int, input().split()))
S = [input() for i in range(n)]
score = [i+1 for i in range(n)]
B = [(i,j) for i,j in zip(range(m), A)]
B.sort(key=lambda x:x[1], reverse=True)
C = [i for i,j in B]
# print(C)
for i in range(n):
for j in range(m):
if S[i][j] == "o":
score[i] += A[j]
# print(score)
ms = max(score)
for i in range(n):
count = 0
for j in range(m):
if ms <= score[i]:
break
index = C[j]
if S[i][j] != "o":
score[i] += A[index]
count += 1
print(count)
n, m = map(int, input().split())
A = list(map(int, input().split()))
S = [input() for i in range(n)]
score = [i+1 for i in range(n)]
B = [(i,j) for i,j in zip(range(m), A)]
B.sort(key=lambda x:x[1], reverse=True)
C = [i for i,j in B]
# print(C)
for i in range(n):
for j in range(m):
if S[i][j] == "o":
score[i] += A[j]
# print(score)
ms = max(score)
for i in range(n):
count = 0
for j in range(m):
if ms <= score[i]:
break
index = C[j]
if S[i][index] != "o":
score[i] += A[index]
count += 1
print(count)
|
ConDefects/ConDefects/Code/abc323_c/Python/54745257
|
condefects-python_data_1142
|
n, m = map(int, input().split())
a = list(map(int, input().split()))
s = [input() for _ in range(n)]
score = [i+1 for i in range(n)]
for i in range(n):
for j in range(m):
if s[i][j] == "o":
score[i] += a[j]
top = max(score)
for i in range(n):
need = top - score[i]
rest = []
for j in range(m):
if s[i][j] == "x":
rest.append(a[j])
rest.sort(reverse=True)
ans = 0
for j in range(len(rest)+1):
if need <= 0:
ans = j
break
need -= a[j]
print(ans)
n, m = map(int, input().split())
a = list(map(int, input().split()))
s = [input() for _ in range(n)]
score = [i+1 for i in range(n)]
for i in range(n):
for j in range(m):
if s[i][j] == "o":
score[i] += a[j]
top = max(score)
for i in range(n):
need = top - score[i]
rest = []
for j in range(m):
if s[i][j] == "x":
rest.append(a[j])
rest.sort(reverse=True)
ans = 0
for j in range(len(rest)+1):
if need <= 0:
ans = j
break
need -= rest[j]
print(ans)
|
ConDefects/ConDefects/Code/abc323_c/Python/54930796
|
condefects-python_data_1143
|
n, m = map(int, input().split())
l = list(map(int, input().split()))
player = []
for i in range(n):
player.append([input(), 0])
hi = [0, 0]
for i in range(n):
score = 0
for j, c in enumerate(player[i][0]):
if c == 'o':
score += l[j]
score += 1
player[i][1] = score
if score >= hi[0]:
hi = [score, i]
il = []
for i in range(m):
il.append([l[i], i])
sorted_il = sorted(il)
for i in range(n):
r = 0
s = player[i][1]
if s <= hi[0] and i != hi[1]:
for j in range(m - 1, -1, -1):
index = sorted_il[j][1]
if player[i][0][index] == 'x' and s <= hi[0]:
s += sorted_il[j][0]
r += 1
print(r)
n, m = map(int, input().split())
l = list(map(int, input().split()))
player = []
for i in range(n):
player.append([input(), 0])
hi = [0, 0]
for i in range(n):
score = 0
for j, c in enumerate(player[i][0]):
if c == 'o':
score += l[j]
score += (i + 1)
player[i][1] = score
if score >= hi[0]:
hi = [score, i]
il = []
for i in range(m):
il.append([l[i], i])
sorted_il = sorted(il)
for i in range(n):
r = 0
s = player[i][1]
if s <= hi[0] and i != hi[1]:
for j in range(m - 1, -1, -1):
index = sorted_il[j][1]
if player[i][0][index] == 'x' and s <= hi[0]:
s += sorted_il[j][0]
r += 1
print(r)
|
ConDefects/ConDefects/Code/abc323_c/Python/54308429
|
condefects-python_data_1144
|
# セグ木のノードに長さを持たせる必要あり
class LazySegTree:
def _update(self, k):
# _d[k]を更新
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k, f):
# _d[k] <- f(_d[k])
self._d[k] = self._mapping(f, self._d[k])
# kが葉でないとき, fを_lz[k]に貯める
if k < self._size:
self._lz[k] = self._composition(f, self._lz[k])
def _push(self, k):
# _lz[k]に貯まった遅延情報を子に流す
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
def __init__(self, op, e, mapping, composition, id, v):
"""
op: 二項演算
e: 単位元
mapping(f, x): 遅延させた情報の処理 (f(x)を返す関数)
composition(g, f): 遅延させた情報が衝突したときの処理 (g(f(x))を返す関数)
id: f(x) = x を満たすf (lzをこれで初期化する)
v: 初期の配列
"""
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p, x):
"""
v[p]にxをセットする
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p):
"""
v[p]を取得する
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, l, r):
"""
[l, r)におけるopの結果を取得
"""
if l == r:
return self._e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml = self._e
smr = self._e
while l < r:
if l & 1:
sml = self._op(sml, self._d[l])
l += 1
if r & 1:
r -= 1
smr = self._op(self._d[r], smr)
l >>= 1
r >>= 1
return self._op(sml, smr)
def all_prod(self):
return self._d[1]
def apply_point(self, p, f):
"""
v[p] <- f(v[p])
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
def apply(self, l, r, f):
"""
i = l,..,r-1について v[i] <- f[v[i]]
"""
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self._all_apply(l, f)
l += 1
if r & 1:
r -= 1
self._all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self._log + 1):
if ((l >> i) << i) != l:
self._update(l >> i)
if ((r >> i) << i) != r:
self._update((r - 1) >> i)
def max_right(self, l, g):
"""
g(op(v[l],..,v[r - 1]) = True となる最大のrを返す
bool g
"""
if l == self._n:
return self._n
l += self._size
for i in range(self._log, 0, -1):
self._push(l >> i)
sm = self._e
first = True
while first or (l & -l) != l:
first = False
while l % 2 == 0:
l >>= 1
if not g(self._op(sm, self._d[l])):
while l < self._size:
self._push(l)
l *= 2
if g(self._op(sm, self._d[l])):
sm = self._op(sm, self._d[l])
l += 1
return l - self._size
sm = self._op(sm, self._d[l])
l += 1
return self._n
def min_left(self, r, g):
"""
g(op(v[l],..,v[r - 1]) = True となる最小のlを返す
bool g
"""
if r == 0:
return 0
r += self._size
for i in range(self._log, 0, -1):
self._push((r - 1) >> i)
sm = self._e
first = True
while first or (r & -r) != r:
first = False
r -= 1
while r > 1 and r % 2:
r >>= 1
if not g(self._op(self._d[r], sm)):
while r < self._size:
self._push(r)
r = 2 * r + 1
if g(self._op(self._d[r], sm)):
sm = self._op(self._d[r], sm)
r -= 1
return r + 1 - self._size
sm = self._op(self._d[r], sm)
return 0
# op
# 1.加法
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# e = (0, 0)
# 2.min
# def op(x, y):
# return (min(x[0], y[0]), x[1] + y[1])
# e = (10 ** 18, 0)
# 3.max
# def op(x, y):
# return (max(x[0], y[0]), x[1] + y[1])
# e = (-10 ** 18, 0)
# mapping, composition(opはすべて加算の場合)
# 1.x <- x+c (加算)
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# def mapping(f, x):
# return (x[0] + f * x[1], x[1])
# def composition(g, f):
# return (g + f)
# e = (0, 0)
# id = 0
# 2.x <- a * x (乗算)
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# def mapping(f, x):
# return (x[0] * f, x[1])
# def composition(g, f):
# return g * f
# e = (0, 0)
# id = 1
# 3.x <- ax+b
# def op(x, y):
# return ((x[0]+y[0]), x[1]+y[1])
# def mapping(f, x):
# a, b = f
# return (a*x[0]+b*x[1], x[1])
# def composition(g, f):
# a, b = f
# c, d = g
# return (a*c, (b*c+d))
# e = (0, 0)
# id = (1, 0)
# 4.x <- y (変更)
# def op(x, y):
# return ((x[0]+y[0]), x[1]+y[1])
# def mapping(f, x):
# if f == None:
# return x
# return (f, x[1])
# def composition(g, f):
# if g == id: return f
# return g
# e = (0, 0)
# id = None
mod = 998244353
def op(x, y):
a1, b1, ab1, l1 = x
a2, b2, ab2, l2 = y
return ((a1 + a2) % mod, (b1 + b2) % mod, (ab1 + ab2) % mod, l1 + l2)
def mapping(f, x):
a, b, ab, l = x
y1, y2 = f
aa = (a + l * y1) % mod
bb = (b + l * y2) % mod
return (aa, bb, (ab + y1*b + y2*a + y1*y2) % mod, l)
def composition(g, f):
x1, y1 = g
x2, y2 = f
return ((x1 + x2) % mod, (y1 + y2) % mod)
e = (0, 0, 0, 0)
id = (0, 0)
N, Q = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
query = [list(map(int, input().split())) for _ in range(Q)]
init = []
for i in range(N):
init.append((A[i], B[i], (A[i] * B[i]) % mod, 1))
seg = LazySegTree(op, e, mapping, composition, id, init)
for i in range(Q):
if query[i][0] == 1:
_, l, r, x = query[i]
l -= 1
seg.apply(l, r, (x, 0))
elif query[i][0] == 2:
_, l, r, x = query[i]
l -= 1
seg.apply(l, r, (0, x))
else:
_, l, r = query[i]
l -= 1
print(seg.prod(l, r)[2])
# セグ木のノードに長さを持たせる必要あり
class LazySegTree:
def _update(self, k):
# _d[k]を更新
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k, f):
# _d[k] <- f(_d[k])
self._d[k] = self._mapping(f, self._d[k])
# kが葉でないとき, fを_lz[k]に貯める
if k < self._size:
self._lz[k] = self._composition(f, self._lz[k])
def _push(self, k):
# _lz[k]に貯まった遅延情報を子に流す
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
def __init__(self, op, e, mapping, composition, id, v):
"""
op: 二項演算
e: 単位元
mapping(f, x): 遅延させた情報の処理 (f(x)を返す関数)
composition(g, f): 遅延させた情報が衝突したときの処理 (g(f(x))を返す関数)
id: f(x) = x を満たすf (lzをこれで初期化する)
v: 初期の配列
"""
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p, x):
"""
v[p]にxをセットする
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p):
"""
v[p]を取得する
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, l, r):
"""
[l, r)におけるopの結果を取得
"""
if l == r:
return self._e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml = self._e
smr = self._e
while l < r:
if l & 1:
sml = self._op(sml, self._d[l])
l += 1
if r & 1:
r -= 1
smr = self._op(self._d[r], smr)
l >>= 1
r >>= 1
return self._op(sml, smr)
def all_prod(self):
return self._d[1]
def apply_point(self, p, f):
"""
v[p] <- f(v[p])
"""
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
def apply(self, l, r, f):
"""
i = l,..,r-1について v[i] <- f[v[i]]
"""
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self._all_apply(l, f)
l += 1
if r & 1:
r -= 1
self._all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self._log + 1):
if ((l >> i) << i) != l:
self._update(l >> i)
if ((r >> i) << i) != r:
self._update((r - 1) >> i)
def max_right(self, l, g):
"""
g(op(v[l],..,v[r - 1]) = True となる最大のrを返す
bool g
"""
if l == self._n:
return self._n
l += self._size
for i in range(self._log, 0, -1):
self._push(l >> i)
sm = self._e
first = True
while first or (l & -l) != l:
first = False
while l % 2 == 0:
l >>= 1
if not g(self._op(sm, self._d[l])):
while l < self._size:
self._push(l)
l *= 2
if g(self._op(sm, self._d[l])):
sm = self._op(sm, self._d[l])
l += 1
return l - self._size
sm = self._op(sm, self._d[l])
l += 1
return self._n
def min_left(self, r, g):
"""
g(op(v[l],..,v[r - 1]) = True となる最小のlを返す
bool g
"""
if r == 0:
return 0
r += self._size
for i in range(self._log, 0, -1):
self._push((r - 1) >> i)
sm = self._e
first = True
while first or (r & -r) != r:
first = False
r -= 1
while r > 1 and r % 2:
r >>= 1
if not g(self._op(self._d[r], sm)):
while r < self._size:
self._push(r)
r = 2 * r + 1
if g(self._op(self._d[r], sm)):
sm = self._op(self._d[r], sm)
r -= 1
return r + 1 - self._size
sm = self._op(self._d[r], sm)
return 0
# op
# 1.加法
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# e = (0, 0)
# 2.min
# def op(x, y):
# return (min(x[0], y[0]), x[1] + y[1])
# e = (10 ** 18, 0)
# 3.max
# def op(x, y):
# return (max(x[0], y[0]), x[1] + y[1])
# e = (-10 ** 18, 0)
# mapping, composition(opはすべて加算の場合)
# 1.x <- x+c (加算)
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# def mapping(f, x):
# return (x[0] + f * x[1], x[1])
# def composition(g, f):
# return (g + f)
# e = (0, 0)
# id = 0
# 2.x <- a * x (乗算)
# def op(x, y):
# return (x[0] + y[0], x[1] + y[1])
# def mapping(f, x):
# return (x[0] * f, x[1])
# def composition(g, f):
# return g * f
# e = (0, 0)
# id = 1
# 3.x <- ax+b
# def op(x, y):
# return ((x[0]+y[0]), x[1]+y[1])
# def mapping(f, x):
# a, b = f
# return (a*x[0]+b*x[1], x[1])
# def composition(g, f):
# a, b = f
# c, d = g
# return (a*c, (b*c+d))
# e = (0, 0)
# id = (1, 0)
# 4.x <- y (変更)
# def op(x, y):
# return ((x[0]+y[0]), x[1]+y[1])
# def mapping(f, x):
# if f == None:
# return x
# return (f, x[1])
# def composition(g, f):
# if g == id: return f
# return g
# e = (0, 0)
# id = None
mod = 998244353
def op(x, y):
a1, b1, ab1, l1 = x
a2, b2, ab2, l2 = y
return ((a1 + a2) % mod, (b1 + b2) % mod, (ab1 + ab2) % mod, l1 + l2)
def mapping(f, x):
a, b, ab, l = x
y1, y2 = f
aa = (a + l * y1) % mod
bb = (b + l * y2) % mod
return (aa, bb, (ab + y1*b + y2*a + l*y1*y2) % mod, l)
def composition(g, f):
x1, y1 = g
x2, y2 = f
return ((x1 + x2) % mod, (y1 + y2) % mod)
e = (0, 0, 0, 0)
id = (0, 0)
N, Q = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
query = [list(map(int, input().split())) for _ in range(Q)]
init = []
for i in range(N):
init.append((A[i], B[i], (A[i] * B[i]) % mod, 1))
seg = LazySegTree(op, e, mapping, composition, id, init)
for i in range(Q):
if query[i][0] == 1:
_, l, r, x = query[i]
l -= 1
seg.apply(l, r, (x, 0))
elif query[i][0] == 2:
_, l, r, x = query[i]
l -= 1
seg.apply(l, r, (0, x))
else:
_, l, r = query[i]
l -= 1
print(seg.prod(l, r)[2])
|
ConDefects/ConDefects/Code/abc357_f/Python/54543446
|
condefects-python_data_1145
|
import sys
import io, os
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
mod = 998244353
n, q = map(int, input().split())
x = 0
par = [-1]*n
sz = [1]*n
root = list(range(n))
g = [[] for _ in range(n)]
for i in range(q):
A, B, C = map(int, input().split())
t = (A*(x+1)%mod)%2 + 1
a = (B*(x+1)%mod)%n
b = (C*(x+1)%mod)%n
if t == 1:
if sz[root[a]] < sz[root[b]]:
a, b = b, a
sz[root[a]] += sz[root[b]]
def dfs(v, p = -1):
par[v] = p
root[v] = root[a]
for u in g[v]:
if u == p:
continue
dfs(u, v)
dfs(b)
par[b] = a
g[a].append(b)
g[b].append(a)
else:
ans = -1
pa = par[a]
pb = par[b]
if pa == pb and pa != -1:
ans = pa
elif pb != -1 and par[pb] == a:
ans = pb
ans += 1
print(ans)
x = ans
import sys
import io, os
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
mod = 998244353
n, q = map(int, input().split())
x = 0
par = [-1]*n
sz = [1]*n
root = list(range(n))
g = [[] for _ in range(n)]
for i in range(q):
A, B, C = map(int, input().split())
t = (A*(x+1)%mod)%2 + 1
a = (B*(x+1)%mod)%n
b = (C*(x+1)%mod)%n
if t == 1:
if sz[root[a]] < sz[root[b]]:
a, b = b, a
sz[root[a]] += sz[root[b]]
def dfs(v, p = -1):
par[v] = p
root[v] = root[a]
for u in g[v]:
if u == p:
continue
dfs(u, v)
dfs(b)
par[b] = a
g[a].append(b)
g[b].append(a)
else:
ans = -1
pa = par[a]
pb = par[b]
if pa == pb and pa != -1:
ans = pa
elif pa != -1 and par[pa] == b:
ans = pa
elif pb != -1 and par[pb] == a:
ans = pb
ans += 1
print(ans)
x = ans
|
ConDefects/ConDefects/Code/abc350_g/Python/52999831
|
condefects-python_data_1146
|
from collections import deque
N, X = map(int, input().split())
ans = []
Q = deque()
for i in range(N):
if i + 1 != X:
Q.append(i + 1)
for i in range(N - 1):
if i % 2 != (X - N // 2) % 2:
ans.append(Q.pop())
else:
ans.append(Q.popleft())
ans.append(X)
print(*ans[::-1])
from collections import deque
N, X = map(int, input().split())
ans = []
Q = deque()
for i in range(N):
if i + 1 != X:
Q.append(i + 1)
for i in range(N - 1):
if i % 2 == (X - N // 2) % 2:
ans.append(Q.pop())
else:
ans.append(Q.popleft())
ans.append(X)
print(*ans[::-1])
|
ConDefects/ConDefects/Code/arc140_c/Python/38250831
|
condefects-python_data_1147
|
from bisect import bisect_left
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(dtype=int, split=True):
s = getStr()
if split:
s = s.split()
return list(map(dtype, s))
t = 1
def lis(a):
h = []
for i in a:
j = bisect_left(h, i)
if j == len(h):
h.append(i)
else:
h[j] = i
return len(h)
def cost(a):
p = [abs(i-j) for i, j in zip(a, a[1:])]
return lis(p)
def solve():
n, x = getList()
# from itertools import permutations
# best = [0] * (n+1)
# for u in permutations(range(1, n+1)):
# u = list(u)
# best[u[0]] = max(best[u[0]], cost(u))
# if u[0] == 3 and best[u[0]] == n-2:
# print(u)
# return
invert = 0
if x > (n+1) // 2:
invert = 1
x = 1 + n - x
res = [x]
mark = [0] * (n+1)
mark[x] = 1
last = 0
if x * 2 - 1 != n:
it = (x+1+n-x+1) >> 1
res.append(it)
mark[it] = 1
last = 1
k = 1
while 1:
while 1 <= res[-1] + k * last <= n and mark[res[-1] + k * last]:
last += 1
if 1 <= res[-1] + k * last <= n:
res.append(res[-1] + k * last)
last += 1
else:
break
k *= -1
if invert:
res = [1+n-x for x in res]
print(*res)
for _ in range(t):
solve()
from bisect import bisect_left
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(dtype=int, split=True):
s = getStr()
if split:
s = s.split()
return list(map(dtype, s))
t = 1
def lis(a):
h = []
for i in a:
j = bisect_left(h, i)
if j == len(h):
h.append(i)
else:
h[j] = i
return len(h)
def cost(a):
p = [abs(i-j) for i, j in zip(a, a[1:])]
return lis(p)
def solve():
n, x = getList()
# from itertools import permutations
# best = [0] * (n+1)
# for u in permutations(range(1, n+1)):
# u = list(u)
# best[u[0]] = max(best[u[0]], cost(u))
# if u[0] == 3 and best[u[0]] == n-2:
# print(u)
# return
invert = 0
if x > (n+1) // 2:
invert = 1
x = 1 + n - x
res = [x]
mark = [0] * (n+1)
mark[x] = 1
last = 0
if x * 2 - 1 != n:
it = (x+1+n-x+1) >> 1
res.append(it)
mark[it] = 1
last = 1
k = x * 2 == n and -1 or 1
while 1:
while 1 <= res[-1] + k * last <= n and mark[res[-1] + k * last]:
last += 1
if 1 <= res[-1] + k * last <= n:
res.append(res[-1] + k * last)
last += 1
else:
break
k *= -1
if invert:
res = [1+n-x for x in res]
print(*res)
for _ in range(t):
solve()
|
ConDefects/ConDefects/Code/arc140_c/Python/39550972
|
condefects-python_data_1148
|
import collections
import math
import os
import random
import sys
from functools import reduce
from heapq import heappop, heappush
from io import BytesIO, IOBase
# Sample Inputs/Output
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ints = lambda: list(map(int, input().split()))
# MOD = 998244353
# MOD = 10 ** 9 + 7
# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
def printQry(a, b) -> None:
sa = str(a)
sb = str(b)
print(f"? {sa} {sb}", flush = True)
def printAns(ans) -> None:
s = str(ans)
print(f"! {s}", flush = True)
def solve() -> None:
n, x = map(int, input().split())
m = n // 2 + 1
sign = -1
if x == m:
ans = [m]
pre = m
elif x < m and not n & 1:
pre = m
ans = [x, pre]
else:
if x > m:
pre = m - 1
sign = 1
else:
pre = m + 1
ans = [x, pre]
i = 1
while i < n:
if pre + i * sign != x:
ans.append(pre + i * sign)
pre = pre + i * sign
sign = - sign
i += 1
print(*ans)
# t = int(input())
# for _ in range(t):
solve()
import collections
import math
import os
import random
import sys
from functools import reduce
from heapq import heappop, heappush
from io import BytesIO, IOBase
# Sample Inputs/Output
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ints = lambda: list(map(int, input().split()))
# MOD = 998244353
# MOD = 10 ** 9 + 7
# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
def printQry(a, b) -> None:
sa = str(a)
sb = str(b)
print(f"? {sa} {sb}", flush = True)
def printAns(ans) -> None:
s = str(ans)
print(f"! {s}", flush = True)
def solve() -> None:
n, x = map(int, input().split())
m = n // 2 + 1
sign = -1
if x == m:
ans = [m]
pre = m
elif x < m and not n & 1:
pre = m
ans = [x, pre]
else:
if x > m:
pre = m - 1
sign = 1
else:
pre = m + 1
ans = [x, pre]
i = 1
while len(ans) < n:
if pre + i * sign != x:
ans.append(pre + i * sign)
pre = pre + i * sign
sign = - sign
i += 1
print(*ans)
# t = int(input())
# for _ in range(t):
solve()
|
ConDefects/ConDefects/Code/arc140_c/Python/37080781
|
condefects-python_data_1149
|
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC241 D 1177 - Sequence Query
# 空の数列 A があります。
# クエリが Q 個与えられるので、与えられた順番に処理してください。
# クエリは次の 3 種類のいずれかです。
# ・1 x : A に x を追加する。
# ・2 x k : A の x 以下の要素のうち、大きい方から k 番目の値を出力する。(k は 5 以下)
# ただし、A に x 以下の要素が k 個以上存在しないときは -1 と出力する。
# ・3 x k : A の x 以上の要素のうち、小さい方から k 番目の値を出力する。(k は 5 以下)
# ただし、A に x 以上の要素が k 個以上存在しないときは -1 と出力する。
# ・1 ≤ Q ≤ 2×10^5
# ・1 ≤ x ≤ 10^18
# ・1 ≤ k ≤ 5
def main():
Q = ip()
A = SortedMultiset()
for _ in range(Q):
q = lmp()
if q[0] == 1:
x = q[1]
A.add(x)
elif q[0] == 2:
x, k = q[1:]
idx = A.index_right(x) - k
print(A[idx] if idx >= 0 else -1)
# print(2, A, x, k, idx)
else:
x, k = q[1:]
idx = A.index_right(x) + k - 1
print(A[idx] if idx < len(A) else -1)
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Optional, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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
if __name__ == '__main__':
main()
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC241 D 1177 - Sequence Query
# 空の数列 A があります。
# クエリが Q 個与えられるので、与えられた順番に処理してください。
# クエリは次の 3 種類のいずれかです。
# ・1 x : A に x を追加する。
# ・2 x k : A の x 以下の要素のうち、大きい方から k 番目の値を出力する。(k は 5 以下)
# ただし、A に x 以下の要素が k 個以上存在しないときは -1 と出力する。
# ・3 x k : A の x 以上の要素のうち、小さい方から k 番目の値を出力する。(k は 5 以下)
# ただし、A に x 以上の要素が k 個以上存在しないときは -1 と出力する。
# ・1 ≤ Q ≤ 2×10^5
# ・1 ≤ x ≤ 10^18
# ・1 ≤ k ≤ 5
def main():
Q = ip()
A = SortedMultiset()
for _ in range(Q):
q = lmp()
if q[0] == 1:
x = q[1]
A.add(x)
elif q[0] == 2:
x, k = q[1:]
idx = A.index_right(x) - k
print(A[idx] if idx >= 0 else -1)
# print(2, A, x, k, idx)
else:
x, k = q[1:]
idx = A.index(x) + k - 1
print(A[idx] if idx < len(A) else -1)
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Optional, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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) -> Optional[T]:
"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
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc241_d/Python/45806316
|
condefects-python_data_1150
|
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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
q = int(input())
s = SortedMultiset()
for i in range(q):
#print(s)
t = list(map(int, input().split()))
if t[0] == 1:
x = t[1]
s.add(x)
elif t[0] == 2:
x = t[1]
k = t[2]
p = s.index_right(x)
if p < k:
print(-1)
else:
print(s[p-k])
else:
x = t[1]
k = t[2]
p = s.index_right(x)
cnt = len(s) - p
if cnt < k:
print(-1)
else:
print(s[p+k-1])
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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
q = int(input())
s = SortedMultiset()
for i in range(q):
#print(s)
t = list(map(int, input().split()))
if t[0] == 1:
x = t[1]
s.add(x)
elif t[0] == 2:
x = t[1]
k = t[2]
p = s.index_right(x)
if p < k:
print(-1)
else:
print(s[p-k])
else:
x = t[1]
k = t[2]
p = s.index(x)
cnt = len(s) - p
if cnt < k:
print(-1)
else:
print(s[p+k-1])
|
ConDefects/ConDefects/Code/abc241_d/Python/45777353
|
condefects-python_data_1151
|
from collections import *
import heapq
import bisect
INF = float("inf")
MOD = 998244353
mod = 998244353
import bisect
class BIT:
def __init__(self, n):
self.n = len(n) if isinstance(n, list) else n
self.size = 1 << (self.n - 1).bit_length()
if isinstance(n, list): # nは1-indexedなリスト
a = [0]
for p in n:
a.append(p + a[-1])
a += [a[-1]] * (self.size - self.n)
self.d = [a[p] - a[p - (p & -p)] for p in range(self.size + 1)]
else: # nは大きさ
self.d = [0] * (self.size + 1)
def __repr__(self):
p = self.size
res = []
while p > 0:
res2 = []
for r in range(p, self.size + 1, p * 2):
l = r - (r & -r) + 1
res2.append(f"[{l}, {r}]:{self.d[r]}")
res.append(" ".join(res2))
p >>= 1
res.append(f"{[self.sum(p + 1) - self.sum(p) for p in range(self.size)]}")
return "\n".join(res)
def add(self, p, x): # O(log(n)), 点pにxを加算
assert p > 0
while p <= self.size:
self.d[p] += x
p += p & -p
def get(self, p, default=None): # O(log(n))
assert p > 0
return (
self.sum(p) - self.sum(p - 1)
if 1 <= p <= self.n or default is None
else default
)
def sum(self, p): # O(log(n)), 閉区間[1, p]の累積和
assert p >= 0
res = 0
while p > 0:
res += self.d[p]
p -= p & -p
return res
def lower_bound(self, x): # O(log(n)), x <= 閉区間[1, p]の累積和 となる最小のp
if x <= 0:
return 0
p, r = 0, self.size
while r > 0:
if p + r <= self.n and self.d[p + r] < x:
x -= self.d[p + r]
p += r
r >>= 1
return p + 1
class MultiSet:
# n: サイズ、compress: 座圧対象list-likeを指定(nは無効)
# multi: マルチセットか通常のOrderedSetか
def __init__(self, n=0, *, compress=[], multi=True):
self.multi = multi
self.inv_compress = (
sorted(set(compress)) if len(compress) > 0 else [i for i in range(n)]
)
self.compress = {k: v for v, k in enumerate(self.inv_compress)}
self.counter_all = 0
self.counter = [0] * len(self.inv_compress)
self.bit = BIT(len(self.inv_compress))
def add(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.counter[x]
if count == 0 or self.multi: # multiなら複数カウントできる
self.bit.add(x + 1, n)
self.counter_all += n
self.counter[x] += n
def remove(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.bit.get(x + 1)
if count < n:
raise KeyError(x)
self.bit.add(x + 1, -n)
self.counter_all -= n
self.counter[x] -= n
def __repr__(self):
return f'MultiSet {{{(", ".join(map(str, list(self))))}}}'
def __len__(self): # oprator len: O(1)
return self.counter_all
def count(self, x): # O(1)
return self.counter[self.compress[x]] if x in self.compress else 0
def __getitem__(self, i): # operator []: O(log n)
if i < 0:
i += len(self)
x = self.bit.lower_bound(i + 1)
if x > self.bit.n:
raise IndexError("list index out of range")
return self.inv_compress[x - 1]
def __contains__(self, x): # operator in: O(1)
return self.count(x) > 0
def bisect_left(self, x): # O(log n)
return self.bit.sum(bisect.bisect_left(self.inv_compress, x))
def bisect_right(self, x): # O(log n)
return self.bit.sum(bisect.bisect_right(self.inv_compress, x))
# 宣言方法
# MultiSet(compress=X,multi=False)
# MultiSet(N+1,multi=True)
Q = int(input())
query = [list(map(int, input().split())) for _ in range(Q)]
X = [q[1] for q in query]
A = MultiSet(compress=X, multi=True)
for q in query:
if q[0] == 1:
A.add(q[1])
elif q[0] == 2:
x, k = q[1], q[2]
kosu = A.bisect_right(x)
if kosu < k:
print(-1)
continue
print(A[kosu - k])
else:
x, k = q[1], q[2]
point = A.bisect_right(x)
kosu = len(A) - point
if kosu < k:
print(-1)
continue
print(A[point + k - 1])
from collections import *
import heapq
import bisect
INF = float("inf")
MOD = 998244353
mod = 998244353
import bisect
class BIT:
def __init__(self, n):
self.n = len(n) if isinstance(n, list) else n
self.size = 1 << (self.n - 1).bit_length()
if isinstance(n, list): # nは1-indexedなリスト
a = [0]
for p in n:
a.append(p + a[-1])
a += [a[-1]] * (self.size - self.n)
self.d = [a[p] - a[p - (p & -p)] for p in range(self.size + 1)]
else: # nは大きさ
self.d = [0] * (self.size + 1)
def __repr__(self):
p = self.size
res = []
while p > 0:
res2 = []
for r in range(p, self.size + 1, p * 2):
l = r - (r & -r) + 1
res2.append(f"[{l}, {r}]:{self.d[r]}")
res.append(" ".join(res2))
p >>= 1
res.append(f"{[self.sum(p + 1) - self.sum(p) for p in range(self.size)]}")
return "\n".join(res)
def add(self, p, x): # O(log(n)), 点pにxを加算
assert p > 0
while p <= self.size:
self.d[p] += x
p += p & -p
def get(self, p, default=None): # O(log(n))
assert p > 0
return (
self.sum(p) - self.sum(p - 1)
if 1 <= p <= self.n or default is None
else default
)
def sum(self, p): # O(log(n)), 閉区間[1, p]の累積和
assert p >= 0
res = 0
while p > 0:
res += self.d[p]
p -= p & -p
return res
def lower_bound(self, x): # O(log(n)), x <= 閉区間[1, p]の累積和 となる最小のp
if x <= 0:
return 0
p, r = 0, self.size
while r > 0:
if p + r <= self.n and self.d[p + r] < x:
x -= self.d[p + r]
p += r
r >>= 1
return p + 1
class MultiSet:
# n: サイズ、compress: 座圧対象list-likeを指定(nは無効)
# multi: マルチセットか通常のOrderedSetか
def __init__(self, n=0, *, compress=[], multi=True):
self.multi = multi
self.inv_compress = (
sorted(set(compress)) if len(compress) > 0 else [i for i in range(n)]
)
self.compress = {k: v for v, k in enumerate(self.inv_compress)}
self.counter_all = 0
self.counter = [0] * len(self.inv_compress)
self.bit = BIT(len(self.inv_compress))
def add(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.counter[x]
if count == 0 or self.multi: # multiなら複数カウントできる
self.bit.add(x + 1, n)
self.counter_all += n
self.counter[x] += n
def remove(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.bit.get(x + 1)
if count < n:
raise KeyError(x)
self.bit.add(x + 1, -n)
self.counter_all -= n
self.counter[x] -= n
def __repr__(self):
return f'MultiSet {{{(", ".join(map(str, list(self))))}}}'
def __len__(self): # oprator len: O(1)
return self.counter_all
def count(self, x): # O(1)
return self.counter[self.compress[x]] if x in self.compress else 0
def __getitem__(self, i): # operator []: O(log n)
if i < 0:
i += len(self)
x = self.bit.lower_bound(i + 1)
if x > self.bit.n:
raise IndexError("list index out of range")
return self.inv_compress[x - 1]
def __contains__(self, x): # operator in: O(1)
return self.count(x) > 0
def bisect_left(self, x): # O(log n)
return self.bit.sum(bisect.bisect_left(self.inv_compress, x))
def bisect_right(self, x): # O(log n)
return self.bit.sum(bisect.bisect_right(self.inv_compress, x))
# 宣言方法
# MultiSet(compress=X,multi=False)
# MultiSet(N+1,multi=True)
Q = int(input())
query = [list(map(int, input().split())) for _ in range(Q)]
X = [q[1] for q in query]
A = MultiSet(compress=X, multi=True)
for q in query:
if q[0] == 1:
A.add(q[1])
elif q[0] == 2:
x, k = q[1], q[2]
kosu = A.bisect_right(x)
if kosu < k:
print(-1)
continue
print(A[kosu - k])
else:
x, k = q[1], q[2]
point = A.bisect_left(x)
kosu = len(A) - point
if kosu < k:
print(-1)
continue
print(A[point + k - 1])
|
ConDefects/ConDefects/Code/abc241_d/Python/45284602
|
condefects-python_data_1152
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
T = int(readline())
mod = 998_244_353
for _ in range(T):
N = int(readline())
S = readline()
dp = [[0, 0] for _ in range((N - 1) // 2 + 1 + 1)]
dp[0][0] = 1
for i in range((N - 1) // 2 + 1):
s = S[i]
dp[i + 1][0] = dp[i][0]
dp[i + 1][1] = dp[i][1] * 26 + dp[i][0] * (ord(s) - ord('A'))
dp[i + 1][1] %= mod
ans = sum(dp[-1]) % mod
if N % 2:
tmp = S[:N//2+1] + S[:N//2][::-1]
if tmp > S:
ans -= 1
else:
tmp = S[:N//2] + S[:N//2][::-1]
if tmp > S:
ans -= 1
print(ans)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
T = int(readline())
mod = 998_244_353
for _ in range(T):
N = int(readline())
S = readline()
dp = [[0, 0] for _ in range((N - 1) // 2 + 1 + 1)]
dp[0][0] = 1
for i in range((N - 1) // 2 + 1):
s = S[i]
dp[i + 1][0] = dp[i][0]
dp[i + 1][1] = dp[i][1] * 26 + dp[i][0] * (ord(s) - ord('A'))
dp[i + 1][1] %= mod
ans = sum(dp[-1]) % mod
if N % 2:
tmp = S[:N//2+1] + S[:N//2][::-1]
if tmp > S:
ans -= 1
else:
tmp = S[:N//2] + S[:N//2][::-1]
if tmp > S:
ans -= 1
print(ans % mod)
|
ConDefects/ConDefects/Code/abc242_e/Python/45535167
|
condefects-python_data_1153
|
N,Q=map(int,input().split())
connects=[[-1,-1] for _ in range(N)]
for _ in range(Q):
query=list(map(int,input().split()))
t=query[0]
x=query[1]-1
if t==1:
y=query[2]-1
connects[x][1]=y
connects[y][0]=x
elif t==2:
y=query[2]-1
connects[x][1]=-1
connects[y][0]=-1
else:
front=[]
back=[]
now=x
while connects[now][0]!=-1:
now=connects[now][0]
front.append(now)
now=x
while connects[now][1]!=-1:
now=connects[now][1]
back.append(now+1)
answer=front[::-1]+[x+1]+back
print(len(answer),*answer)
N,Q=map(int,input().split())
connects=[[-1,-1] for _ in range(N)]
for _ in range(Q):
query=list(map(int,input().split()))
t=query[0]
x=query[1]-1
if t==1:
y=query[2]-1
connects[x][1]=y
connects[y][0]=x
elif t==2:
y=query[2]-1
connects[x][1]=-1
connects[y][0]=-1
else:
front=[]
back=[]
now=x
while connects[now][0]!=-1:
now=connects[now][0]
front.append(now+1)
now=x
while connects[now][1]!=-1:
now=connects[now][1]
back.append(now+1)
answer=front[::-1]+[x+1]+back
print(len(answer),*answer)
|
ConDefects/ConDefects/Code/abc225_d/Python/45240176
|
condefects-python_data_1154
|
a,b = map(int, input().split())
ct=[[0],[1],[2],[1,2],[4],[1,4],[2,4],[1,2,7]]
taka=ct[a]
ao=ct[b]
su=taka+ao
ans=set(su)
sim=sum(ans)
print(sim)
a,b = map(int, input().split())
ct=[[0],[1],[2],[1,2],[4],[1,4],[2,4],[1,2,4]]
taka=ct[a]
ao=ct[b]
su=taka+ao
ans=set(su)
sim=sum(ans)
print(sim)
|
ConDefects/ConDefects/Code/abc270_a/Python/46202213
|
condefects-python_data_1155
|
a,b = map(int,input().split())
ans = a ^ b
print(ans)
a,b = map(int,input().split())
ans = a | b
print(ans)
|
ConDefects/ConDefects/Code/abc270_a/Python/44921373
|
condefects-python_data_1156
|
def getIntMap():
return map(int, input().split())
def getIntList():
return list(map(int, input().split()))
def main():
n, p, q = getIntMap()
a = getIntList()
b = min([p - q + a[i] for i in range(n)])
print(b if b < p else p)
if __name__ == "__main__":
main()
def getIntMap():
return map(int, input().split())
def getIntList():
return list(map(int, input().split()))
def main():
n, p, q = getIntMap()
a = getIntList()
b = min([q + a[i] for i in range(n)])
print(b if b < p else p)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc310_a/Python/45785883
|
condefects-python_data_1157
|
N, P, Q = map(int, input().split())
D = list(map(int, input().split()))
ans = P
for i in range(N):
ret = P - Q + D[i]
ans = min(ans, ret)
print(ans)
N, P, Q = map(int, input().split())
D = list(map(int, input().split()))
ans = P
for i in range(N):
ret = Q + D[i]
ans = min(ans, ret)
print(ans)
|
ConDefects/ConDefects/Code/abc310_a/Python/45951629
|
condefects-python_data_1158
|
n, p, q = map(int, input().split(' '))
d = list(map(int, input().split(' ')))
print(min(p, p - q + min(d)))
n, p, q = map(int, input().split(' '))
d = list(map(int, input().split(' ')))
print(min(p, q + min(d)))
|
ConDefects/ConDefects/Code/abc310_a/Python/46023025
|
condefects-python_data_1159
|
N, P, Q = map(int, input().split())
D = list(map(int, input().split()))
res = P
for d in D:
if (p := P - Q + d) < res:
res = p
print(res)
N, P, Q = map(int, input().split())
D = list(map(int, input().split()))
res = P
for d in D:
if (p := Q + d) < res:
res = p
print(res)
|
ConDefects/ConDefects/Code/abc310_a/Python/45739812
|
condefects-python_data_1160
|
n, p, q = map(int,input().split())
d_list = [int(e) for e in input().split()]
a = min(d_list)
print(min(p-q+a,p))
n, p, q = map(int,input().split())
d_list = [int(e) for e in input().split()]
a = min(d_list)
print(min(q+a,p))
|
ConDefects/ConDefects/Code/abc310_a/Python/46010909
|
condefects-python_data_1161
|
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n", end="\n\n")
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = 18446744073709551615
# inf = 4294967295
md = 10**9+7
# md = 998244353
from collections import Counter
class Sieve:
def __init__(self, n):
self.plist = [2] # n以下の素数のリスト
min_prime_factor = [2, 0]*(n//2+1)
for x in range(3, n+1, 2):
if min_prime_factor[x] == 0:
min_prime_factor[x] = x
self.plist.append(x)
if x**2 > n: continue
for y in range(x**2, n+1, 2*x):
if min_prime_factor[y] == 0:
min_prime_factor[y] = x
self.min_prime_factor = min_prime_factor
def isprime(self, x):
return self.min_prime_factor[x] == x
# これが素因数分解(prime factorization)
def pfct(self, x):
pp, ee = [], []
while x > 1:
mpf = self.min_prime_factor[x]
if pp and mpf == pp[-1]:
ee[-1] += 1
else:
pp.append(mpf)
ee.append(1)
x //= mpf
return pp, ee
mx = 200005
sv = Sieve(mx)
mu = [-1]*mx
mu[1] = 0
for p in sv.plist:
for a in range(p, mx, p):
mu[a] = -mu[a]
for a in range(p*p, mx, p*p):
mu[a] = 0
# print(mu)
n = II()
pp = [-1]+LI()
def fac(a):
pp, _ = sv.pfct(a)
res = [1]
for p in pp:
nr = []
for s in res:
nr.append(s*p)
res += nr
return res[1:]
def cnt_pair(a):
if a*2 > n: return 1
cnt = Counter()
for i in range(a, n+1, a):
# print(a, pp[i], fac(pp[i]))
for f in fac(pp[i]):
cnt[f] += 1
s = 0
for f, c in cnt.items():
s += c*(c+1)//2*mu[f]
return s
ans = 0
for a in range(2, n+1):
if mu[a] == 0: continue
ans += mu[a]*cnt_pair(a)
# print(a, cnt_pair(a), ans)
print(ans)
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n", end="\n\n")
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = 18446744073709551615
# inf = 4294967295
md = 10**9+7
# md = 998244353
from collections import Counter
class Sieve:
def __init__(self, n):
self.plist = [2] # n以下の素数のリスト
min_prime_factor = [2, 0]*(n//2+1)
for x in range(3, n+1, 2):
if min_prime_factor[x] == 0:
min_prime_factor[x] = x
self.plist.append(x)
if x**2 > n: continue
for y in range(x**2, n+1, 2*x):
if min_prime_factor[y] == 0:
min_prime_factor[y] = x
self.min_prime_factor = min_prime_factor
def isprime(self, x):
return self.min_prime_factor[x] == x
# これが素因数分解(prime factorization)
def pfct(self, x):
pp, ee = [], []
while x > 1:
mpf = self.min_prime_factor[x]
if pp and mpf == pp[-1]:
ee[-1] += 1
else:
pp.append(mpf)
ee.append(1)
x //= mpf
return pp, ee
mx = 200005
sv = Sieve(mx)
mu = [-1]*mx
mu[1] = 0
for p in sv.plist:
for a in range(p, mx, p):
mu[a] = -mu[a]
for a in range(p*p, mx, p*p):
mu[a] = 0
# print(mu)
n = II()
pp = [-1]+LI()
def fac(a):
pp, _ = sv.pfct(a)
res = [1]
for p in pp:
nr = []
for s in res:
nr.append(s*p)
res += nr
return res[1:]
def cnt_pair(a):
if a*2 > n: return pp[a] > 1
cnt = Counter()
for i in range(a, n+1, a):
# print(a, pp[i], fac(pp[i]))
for f in fac(pp[i]):
cnt[f] += 1
s = 0
for f, c in cnt.items():
s += c*(c+1)//2*mu[f]
return s
ans = 0
for a in range(2, n+1):
if mu[a] == 0: continue
ans += mu[a]*cnt_pair(a)
# print(a, cnt_pair(a), ans)
print(ans)
|
ConDefects/ConDefects/Code/abc230_g/Python/27770752
|
condefects-python_data_1162
|
from atcoder.segtree import SegTree
N=int(input())
S={0}
P=[None]*N
for i in range(N):
h,w,d=map(int,input().split())
S.add(h); S.add(w); S.add(d)
P[i]=(h,w,d)
D={v:i for i,v in enumerate(sorted(S))}
points=[]
for i in range(N):
a,b,c=list(sorted(P[i]))
a=D[a]; b=D[b]; c=D[c]
points.append((a,b,c))
points.sort(key = lambda x: (x[0], -x[1], -x[2]))
INF = 1<<60
st = SegTree(min, INF, [INF]*(len(S)+5))
for x, y, z in points:
if st.prod(0, y)<z:
print("Yes")
exit()
st.set(y, z)
print("No")
from atcoder.segtree import SegTree
N=int(input())
S={0}
P=[None]*N
for i in range(N):
h,w,d=map(int,input().split())
S.add(h); S.add(w); S.add(d)
P[i]=(h,w,d)
D={v:i for i,v in enumerate(sorted(S))}
points=[]
for i in range(N):
a,b,c=list(sorted(P[i]))
a=D[a]; b=D[b]; c=D[c]
points.append((a,b,c))
points.sort(key = lambda x: (x[0], -x[1], -x[2]))
INF = 1<<60
st = SegTree(min, INF, [INF]*(len(S)+5))
for x, y, z in points:
if st.prod(0, y)<z:
print("Yes")
exit()
st.set(y, min(z, st.get(y)))
print("No")
|
ConDefects/ConDefects/Code/abc309_f/Python/55142933
|
condefects-python_data_1163
|
class SegmentTree:
def __init__(self, n, identity_e, combine_f):
"""
配列を 2 * n 個のノードで初期化する(0-indexed, 頂点は1から)
n: 列の長さ
identity_e: 単位元
combine_f: 2つのデータから値を合成するための関数
node: 各頂点の中身
"""
self._n = n
self._size = 1
while self._size < self._n:
self._size <<= 1
self._identity_e = identity_e
self._combine_f = combine_f
self._node = [self._identity_e] * (2 * self._size)
def build(self, array):
"""
配列 array の各要素を登録する
"""
# assert: True なら何も起こらない, False なら AssertionError を返す
assert len(array) == self._n
for idx, value in enumerate(array, start = self._size):
self._node[idx] = value
for idx in range(self._size - 1, 0, -1):
self._node[idx] = self._combine_f(
self._node[idx << 1 | 0], # 左の子
self._node[idx << 1 | 1], # 右の子
)
def update(self, idx, value):
"""
一点更新: 位置 idx(0-indexed) を値 value で更新
"""
i = self._size + idx
self._node[i] = value
while i > 1:
i >>= 1
self._node[i] = self._combine_f(
self._node[i << 1 | 0], # 左の子
self._node[i << 1 | 1], # 右の子
)
def fold(self, L, R):
"""
区間取得: 区間 [l, r) (0-indexed) 内の要素について、l 番目から順に
combine_f を適用した結果を返す(交換法則が前提になくても良い)
"""
L += self._size
R += self._size
value_L = self._identity_e
value_R = self._identity_e
while L < R:
if L & 1:
value_L = self._combine_f(value_L, self._node[L])
L += 1
if R & 1:
R -= 1
value_R = self._combine_f(self._node[R], value_R)
L >>= 1
R >>= 1
return self._combine_f(value_L, value_R)
def __str__(self):
return ', '.join([str(x) for x in self._node])
def comp(A):
# 座標圧縮
d = {a: i for i, a in enumerate(sorted(set(A)))}
res = [d[a] for a in A]
return res
from functools import cmp_to_key
from operator import add
def cmp(a, b):
if a[0] != b[0]:
return a[0] - b[0]
elif a[1] != b[1]:
return a[1] - b[1]
else:
return 0
N = int(input())
HWD = [list(map(int, input().split())) for _ in range(N)]
ss = set()
for i in range(N):
HWD[i].sort(reverse=True)
for j in range(3):
ss.add(HWD[i][j])
HWD.sort(key=cmp_to_key(cmp))
d = {a: i for i, a in enumerate(sorted(ss))}
# print(d)
# print(HWD)
INF = 10**18
seg_size = len(d)
seg = SegmentTree(seg_size, INF, min)
for i in range(N):
_, h, w = HWD[i]
h = d[h]
w = d[w]
cv = seg.fold(0, h)
seg.update(h, min(seg.fold(h, h + 1), w))
if cv < w:
print('Yes')
exit()
# print(cv, max(seg.fold(h, h + 1), w), h, w)
print('No')
class SegmentTree:
def __init__(self, n, identity_e, combine_f):
"""
配列を 2 * n 個のノードで初期化する(0-indexed, 頂点は1から)
n: 列の長さ
identity_e: 単位元
combine_f: 2つのデータから値を合成するための関数
node: 各頂点の中身
"""
self._n = n
self._size = 1
while self._size < self._n:
self._size <<= 1
self._identity_e = identity_e
self._combine_f = combine_f
self._node = [self._identity_e] * (2 * self._size)
def build(self, array):
"""
配列 array の各要素を登録する
"""
# assert: True なら何も起こらない, False なら AssertionError を返す
assert len(array) == self._n
for idx, value in enumerate(array, start = self._size):
self._node[idx] = value
for idx in range(self._size - 1, 0, -1):
self._node[idx] = self._combine_f(
self._node[idx << 1 | 0], # 左の子
self._node[idx << 1 | 1], # 右の子
)
def update(self, idx, value):
"""
一点更新: 位置 idx(0-indexed) を値 value で更新
"""
i = self._size + idx
self._node[i] = value
while i > 1:
i >>= 1
self._node[i] = self._combine_f(
self._node[i << 1 | 0], # 左の子
self._node[i << 1 | 1], # 右の子
)
def fold(self, L, R):
"""
区間取得: 区間 [l, r) (0-indexed) 内の要素について、l 番目から順に
combine_f を適用した結果を返す(交換法則が前提になくても良い)
"""
L += self._size
R += self._size
value_L = self._identity_e
value_R = self._identity_e
while L < R:
if L & 1:
value_L = self._combine_f(value_L, self._node[L])
L += 1
if R & 1:
R -= 1
value_R = self._combine_f(self._node[R], value_R)
L >>= 1
R >>= 1
return self._combine_f(value_L, value_R)
def __str__(self):
return ', '.join([str(x) for x in self._node])
def comp(A):
# 座標圧縮
d = {a: i for i, a in enumerate(sorted(set(A)))}
res = [d[a] for a in A]
return res
from functools import cmp_to_key
from operator import add
def cmp(a, b):
if a[0] != b[0]:
return a[0] - b[0]
elif a[1] != b[1]:
return b[1] - a[1]
else:
return 0
N = int(input())
HWD = [list(map(int, input().split())) for _ in range(N)]
ss = set()
for i in range(N):
HWD[i].sort(reverse=True)
for j in range(3):
ss.add(HWD[i][j])
HWD.sort(key=cmp_to_key(cmp))
d = {a: i for i, a in enumerate(sorted(ss))}
# print(d)
# print(HWD)
INF = 10**18
seg_size = len(d)
seg = SegmentTree(seg_size, INF, min)
for i in range(N):
_, h, w = HWD[i]
h = d[h]
w = d[w]
cv = seg.fold(0, h)
seg.update(h, min(seg.fold(h, h + 1), w))
if cv < w:
print('Yes')
exit()
# print(cv, max(seg.fold(h, h + 1), w), h, w)
print('No')
|
ConDefects/ConDefects/Code/abc309_f/Python/51733804
|
condefects-python_data_1164
|
#N,M=map(int, input().split())
N=int(input())
D={};E=[];F=[]
for i in range(N):
B=list(map(int, input().split()))
B=sorted(B)
a,b,c=B
F.append(b)
if a not in D:
D[a]=[];E.append(a)
D[a].append((b,c))
#print(D,E)
E=sorted(E)
FF={}
F=sorted(list(set(F)))
for i in range(len(F)):
FF[F[i]]=i
#print(FF)
#####segfunc#####
def segfunc(x, y):
return max(x,y)
#################
#####ide_ele#####
ide_ele =0
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
G=[0]*(N+10)
seg = SegTree(G, segfunc, ide_ele)
#print(seg.query(0, 8))
#seg.update(5, 4)
#print(seg.query(0, 8))
f=0
for e in E[::-1]:
for x,y in D[e]:
x=FF[x]
s=seg.query(x+1,N+5)
if y<s:
f=1
m=seg.query(x,x+1)
seg.update(x,max(m,y))
if f==1:
print('Yes')
else:
print('No')
#N,M=map(int, input().split())
N=int(input())
D={};E=[];F=[]
for i in range(N):
B=list(map(int, input().split()))
B=sorted(B)
a,b,c=B
F.append(b)
if a not in D:
D[a]=[];E.append(a)
D[a].append((b,c))
#print(D,E)
E=sorted(E)
FF={}
F=sorted(list(set(F)))
for i in range(len(F)):
FF[F[i]]=i
#print(FF)
#####segfunc#####
def segfunc(x, y):
return max(x,y)
#################
#####ide_ele#####
ide_ele =0
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
G=[0]*(N+10)
seg = SegTree(G, segfunc, ide_ele)
#print(seg.query(0, 8))
#seg.update(5, 4)
#print(seg.query(0, 8))
f=0
for e in E[::-1]:
for x,y in D[e]:
x=FF[x]
s=seg.query(x+1,N+5)
if y<s:
f=1
for x,y in D[e]:
x=FF[x]
m=seg.query(x,x+1)
seg.update(x,max(m,y))
if f==1:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc309_f/Python/52944581
|
condefects-python_data_1165
|
from collections import defaultdict
from math import inf
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class RangeDescendRangeMin:
def __init__(self, n):
self.n = n
self.cover = [inf] * (4 * n)
self.lazy_tag = [inf] * (4 * n)
def _make_tag(self, i, val):
self.cover[i] = min(self.cover[i], val)
self.lazy_tag[i] = min(self.lazy_tag[i], val)
return
def _push_up(self, i):
self.cover[i] = min(self.cover[i << 1], self.cover[(i << 1) | 1])
return
def _push_down(self, i):
if self.lazy_tag[i] != inf:
self.cover[i << 1] = min(self.cover[i << 1], self.lazy_tag[i])
self.cover[(i << 1) | 1] = min(self.cover[(i << 1) | 1], self.lazy_tag[i])
self.lazy_tag[i << 1] = min(self.lazy_tag[i << 1], self.lazy_tag[i])
self.lazy_tag[(i << 1) | 1] = min(self.lazy_tag[(i << 1) | 1], self.lazy_tag[i])
self.lazy_tag[i] = inf
return
def build(self, nums):
stack = [(0, self.n - 1, 1)]
while stack:
s, t, i = stack.pop()
if i >= 0:
if s == t:
self._make_tag(i, nums[s])
else:
stack.append((s, t, ~i))
m = s + (t - s) // 2
stack.append((s, m, i << 1))
stack.append((m + 1, t, (i << 1) | 1))
else:
i = ~i
self._push_up(i)
return
def get(self):
stack = [(0, self.n - 1, 1)]
nums = [0] * self.n
while stack:
s, t, i = stack.pop()
if s == t:
nums[s] = self.cover[i]
continue
m = s + (t - s) // 2
self._push_down(i)
stack.append((s, m, i << 1))
stack.append((m + 1, t, (i << 1) | 1))
return nums
def range_descend(self, left, right, val):
# update the range descend
stack = [(0, self.n - 1, 1)]
while stack:
a, b, i = stack.pop()
if i >= 0:
if left <= a and b <= right:
self._make_tag(i, val)
continue
self._push_down(i)
stack.append([a, b, ~i])
m = a + (b - a) // 2
if left <= m:
stack.append((a, m, i << 1))
if right > m:
stack.append((m + 1, b, (i << 1) | 1))
else:
i = ~i
self._push_up(i)
return
def range_min(self, left, right):
# query the range min
stack = [(0, self.n - 1, 1)]
lowest = inf
while stack:
a, b, i = stack.pop()
if left <= a and b <= right:
lowest = min(lowest, self.cover[i])
continue
self._push_down(i)
m = a + (b - a) // 2
if left <= m:
stack.append((a, m, i << 1))
if right > m:
stack.append((m + 1, b, (i << 1) | 1))
return lowest
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n = ac.read_int()
nodes = set()
dct = [ac.read_list_ints() for _ in range(n)]
for x, y, z in dct:
nodes.add(x)
nodes.add(y)
nodes.add(z)
ind = {num: i for i, num in enumerate(sorted(nodes))}
m = len(ind)
dct = [sorted([ind[w] for w in ls]) for ls in dct]
ind = defaultdict(list)
for x, y, z in dct:
ind[x].append((y, z))
tree = RangeDescendRangeMin(m)
for x in ind:
for y, z in ind[x]:
if y:
pre = tree.range_min(0, y - 1)
if pre < z:
ac.st("Yes")
return
if z:
pre = tree.range_min(0, z - 1)
if pre < y:
ac.st("Yes")
return
for y, z in ind[x]:
tree.range_descend(y, y, z)
tree.range_descend(z, z, y)
ac.st("No")
return
Solution().main()
from collections import defaultdict
from math import inf
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class RangeDescendRangeMin:
def __init__(self, n):
self.n = n
self.cover = [inf] * (4 * n)
self.lazy_tag = [inf] * (4 * n)
def _make_tag(self, i, val):
self.cover[i] = min(self.cover[i], val)
self.lazy_tag[i] = min(self.lazy_tag[i], val)
return
def _push_up(self, i):
self.cover[i] = min(self.cover[i << 1], self.cover[(i << 1) | 1])
return
def _push_down(self, i):
if self.lazy_tag[i] != inf:
self.cover[i << 1] = min(self.cover[i << 1], self.lazy_tag[i])
self.cover[(i << 1) | 1] = min(self.cover[(i << 1) | 1], self.lazy_tag[i])
self.lazy_tag[i << 1] = min(self.lazy_tag[i << 1], self.lazy_tag[i])
self.lazy_tag[(i << 1) | 1] = min(self.lazy_tag[(i << 1) | 1], self.lazy_tag[i])
self.lazy_tag[i] = inf
return
def build(self, nums):
stack = [(0, self.n - 1, 1)]
while stack:
s, t, i = stack.pop()
if i >= 0:
if s == t:
self._make_tag(i, nums[s])
else:
stack.append((s, t, ~i))
m = s + (t - s) // 2
stack.append((s, m, i << 1))
stack.append((m + 1, t, (i << 1) | 1))
else:
i = ~i
self._push_up(i)
return
def get(self):
stack = [(0, self.n - 1, 1)]
nums = [0] * self.n
while stack:
s, t, i = stack.pop()
if s == t:
nums[s] = self.cover[i]
continue
m = s + (t - s) // 2
self._push_down(i)
stack.append((s, m, i << 1))
stack.append((m + 1, t, (i << 1) | 1))
return nums
def range_descend(self, left, right, val):
# update the range descend
stack = [(0, self.n - 1, 1)]
while stack:
a, b, i = stack.pop()
if i >= 0:
if left <= a and b <= right:
self._make_tag(i, val)
continue
self._push_down(i)
stack.append([a, b, ~i])
m = a + (b - a) // 2
if left <= m:
stack.append((a, m, i << 1))
if right > m:
stack.append((m + 1, b, (i << 1) | 1))
else:
i = ~i
self._push_up(i)
return
def range_min(self, left, right):
# query the range min
stack = [(0, self.n - 1, 1)]
lowest = inf
while stack:
a, b, i = stack.pop()
if left <= a and b <= right:
lowest = min(lowest, self.cover[i])
continue
self._push_down(i)
m = a + (b - a) // 2
if left <= m:
stack.append((a, m, i << 1))
if right > m:
stack.append((m + 1, b, (i << 1) | 1))
return lowest
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n = ac.read_int()
nodes = set()
dct = [ac.read_list_ints() for _ in range(n)]
for x, y, z in dct:
nodes.add(x)
nodes.add(y)
nodes.add(z)
ind = {num: i for i, num in enumerate(sorted(nodes))}
m = len(ind)
dct = [sorted([ind[w] for w in ls]) for ls in dct]
ind = defaultdict(list)
for x, y, z in dct:
ind[x].append((y, z))
tree = RangeDescendRangeMin(m)
for x in sorted(ind):
for y, z in ind[x]:
if y:
pre = tree.range_min(0, y - 1)
if pre < z:
ac.st("Yes")
return
if z:
pre = tree.range_min(0, z - 1)
if pre < y:
ac.st("Yes")
return
for y, z in ind[x]:
tree.range_descend(y, y, z)
tree.range_descend(z, z, y)
ac.st("No")
return
Solution().main()
|
ConDefects/ConDefects/Code/abc309_f/Python/51247653
|
condefects-python_data_1166
|
class SegTree:
def __init__(self, op, e, seq):
if type(seq) is int:
seq = [e]*seq
self.N = len(seq)
self.e = e
self.op = op
self.X = [e]*(self.N * 2)
self._build(seq)
def _build(self, seq):
X = self.X
op = self.op
for i, x in enumerate(seq, self.N):
X[i] = x
for i in range(self.N - 1, 0, -1):
X[i] = op(X[i<<1], X[i<<1|1])
def get(self, i):
return self.X[self.N + i]
def set(self, i, x):
X = self.X
op = self.op
i += self.N
X[i] = x
while i > 1:
i >>= 1
X[i] = op(X[i<<1], X[i<<1|1])
def fold(self, L, R):
assert 0 <= L <= R <= self.N
X = self.X
op = self.op
L += self.N
R += self.N
vL = self.e
vR = self.e
while L < R:
if L&1:
vL = op(vL, X[L])
L += 1
if R&1:
R -= 1
vR = op(X[R], vR)
L >>= 1
R >>= 1
return op(vL, vR)
def __getitem__(self, idx):
if type(idx) is int:
return self.get(idx)
return self.fold(*self.unpack_slice(idx))
def __setitem__(self, i, x):
self.set(i, x)
def __repr__(self):
return repr([self.get(i) for i in range(self.N)])
def __iter__(self):
return iter(self.X[self.N:])
def unpack_slice(self, slice):
assert slice.step is None
l = slice.start or 0
r = slice.stop if slice.stop is not None else self.N
l = max(0, l)
r = min(self.N, r)
assert l <= r
return l, r
from collections import defaultdict
INF = float("INF")
N = int(input())
B = defaultdict(list)
W = []
D = []
for _ in range(N):
h, w, d = map(int, input().split())
h, w, d = sorted([h, w, d])
B[h].append((w, d))
W.append(w)
D.append(d)
H = sorted(B.keys())
def compress(A):
S = sorted(set(A))
d = {v: i for i, v in enumerate(S)}
return d
encode_W = compress(W)
encode_D = compress(D)
for h in H:
WD = B[h]
del B[h]
for w, d in WD:
B[h].append((encode_W[w], encode_D[d]))
seg = SegTree(min, INF, len(set(W)) + 1)
class Break(Exception):
pass
try:
for h in H:
WD = B[h]
for w, d in WD:
if d > seg[:w]:
raise Break
for w, d in WD:
seg[w] = d
except Break:
ans = True
else:
ans = False
if ans is True:
print("Yes")
else:
print("No")
class SegTree:
def __init__(self, op, e, seq):
if type(seq) is int:
seq = [e]*seq
self.N = len(seq)
self.e = e
self.op = op
self.X = [e]*(self.N * 2)
self._build(seq)
def _build(self, seq):
X = self.X
op = self.op
for i, x in enumerate(seq, self.N):
X[i] = x
for i in range(self.N - 1, 0, -1):
X[i] = op(X[i<<1], X[i<<1|1])
def get(self, i):
return self.X[self.N + i]
def set(self, i, x):
X = self.X
op = self.op
i += self.N
X[i] = x
while i > 1:
i >>= 1
X[i] = op(X[i<<1], X[i<<1|1])
def fold(self, L, R):
assert 0 <= L <= R <= self.N
X = self.X
op = self.op
L += self.N
R += self.N
vL = self.e
vR = self.e
while L < R:
if L&1:
vL = op(vL, X[L])
L += 1
if R&1:
R -= 1
vR = op(X[R], vR)
L >>= 1
R >>= 1
return op(vL, vR)
def __getitem__(self, idx):
if type(idx) is int:
return self.get(idx)
return self.fold(*self.unpack_slice(idx))
def __setitem__(self, i, x):
self.set(i, x)
def __repr__(self):
return repr([self.get(i) for i in range(self.N)])
def __iter__(self):
return iter(self.X[self.N:])
def unpack_slice(self, slice):
assert slice.step is None
l = slice.start or 0
r = slice.stop if slice.stop is not None else self.N
l = max(0, l)
r = min(self.N, r)
assert l <= r
return l, r
from collections import defaultdict
INF = float("INF")
N = int(input())
B = defaultdict(list)
W = []
D = []
for _ in range(N):
h, w, d = map(int, input().split())
h, w, d = sorted([h, w, d])
B[h].append((w, d))
W.append(w)
D.append(d)
H = sorted(B.keys())
def compress(A):
S = sorted(set(A))
d = {v: i for i, v in enumerate(S)}
return d
encode_W = compress(W)
encode_D = compress(D)
for h in H:
WD = B[h]
del B[h]
for w, d in WD:
B[h].append((encode_W[w], encode_D[d]))
seg = SegTree(min, INF, len(set(W)) + 1)
class Break(Exception):
pass
try:
for h in H:
WD = B[h]
for w, d in WD:
if d > seg[:w]:
raise Break
for w, d in WD:
seg[w] = min(seg[w], d)
except Break:
ans = True
else:
ans = False
if ans is True:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc309_f/Python/52283209
|
condefects-python_data_1167
|
import math
import re
import functools
import random
import sys
import os
import typing
from math import gcd,comb
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heappushpop, heapify, heappop, heappush
from io import BytesIO, IOBase
from copy import deepcopy
import threading
from typing import *
from bisect import bisect_left, bisect_right
from types import GeneratorType
# from sortedcontainers import SortedList
from operator import add
BUFSIZE = 4096
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
sys.stdout = IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def I():
return input()
def II():
return int(input())
def MII():
return map(int, input().split())
def LI():
return list(input().split())
def LII():
return list(map(int, input().split()))
def GMI():
return map(lambda x: int(x) - 1, input().split())
def LGMI():
return list(map(lambda x: int(x) - 1, input().split()))
mod=10**9+7
def gcd(a, b):
while b: a, b = b, a % b
return a
def lcm(a, b):
return a // gcd(a, b) * b
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1 << 32 else [2, 3, 5, 7, 11, 13, 17] if n < 1 << 48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g):
return g
elif isPrimeMR(n // g):
return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(N):
pf = primeFactor(N)
ret = [1]
for p in pf:
ret_prev = ret
ret = []
for i in range(pf[p] + 1):
for r in ret_prev:
ret.append(r * (p ** i))
return sorted(ret)[::-1]
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def solve():
n=II()
A=[tuple(sorted(LII())) for i in range(n)]
A.sort()
A=list(set(A))
A.sort(key=lambda x:[x[0],-x[1],-x[2]])
sl=SortedList()
mp={}
for a,b,c in A:
idx=sl.bisect_left(b)
if idx==0:
sl.add(b)
mp[b]=c
while len(sl)>1 and mp[sl[1]]>=c:
sl.remove(sl[1])
else:
if c>mp[sl[idx-1]]:
print('Yes')
return
elif c==mp[sl[idx-1]]:
continue
else:
while idx<len(sl) and mp[sl[idx]]>=c:
sl.remove(sl[idx])
if idx<len(sl) and sl[idx]==b and mp[b]<=c:
continue
else:
sl.add(b)
mp[b]=c
print('No')
for _ in range(1):
solve()
import math
import re
import functools
import random
import sys
import os
import typing
from math import gcd,comb
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heappushpop, heapify, heappop, heappush
from io import BytesIO, IOBase
from copy import deepcopy
import threading
from typing import *
from bisect import bisect_left, bisect_right
from types import GeneratorType
# from sortedcontainers import SortedList
from operator import add
BUFSIZE = 4096
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
sys.stdout = IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def I():
return input()
def II():
return int(input())
def MII():
return map(int, input().split())
def LI():
return list(input().split())
def LII():
return list(map(int, input().split()))
def GMI():
return map(lambda x: int(x) - 1, input().split())
def LGMI():
return list(map(lambda x: int(x) - 1, input().split()))
mod=10**9+7
def gcd(a, b):
while b: a, b = b, a % b
return a
def lcm(a, b):
return a // gcd(a, b) * b
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1 << 32 else [2, 3, 5, 7, 11, 13, 17] if n < 1 << 48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g):
return g
elif isPrimeMR(n // g):
return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(N):
pf = primeFactor(N)
ret = [1]
for p in pf:
ret_prev = ret
ret = []
for i in range(pf[p] + 1):
for r in ret_prev:
ret.append(r * (p ** i))
return sorted(ret)[::-1]
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def solve():
n=II()
A=[tuple(sorted(LII())) for i in range(n)]
A.sort()
A=list(set(A))
A.sort(key=lambda x:[x[0],-x[1],-x[2]])
sl=SortedList()
mp={}
for a,b,c in A:
idx=sl.bisect_left(b)
if idx==0:
if len(sl)>0 and sl[0]==b and mp[b]<c:
continue
sl.add(b)
mp[b]=c
while len(sl)>1 and mp[sl[1]]>=c:
sl.remove(sl[1])
else:
if c>mp[sl[idx-1]]:
print('Yes')
return
elif c==mp[sl[idx-1]]:
continue
else:
while idx<len(sl) and mp[sl[idx]]>=c:
sl.remove(sl[idx])
if idx<len(sl) and sl[idx]==b and mp[b]<=c:
continue
else:
sl.add(b)
mp[b]=c
print('No')
for _ in range(1):
solve()
|
ConDefects/ConDefects/Code/abc309_f/Python/52190693
|
condefects-python_data_1168
|
from collections import defaultdict
import heapq
N,M = map(int, input().split())
in_edges = [0]*(N+1)
G = defaultdict(list)
for _ in range(M):
A,B = map(int, input().split())
G[A].append(B)
in_edges[B] += 1
H = []
for i in range(1,N+1):
if in_edges[i] == 0:
heapq.heappush(H, i)
heapq.heapify(H)
ans = []
while H:
v = heapq.heappop(H)
ans.append(v)
for u in G[v]:
in_edges[u] -= 1
if in_edges[u] == 0:
heapq.heappush(H, u)
if ans:
print(*ans)
else:
print(-1)
from collections import defaultdict
import heapq
N,M = map(int, input().split())
in_edges = [0]*(N+1)
G = defaultdict(list)
for _ in range(M):
A,B = map(int, input().split())
G[A].append(B)
in_edges[B] += 1
H = []
for i in range(1,N+1):
if in_edges[i] == 0:
heapq.heappush(H, i)
heapq.heapify(H)
ans = []
while H:
v = heapq.heappop(H)
ans.append(v)
for u in G[v]:
in_edges[u] -= 1
if in_edges[u] == 0:
heapq.heappush(H, u)
if ans and len(ans) == N:
print(*ans)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc223_d/Python/45783590
|
condefects-python_data_1169
|
import heapq
N,M=map(int,input().split())
graph=[[] for _ in range(N)]
reversed_graph=[set() for _ in range(N)]
pairs=set()
que=set(range(N))
for _ in range(M):
u,v=map(int,input().split())
pair=(u-1,v-1)
if pair in pairs:
continue
graph[u-1].append(v-1)
reversed_graph[v-1].add(u-1)
if v-1 in que:
que.remove(v-1)
que=list(que)
heapq.heapify(que)
answers=[]
used=[0 for _ in range(N)]
while que:
now=heapq.heappop(que)
answers.append(now+1)
for to in graph[now]:
if len(reversed_graph[to])==0:
heapq.heappush(que,to)
if len(answers)==N:
print(*answers)
else:
print(-1)
import heapq
N,M=map(int,input().split())
graph=[[] for _ in range(N)]
reversed_graph=[set() for _ in range(N)]
pairs=set()
que=set(range(N))
for _ in range(M):
u,v=map(int,input().split())
pair=(u-1,v-1)
if pair in pairs:
continue
pairs.add(pair)
graph[u-1].append(v-1)
reversed_graph[v-1].add(u-1)
if v-1 in que:
que.remove(v-1)
que=list(que)
heapq.heapify(que)
answers=[]
used=[0 for _ in range(N)]
while que:
now=heapq.heappop(que)
answers.append(now+1)
for to in graph[now]:
reversed_graph[to].remove(now)
if len(reversed_graph[to])==0:
heapq.heappush(que,to)
if len(answers)==N:
print(*answers)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc223_d/Python/45718110
|
condefects-python_data_1170
|
# Python3/Pypy3テンプレート集
#ライブラリ-------------------------------------------------------------------
from bisect import *
import heapq
import collections
from collections import deque
from queue import Queue
from itertools import groupby
import itertools
import math
import array
import string
import copy
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from functools import reduce
from operator import and_, or_, xor
#便利スクリプト---------------------------------------------------------------
INF = 10**20
mod = 998244353
MOD = 10**9+7
def YesNo(b): print("Yes") if b else print("No")
def YESNO(b): print("YES") if b else print("NO")
#標準入力---------------------------------------------------------------------
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LIS(): return list(map(int, SI()))
def LA(f): return list(map(f, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().strip('\n')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def LMS(rows_number): return [MS() for _ in range(rows_number)]
#関数------------------------------------------------------------------------
###標準ライブラリ###
def ceil(a,b): #切り捨て
return (a+b-1)//b
def inv(a,p): #aのpを法とする逆元(aとpは互いに素)
return pow(a,p-2,p)%p
def transpose(A): #二次元配列の転置
A_t = []
for i in range(len(A[0])) :
tmp = []
for v in A :
tmp.append(v[i])
A_t.append(tmp)
return A_t
def rotate_matrix(A): #グリッドを時計回りに90度回転
return transpose(A[::-1])
def removeDuplicates_2D(A): #二次元配列の重複削除
return list(map(list, set(map(tuple, A))))
def convert(S,c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
s = set()
h = len(S)
w = len(S[0])
for i in range(h):
for j in range(w):
if S[i][j] == c:
s.add((i, j))
return s
def normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
mi = min(i for (i, j) in s)
mj = min(j for (i, j) in s)
return set((i - mi, j - mj) for (i, j) in s)
def cumulativeSum_1D(A): #配列Aの累積和
return list(itertools.accumulate(A))
def cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
h = len(S)
w = len(S[0])
CS = [[0 for _ in range(w)]for _ in range(h)]
CCS = [[0 for _ in range(w)]for _ in range(h)]
for i in range(h):
for j in range(w):
if(j==0):
CS[i][0] = S[i][0]
else:
CS[i][j] = CS[i][j-1] + S[i][j]
for i in range(h):
for j in range(w):
if(i==0):
CCS[0][j] = CS[0][j]
else:
CCS[i][j] = CCS[i-1][j] + CS[i][j]
return CCS
def string_to_runLength(S: str): #文字列/リストからラングレス圧縮
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
def runLength_to_string(L: "list[tuple]"): #ラングレス圧縮から文字列 => 文字だけ
res = ""
for c, n in L:
res += c * int(n)
return res
def bfs(i,G): # i:始点
n = len(G)
dist = [-1] * n
pre = [-1] * n
que = deque()
dist[i] = 0
que.append(i)
while not len(que)==0:
v = que.popleft()
for next_v in G[v]:
if dist[next_v] != -1:
continue
dist[next_v] = dist[v] + 1
pre[next_v] = v
que.append(next_v)
return dist,pre
def bfs01(s, G): # i:始点 => dist
N = len(G)
dist = [INF] * N
S = deque([s])
T = deque()
dist[s] = 0
d = 0
while S:
while S:
v = S.popleft()
for c, w in G[v]:
if d+c < dist[w]:
dist[w] = d+c
if c:
T.append(w)
else:
S.append(w)
S, T = T, S
d += 1
return dist
def dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
n = len(G)
hq = [(0, s)]
heapq.heapify(hq)
cost = [INF]*n
cost[s]= 0
pre = [-1] * n
while hq:
c,v = heapq.heappop(hq)
if c > cost[v]:
continue
for d,u in G[v]:
tmp = d+cost[v]
if tmp < cost[u]:
cost[u] = tmp
pre[u] = v
heapq.heappush(hq,(tmp,u))
return cost, pre
def coordinates(A): # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
B = sorted(set(A))
C = { v: i for i, v in enumerate(B) }
D = { i: v for i, v in enumerate(B) }
E = list(map(lambda v: C[v], A))
return C, D, E
def eng_L(): return list(string.ascii_lowercase)
def ENG_L(): return list(string.ascii_uppercase)
def bit_len(n): #bit長
return n.bit_length()
def bit_cnt(n): # bitにしたときの1の数
cnt = 0
for i in range(bit_len(n)+1):
cnt += n>>i & 1
return cnt
def idx_le(A, x): # x 以下の最大の要素位置 / なければ "No"
return bisect_right(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_lt(A, x): # x 未満の最大の要素位置 / なければ "No"
return bisect_left(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_ge(A, x): # x 以上の最小の要素位置 / なければ "No"
return bisect_left(A, x) if bisect_left(A, x) != len(A) else "No"
def idx_gt(A, x): # x 超過の最小の要素位置 / なければ "No"
return bisect_right(A, x) if bisect_right(A, x) != len(A) else "No"
def cnt_le(A, x): # x 以下の要素の個数
if(idx_le(A, x) == "No"): return 0
return idx_le(A, x) + 1
def cnt_lt(A, x): # x 未満の要素の個数
if(idx_lt(A, x) == "No"): return 0
return idx_lt(A, x) + 1
def cnt_ge(A, x): # x 以上の要素の個数
return len(A) - cnt_lt(A, x)
def cnt_gt(A, x): # x 超過の要素の個数
return len(A) - cnt_le(A, x)
###数学ライブラリ###
def allAND(A): # 配列Aの総AND
return reduce(and_, A)
def allOR(A): # 配列Aの総OR
return reduce(or_, A)
def allXOR(A): # 配列Aの総XOR
return reduce(xor, A)
def allGCD(A): # 配列Aの総GCD
if(len(A)==1):
return A[0]
g = math.gcd(A[0],A[1])
for i in range(1,len(A)):
g = math.gcd(g, A[i])
return g
def mex(A): #配列Aのmexを求める
B = set()
for a in A:
if(a>=0):
B.add(a)
B = list(B)
B.sort()
if(len(B)==0):
return 0
if(B[0]!=0):
return 0
m = 0
for i in range(1,len(B)):
if(B[i]==B[i-1]+1):
m +=1
else:
break
return m +1
def gcd(a,b): #aとbの最大公約数を求める
return math.gcd(a,b)
def lcm(a,b): #aとbの最小公倍数を求める
return a*b//gcd(a,b)
def extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b)*x
return d, x, y
return a, 1, 0
def fact_L(n,mod): # [0!, 1! ..., n!] を返す
fact = [1]
p = 1
for i in range(1,n+1):
p *= i
p %= mod
fact.append(p)
return fact
def bitCount_L(n): # n以下のそれぞれのbitカウントを返す
bitcount = [0] * (n+1)
for i in range(1,n+1):
bitcount[i] = bitcount[i//2] + i%2
return bitcount
def factorial(n, m=0): #nの階乗 | m:mod(デフォなし)
if(n<0):
return -1
elif(n==0):
return 1
P = 1
for i in range(1,n+1):
P *= i
if(m==0):
continue
P %= m
return P
def nPr(n, r, m=0): #順列nPr
if(n<=0 or r<0 or n<r):
return -1
if(r==0):
return 1
P = 1
for i in range(n,n-r,-1):
P *= i
if(m==0):
continue
P %= m
return P
def nCr(n, r, m=0): #組み合わせnCr
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
N = 1
for i in range(r):
N *= n-i
if(m==0):
continue
N %= m
R = factorial(r)
return N//R
def nCrm(n,r,m=mod): #逆元を用いた組み合わせnCr%mod
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
over=1
for i in range(n-r+1,n+1):
over *= i
over %= m
under=1
for i in range(1,r+1):
under *= i
under %= m
return over*pow(under,m-2,m)%m
def is_prime(n): #素数判定 => True/False
if n == 2:
return 1
if n == 1 or n%2 == 0:
return 0
m = n - 1
lsb = m & -m
s = lsb.bit_length()-1
d = m // lsb
test_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in test_numbers:
if a == n:
continue
x = pow(a,d,n)
r = 0
if x == 1:
continue
while x != m:
x = pow(x,2,n)
r += 1
if x == 1 or r == s:
return 0
return 1
def prime_L(n): #n以下の素数のリスト
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
def find_prime_factor(n):
if n%2 == 0:
return 2
m = int(n**0.125)+1
for c in range(1,n):
f = lambda a: (pow(a,2,n)+c)%n
y = 0
g = q = r = 1
k = 0
while g == 1:
x = y
while k < 3*r//4:
y = f(y)
k += 1
while k < r and g == 1:
ys = y
for _ in range(min(m, r-k)):
y = f(y)
q = q*abs(x-y)%n
g = math.gcd(q,n)
k += m
k = r
r *= 2
if g == n:
g = 1
y = ys
while g == 1:
y = f(y)
g = math.gcd(abs(x-y),n)
if g == n:
continue
if is_prime(g):
return g
elif is_prime(n//g):
return n//g
else:
return find_prime_factor(g)
def primeFactorization_2L(n): #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
if(n<=10**6):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
else:
res = {}
while not is_prime(n) and n > 1:
p = find_prime_factor(n)
s = 0
while n%p == 0:
n //= p
s += 1
res[p] = s
if n > 1:
res[n] = 1
R = []
for r in res:
R.append([r,res[r]])
R.sort()
return R
def divisor_L(n): #nまでの約数のリスト
if(n==1):
return [1]
if(n<=10**6):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
else:
L = primeFactorization_2L(n)
E = [[]for i in range(len(L))]
for i in range(len(L)):
for j in range(L[i][1]+1):
E[i].append(L[i][0]**j)
D = []
for p in list(itertools.product(*E)):
s = 1
for v in p:
s *= v
D.append(s)
D.sort()
return D
def floorsqrt(n): # N => ⌊√N⌋
# only for n <= 10 ** 18
ok = 10 ** 9 + 10
ng = 0
while ok - ng > 1:
t = (ok + ng) // 2
if t * t > n: ok = t
else: ng = t
return ng
def decimal_to_nAry(num_10,n): #10進数からn進数へ変換する(n<=36) |int型 => str型
str_n = []
while num_10:
if num_10%n >= 10:
str_n.append(chr(num_10%n+55))
else:
str_n.append(str(num_10%n))
num_10 //= n
return "".join(str_n[::-1])
def nAry_to_decimal(X,n): #n進数から10進数へ変換する(n<=36) | str型 => int型
num = 0
X = X.upper()
X = list(X)
for i in range(len(X)):
if(("0"<=X[i]<="9")==False):
X[i] = str(ord(X[i]) - 55)
for i in range(1,len(X)+1):
num += int(X[-i]) * pow(n, (i-1))
return num
def roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
return float(Decimal(x).quantize(Decimal(f"1E{d}"), rounding=ROUND_HALF_UP))
###幾何ライブラリ###
def dsin(d): #度数法でsinを計算する
return math.sin(math.radians(d))
def dcos(d): #度数法でcosを計算する
return math.cos(math.radians(d))
def rotate(x,y,d,cx=0,cy=0): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転 => [x,y]
nx = (x-cx)*dcos(d)-(y-cy)*dsin(d)
ny = (x-cx)*dsin(d)+(y-cy)*dcos(d)
return [nx+cx,ny+cy]
def findAngle(O,A,B): #∠AOBを求める(弧度法)
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
u = s[0]*t[0]+s[1]*t[1]
l = (s[0]**2+s[1]**2)**(1/2) * (t[0]**2+t[1]**2)**(1/2)
v = u/l
t = math.degrees(math.acos(v))
return t
def outerProduct(Av,Bv): #二次元ベクトルの外積(=符号付面積)を求める(a×b)
return Av[0]*Bv[1] - Bv[0]*Av[1]
def CCW(O,A,B): #Oを中心として、Aから見たAとBの位置関係を求める。
# -1: 時計回り, 0: 一直線上, 1: 反時計回り
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
op = outerProduct(s,t)
if(op > 0): return 1
if(op < 0): return -1
if(op == 0): return 0
def matrixMultiplication_2D(a,b,m): #行列の掛け算(a×b) m:mod
I,J,K,L = len(a),len(b[0]),len(b),len(a[0])
if(L!=K):
return -1
c = [[0] * J for _ in range(I)]
for i in range(I) :
for j in range(J) :
for k in range(K) :
c[i][j] += a[i][k] * b[k][j]
c[i][j] %= m
return c
def matrixExponentiation_2D(x,n,m): #行列の累乗 (x^n) m:mod
y = [[0] * len(x) for _ in range(len(x))]
for i in range(len(x)):
y[i][i] = 1
while n > 0:
if n & 1:
y = matrixMultiplication_2D(x,y,m)
x = matrixMultiplication_2D(x,x,m)
n >>= 1
return y
def twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
# 1 : 一方の円が他方の円を完全に含み、2 つの円は接していない
# 2 : 一方の円が他方の円を完全に含み、2 つの円は接している
# 3 : 2 つの円が互いに交差する
# 4 : 2 つの円の内部に共通部分は存在しないが、2 つの円は接している
# 5 : 2 つの円の内部に共通部分は存在せず、2 つの円は接していない
x1 = A[0]
x2 = B[0]
y1 = A[1]
y2 = B[1]
r1 = A[2]
r2 = B[2]
d = abs((x1-x2)+1j*(y1-y2))
if(abs(r2-r1)>d):
return 1
elif(abs(r2-r1)==d):
return 2
elif(r1+r2>d):
return 3
elif(r1+r2==d):
return 4
elif(r1+r2<d):
return 5
###デバッグ用ライブラリ###
def TS(_str): #変数/リストに格納されている値を確認
print('{}: {}'.format(_str, eval(_str)))
def T2d(A): #二次元配列の確認用
for a in A:
print(*a)
def T3d(A): #三次元配列の確認用
for a in A:
T2d(a)
BR()
def BR(): #横線で区切りを入れる
print("---")
#クラス----------------------------------------------------------------------
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
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):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
#カンニングペーパー-----------------------------------------------------------
'''
###標準ライブラリ###
ceil(a,b): #切り捨て
inv(a,p): #xのpを法とする逆元
transpose(A): #二次元配列の転置
rotate_matrix(A): #グリッドを時計回りに90度回転
removeDuplicates_2D(A): #二次元配列の重複削除
convert(S, c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
例)normalize(convert(h,w,A))
cumulativeSum_1D(A) #配列Aの累積和
cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
string_to_runLength(S: str) #文字列/リストからラングレス圧縮 => [(文字,個数), ...]の二次元リスト
runLength_to_string(L: "list[tuple]") #ラングレス圧縮 => 文字列
bfs(i,G) # i:始点 => dist,pre
bfs01(i,G) # i:始点 => dist
dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
coordinates(A) # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
eng_L() #英小文字のリスト
ENG_L() #英大文字のリスト
bit_len(n): #bit長
bit_cnt(n): # bitにしたときの1の数
idx_le(A, x) # x 以下の最大の要素位置 / なければ "No"
idx_lt(A, x) # x 未満の最大の要素位置 / なければ "No"
idx_ge(A, x) # x 以上の最小の要素位置 / なければ "No"
idx_gt(A, x) # x 超過の最小の要素位置 / なければ "No"
cnt_le(A, x) # x 以下の要素の個数
cnt_lt(A, x) # x 未満の要素の個数
cnt_ge(A, x) # x 以上の要素の個数
cnt_gt(A, x) # x 超過の要素の個数
###数学ライブラリ###
allAND(A): # 配列Aの総AND
allOR(A): # 配列Aの総OR
allXOR(A): # 配列Aの総XOR
allGCD(A): # 配列Aの総GCD
mex(A) #配列Aのmexを求める
gcd(a,b) #aとbの最大公約数を求める
lcm(a,b) #aとbの最小公倍数を求める
extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
fact_L(n,mod): # [0!, 1! ..., n!] を返す
bitCount_L(n): # n以下のそれぞれのbitカウントを返す
factorial(n,m) #nの階乗 | m:mod(デフォなし)
nPr(n,r,m) #順列nPr | m:mod(デフォなし)
nCr(n,r,m) #組み合わせ,nCr | m:mod(デフォなし)
nCrm(n,r,m) #逆元を用いた組み合わせnCr%mod
divisor_L(n) #nの約数のリスト
is_prime(n) #素数判定 => True/False
prime_L(n) #nまでの素数のリスト
primeFactorization_2L(n) #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
floorsqrt(n): # N => ⌊√N⌋
decimal_to_nAry(num_10,n) #10進数からn進数へ変換する(n<=36) |int型 => str型
nAry_to_decimal(num_n,n) #n進数から10進数へ変換する(n<=36) | str型 => int型
roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
###幾何ライブラリ###
dsin(d): #度数法でsinを計算する
dcos(d): #度数法でcosを計算する
rotate(x,y,d,cx,cy): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転(デフォ原点) => [x,y]
findAngle(O,A,B) #∠AOBを求める(弧度法) | 引数はそれぞれ[x,y(=座標)]
outerProduct(Av,Bv) #二次元ベクトルの外積(=符号付面積)を求める(a×b) | 引数はそれぞれ[x,y(=座標)]
CCW(O,A,B) #Oを中心として、Aから見たAとBの位置関係
=> -1:時計回り, 0:一直線上, 1:反時計回り | 引数はそれぞれ[x,y(=座標)]
matrixMultiplication_2D(a,b,m) #行列の掛け算(a×b) m:mod | 引数は二次元リスト
matrixExponentiation_2D(x,n m)#行列の累乗 (x^n) m:mod | 引数は二次元リスト
twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
=> 1, 2, 3, 4, 5 各数字に対応する位置関係の説明は上記参照
###デバッグ用ライブラリ###
TS(_str) # 変数/リストに格納されている値を確認 => 〇〇:××
T2d(A): # 二次元配列の確認用
T3d(A): # 三次元配列の確認用
BR() # 横線で区切りを入れる
###文法チートシート###
|S|<x => "0"*(x-|S|) + S : str(n).zfill(x)
全部大文字に変換：str.upper()
全部小文字に変換：str.lower()
先頭のみ大文字に変換：str.capitalize()
各単語の先頭のみ大文字に変換（タイトルケース）:str.title()
大文字と小文字を入れ替える：str.swapcase()
文字 → ASCIIコード ord(s)
ASCIIコード → 文字 chr(x)
ASCII表
65:A ~ 90:Z
97:a ~ 122:z
'''
#PyPyで再帰関数を用いる場合はコメントを外す----------------------------------
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
#----------------------------------------------------------------------------
N, D = MI()
A = LLI(N)
def isVirus(X1,Y1,X2,Y2):
return ((X1-X2)**2 + (Y1-Y2)**2)**(1/2) <= D
uf = UnionFind(N);
for i in range(N):
for j in range(N):
if(isVirus(A[i][0],A[i][1],A[j][0],A[j][1])):
uf.union(i,j)
dict = uf.all_group_members()
for i in range(N):
if(i in dict[0]):
print('Yes')
else:
print('No')
# Python3/Pypy3テンプレート集
#ライブラリ-------------------------------------------------------------------
from bisect import *
import heapq
import collections
from collections import deque
from queue import Queue
from itertools import groupby
import itertools
import math
import array
import string
import copy
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from functools import reduce
from operator import and_, or_, xor
#便利スクリプト---------------------------------------------------------------
INF = 10**20
mod = 998244353
MOD = 10**9+7
def YesNo(b): print("Yes") if b else print("No")
def YESNO(b): print("YES") if b else print("NO")
#標準入力---------------------------------------------------------------------
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LIS(): return list(map(int, SI()))
def LA(f): return list(map(f, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().strip('\n')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def LMS(rows_number): return [MS() for _ in range(rows_number)]
#関数------------------------------------------------------------------------
###標準ライブラリ###
def ceil(a,b): #切り捨て
return (a+b-1)//b
def inv(a,p): #aのpを法とする逆元(aとpは互いに素)
return pow(a,p-2,p)%p
def transpose(A): #二次元配列の転置
A_t = []
for i in range(len(A[0])) :
tmp = []
for v in A :
tmp.append(v[i])
A_t.append(tmp)
return A_t
def rotate_matrix(A): #グリッドを時計回りに90度回転
return transpose(A[::-1])
def removeDuplicates_2D(A): #二次元配列の重複削除
return list(map(list, set(map(tuple, A))))
def convert(S,c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
s = set()
h = len(S)
w = len(S[0])
for i in range(h):
for j in range(w):
if S[i][j] == c:
s.add((i, j))
return s
def normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
mi = min(i for (i, j) in s)
mj = min(j for (i, j) in s)
return set((i - mi, j - mj) for (i, j) in s)
def cumulativeSum_1D(A): #配列Aの累積和
return list(itertools.accumulate(A))
def cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
h = len(S)
w = len(S[0])
CS = [[0 for _ in range(w)]for _ in range(h)]
CCS = [[0 for _ in range(w)]for _ in range(h)]
for i in range(h):
for j in range(w):
if(j==0):
CS[i][0] = S[i][0]
else:
CS[i][j] = CS[i][j-1] + S[i][j]
for i in range(h):
for j in range(w):
if(i==0):
CCS[0][j] = CS[0][j]
else:
CCS[i][j] = CCS[i-1][j] + CS[i][j]
return CCS
def string_to_runLength(S: str): #文字列/リストからラングレス圧縮
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
def runLength_to_string(L: "list[tuple]"): #ラングレス圧縮から文字列 => 文字だけ
res = ""
for c, n in L:
res += c * int(n)
return res
def bfs(i,G): # i:始点
n = len(G)
dist = [-1] * n
pre = [-1] * n
que = deque()
dist[i] = 0
que.append(i)
while not len(que)==0:
v = que.popleft()
for next_v in G[v]:
if dist[next_v] != -1:
continue
dist[next_v] = dist[v] + 1
pre[next_v] = v
que.append(next_v)
return dist,pre
def bfs01(s, G): # i:始点 => dist
N = len(G)
dist = [INF] * N
S = deque([s])
T = deque()
dist[s] = 0
d = 0
while S:
while S:
v = S.popleft()
for c, w in G[v]:
if d+c < dist[w]:
dist[w] = d+c
if c:
T.append(w)
else:
S.append(w)
S, T = T, S
d += 1
return dist
def dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
n = len(G)
hq = [(0, s)]
heapq.heapify(hq)
cost = [INF]*n
cost[s]= 0
pre = [-1] * n
while hq:
c,v = heapq.heappop(hq)
if c > cost[v]:
continue
for d,u in G[v]:
tmp = d+cost[v]
if tmp < cost[u]:
cost[u] = tmp
pre[u] = v
heapq.heappush(hq,(tmp,u))
return cost, pre
def coordinates(A): # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
B = sorted(set(A))
C = { v: i for i, v in enumerate(B) }
D = { i: v for i, v in enumerate(B) }
E = list(map(lambda v: C[v], A))
return C, D, E
def eng_L(): return list(string.ascii_lowercase)
def ENG_L(): return list(string.ascii_uppercase)
def bit_len(n): #bit長
return n.bit_length()
def bit_cnt(n): # bitにしたときの1の数
cnt = 0
for i in range(bit_len(n)+1):
cnt += n>>i & 1
return cnt
def idx_le(A, x): # x 以下の最大の要素位置 / なければ "No"
return bisect_right(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_lt(A, x): # x 未満の最大の要素位置 / なければ "No"
return bisect_left(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_ge(A, x): # x 以上の最小の要素位置 / なければ "No"
return bisect_left(A, x) if bisect_left(A, x) != len(A) else "No"
def idx_gt(A, x): # x 超過の最小の要素位置 / なければ "No"
return bisect_right(A, x) if bisect_right(A, x) != len(A) else "No"
def cnt_le(A, x): # x 以下の要素の個数
if(idx_le(A, x) == "No"): return 0
return idx_le(A, x) + 1
def cnt_lt(A, x): # x 未満の要素の個数
if(idx_lt(A, x) == "No"): return 0
return idx_lt(A, x) + 1
def cnt_ge(A, x): # x 以上の要素の個数
return len(A) - cnt_lt(A, x)
def cnt_gt(A, x): # x 超過の要素の個数
return len(A) - cnt_le(A, x)
###数学ライブラリ###
def allAND(A): # 配列Aの総AND
return reduce(and_, A)
def allOR(A): # 配列Aの総OR
return reduce(or_, A)
def allXOR(A): # 配列Aの総XOR
return reduce(xor, A)
def allGCD(A): # 配列Aの総GCD
if(len(A)==1):
return A[0]
g = math.gcd(A[0],A[1])
for i in range(1,len(A)):
g = math.gcd(g, A[i])
return g
def mex(A): #配列Aのmexを求める
B = set()
for a in A:
if(a>=0):
B.add(a)
B = list(B)
B.sort()
if(len(B)==0):
return 0
if(B[0]!=0):
return 0
m = 0
for i in range(1,len(B)):
if(B[i]==B[i-1]+1):
m +=1
else:
break
return m +1
def gcd(a,b): #aとbの最大公約数を求める
return math.gcd(a,b)
def lcm(a,b): #aとbの最小公倍数を求める
return a*b//gcd(a,b)
def extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b)*x
return d, x, y
return a, 1, 0
def fact_L(n,mod): # [0!, 1! ..., n!] を返す
fact = [1]
p = 1
for i in range(1,n+1):
p *= i
p %= mod
fact.append(p)
return fact
def bitCount_L(n): # n以下のそれぞれのbitカウントを返す
bitcount = [0] * (n+1)
for i in range(1,n+1):
bitcount[i] = bitcount[i//2] + i%2
return bitcount
def factorial(n, m=0): #nの階乗 | m:mod(デフォなし)
if(n<0):
return -1
elif(n==0):
return 1
P = 1
for i in range(1,n+1):
P *= i
if(m==0):
continue
P %= m
return P
def nPr(n, r, m=0): #順列nPr
if(n<=0 or r<0 or n<r):
return -1
if(r==0):
return 1
P = 1
for i in range(n,n-r,-1):
P *= i
if(m==0):
continue
P %= m
return P
def nCr(n, r, m=0): #組み合わせnCr
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
N = 1
for i in range(r):
N *= n-i
if(m==0):
continue
N %= m
R = factorial(r)
return N//R
def nCrm(n,r,m=mod): #逆元を用いた組み合わせnCr%mod
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
over=1
for i in range(n-r+1,n+1):
over *= i
over %= m
under=1
for i in range(1,r+1):
under *= i
under %= m
return over*pow(under,m-2,m)%m
def is_prime(n): #素数判定 => True/False
if n == 2:
return 1
if n == 1 or n%2 == 0:
return 0
m = n - 1
lsb = m & -m
s = lsb.bit_length()-1
d = m // lsb
test_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in test_numbers:
if a == n:
continue
x = pow(a,d,n)
r = 0
if x == 1:
continue
while x != m:
x = pow(x,2,n)
r += 1
if x == 1 or r == s:
return 0
return 1
def prime_L(n): #n以下の素数のリスト
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
def find_prime_factor(n):
if n%2 == 0:
return 2
m = int(n**0.125)+1
for c in range(1,n):
f = lambda a: (pow(a,2,n)+c)%n
y = 0
g = q = r = 1
k = 0
while g == 1:
x = y
while k < 3*r//4:
y = f(y)
k += 1
while k < r and g == 1:
ys = y
for _ in range(min(m, r-k)):
y = f(y)
q = q*abs(x-y)%n
g = math.gcd(q,n)
k += m
k = r
r *= 2
if g == n:
g = 1
y = ys
while g == 1:
y = f(y)
g = math.gcd(abs(x-y),n)
if g == n:
continue
if is_prime(g):
return g
elif is_prime(n//g):
return n//g
else:
return find_prime_factor(g)
def primeFactorization_2L(n): #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
if(n<=10**6):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
else:
res = {}
while not is_prime(n) and n > 1:
p = find_prime_factor(n)
s = 0
while n%p == 0:
n //= p
s += 1
res[p] = s
if n > 1:
res[n] = 1
R = []
for r in res:
R.append([r,res[r]])
R.sort()
return R
def divisor_L(n): #nまでの約数のリスト
if(n==1):
return [1]
if(n<=10**6):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
else:
L = primeFactorization_2L(n)
E = [[]for i in range(len(L))]
for i in range(len(L)):
for j in range(L[i][1]+1):
E[i].append(L[i][0]**j)
D = []
for p in list(itertools.product(*E)):
s = 1
for v in p:
s *= v
D.append(s)
D.sort()
return D
def floorsqrt(n): # N => ⌊√N⌋
# only for n <= 10 ** 18
ok = 10 ** 9 + 10
ng = 0
while ok - ng > 1:
t = (ok + ng) // 2
if t * t > n: ok = t
else: ng = t
return ng
def decimal_to_nAry(num_10,n): #10進数からn進数へ変換する(n<=36) |int型 => str型
str_n = []
while num_10:
if num_10%n >= 10:
str_n.append(chr(num_10%n+55))
else:
str_n.append(str(num_10%n))
num_10 //= n
return "".join(str_n[::-1])
def nAry_to_decimal(X,n): #n進数から10進数へ変換する(n<=36) | str型 => int型
num = 0
X = X.upper()
X = list(X)
for i in range(len(X)):
if(("0"<=X[i]<="9")==False):
X[i] = str(ord(X[i]) - 55)
for i in range(1,len(X)+1):
num += int(X[-i]) * pow(n, (i-1))
return num
def roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
return float(Decimal(x).quantize(Decimal(f"1E{d}"), rounding=ROUND_HALF_UP))
###幾何ライブラリ###
def dsin(d): #度数法でsinを計算する
return math.sin(math.radians(d))
def dcos(d): #度数法でcosを計算する
return math.cos(math.radians(d))
def rotate(x,y,d,cx=0,cy=0): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転 => [x,y]
nx = (x-cx)*dcos(d)-(y-cy)*dsin(d)
ny = (x-cx)*dsin(d)+(y-cy)*dcos(d)
return [nx+cx,ny+cy]
def findAngle(O,A,B): #∠AOBを求める(弧度法)
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
u = s[0]*t[0]+s[1]*t[1]
l = (s[0]**2+s[1]**2)**(1/2) * (t[0]**2+t[1]**2)**(1/2)
v = u/l
t = math.degrees(math.acos(v))
return t
def outerProduct(Av,Bv): #二次元ベクトルの外積(=符号付面積)を求める(a×b)
return Av[0]*Bv[1] - Bv[0]*Av[1]
def CCW(O,A,B): #Oを中心として、Aから見たAとBの位置関係を求める。
# -1: 時計回り, 0: 一直線上, 1: 反時計回り
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
op = outerProduct(s,t)
if(op > 0): return 1
if(op < 0): return -1
if(op == 0): return 0
def matrixMultiplication_2D(a,b,m): #行列の掛け算(a×b) m:mod
I,J,K,L = len(a),len(b[0]),len(b),len(a[0])
if(L!=K):
return -1
c = [[0] * J for _ in range(I)]
for i in range(I) :
for j in range(J) :
for k in range(K) :
c[i][j] += a[i][k] * b[k][j]
c[i][j] %= m
return c
def matrixExponentiation_2D(x,n,m): #行列の累乗 (x^n) m:mod
y = [[0] * len(x) for _ in range(len(x))]
for i in range(len(x)):
y[i][i] = 1
while n > 0:
if n & 1:
y = matrixMultiplication_2D(x,y,m)
x = matrixMultiplication_2D(x,x,m)
n >>= 1
return y
def twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
# 1 : 一方の円が他方の円を完全に含み、2 つの円は接していない
# 2 : 一方の円が他方の円を完全に含み、2 つの円は接している
# 3 : 2 つの円が互いに交差する
# 4 : 2 つの円の内部に共通部分は存在しないが、2 つの円は接している
# 5 : 2 つの円の内部に共通部分は存在せず、2 つの円は接していない
x1 = A[0]
x2 = B[0]
y1 = A[1]
y2 = B[1]
r1 = A[2]
r2 = B[2]
d = abs((x1-x2)+1j*(y1-y2))
if(abs(r2-r1)>d):
return 1
elif(abs(r2-r1)==d):
return 2
elif(r1+r2>d):
return 3
elif(r1+r2==d):
return 4
elif(r1+r2<d):
return 5
###デバッグ用ライブラリ###
def TS(_str): #変数/リストに格納されている値を確認
print('{}: {}'.format(_str, eval(_str)))
def T2d(A): #二次元配列の確認用
for a in A:
print(*a)
def T3d(A): #三次元配列の確認用
for a in A:
T2d(a)
BR()
def BR(): #横線で区切りを入れる
print("---")
#クラス----------------------------------------------------------------------
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
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):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
#カンニングペーパー-----------------------------------------------------------
'''
###標準ライブラリ###
ceil(a,b): #切り捨て
inv(a,p): #xのpを法とする逆元
transpose(A): #二次元配列の転置
rotate_matrix(A): #グリッドを時計回りに90度回転
removeDuplicates_2D(A): #二次元配列の重複削除
convert(S, c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
例)normalize(convert(h,w,A))
cumulativeSum_1D(A) #配列Aの累積和
cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
string_to_runLength(S: str) #文字列/リストからラングレス圧縮 => [(文字,個数), ...]の二次元リスト
runLength_to_string(L: "list[tuple]") #ラングレス圧縮 => 文字列
bfs(i,G) # i:始点 => dist,pre
bfs01(i,G) # i:始点 => dist
dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
coordinates(A) # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
eng_L() #英小文字のリスト
ENG_L() #英大文字のリスト
bit_len(n): #bit長
bit_cnt(n): # bitにしたときの1の数
idx_le(A, x) # x 以下の最大の要素位置 / なければ "No"
idx_lt(A, x) # x 未満の最大の要素位置 / なければ "No"
idx_ge(A, x) # x 以上の最小の要素位置 / なければ "No"
idx_gt(A, x) # x 超過の最小の要素位置 / なければ "No"
cnt_le(A, x) # x 以下の要素の個数
cnt_lt(A, x) # x 未満の要素の個数
cnt_ge(A, x) # x 以上の要素の個数
cnt_gt(A, x) # x 超過の要素の個数
###数学ライブラリ###
allAND(A): # 配列Aの総AND
allOR(A): # 配列Aの総OR
allXOR(A): # 配列Aの総XOR
allGCD(A): # 配列Aの総GCD
mex(A) #配列Aのmexを求める
gcd(a,b) #aとbの最大公約数を求める
lcm(a,b) #aとbの最小公倍数を求める
extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
fact_L(n,mod): # [0!, 1! ..., n!] を返す
bitCount_L(n): # n以下のそれぞれのbitカウントを返す
factorial(n,m) #nの階乗 | m:mod(デフォなし)
nPr(n,r,m) #順列nPr | m:mod(デフォなし)
nCr(n,r,m) #組み合わせ,nCr | m:mod(デフォなし)
nCrm(n,r,m) #逆元を用いた組み合わせnCr%mod
divisor_L(n) #nの約数のリスト
is_prime(n) #素数判定 => True/False
prime_L(n) #nまでの素数のリスト
primeFactorization_2L(n) #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
floorsqrt(n): # N => ⌊√N⌋
decimal_to_nAry(num_10,n) #10進数からn進数へ変換する(n<=36) |int型 => str型
nAry_to_decimal(num_n,n) #n進数から10進数へ変換する(n<=36) | str型 => int型
roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
###幾何ライブラリ###
dsin(d): #度数法でsinを計算する
dcos(d): #度数法でcosを計算する
rotate(x,y,d,cx,cy): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転(デフォ原点) => [x,y]
findAngle(O,A,B) #∠AOBを求める(弧度法) | 引数はそれぞれ[x,y(=座標)]
outerProduct(Av,Bv) #二次元ベクトルの外積(=符号付面積)を求める(a×b) | 引数はそれぞれ[x,y(=座標)]
CCW(O,A,B) #Oを中心として、Aから見たAとBの位置関係
=> -1:時計回り, 0:一直線上, 1:反時計回り | 引数はそれぞれ[x,y(=座標)]
matrixMultiplication_2D(a,b,m) #行列の掛け算(a×b) m:mod | 引数は二次元リスト
matrixExponentiation_2D(x,n m)#行列の累乗 (x^n) m:mod | 引数は二次元リスト
twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
=> 1, 2, 3, 4, 5 各数字に対応する位置関係の説明は上記参照
###デバッグ用ライブラリ###
TS(_str) # 変数/リストに格納されている値を確認 => 〇〇:××
T2d(A): # 二次元配列の確認用
T3d(A): # 三次元配列の確認用
BR() # 横線で区切りを入れる
###文法チートシート###
|S|<x => "0"*(x-|S|) + S : str(n).zfill(x)
全部大文字に変換：str.upper()
全部小文字に変換：str.lower()
先頭のみ大文字に変換：str.capitalize()
各単語の先頭のみ大文字に変換（タイトルケース）:str.title()
大文字と小文字を入れ替える：str.swapcase()
文字 → ASCIIコード ord(s)
ASCIIコード → 文字 chr(x)
ASCII表
65:A ~ 90:Z
97:a ~ 122:z
'''
#PyPyで再帰関数を用いる場合はコメントを外す----------------------------------
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
#----------------------------------------------------------------------------
N, D = MI()
A = LLI(N)
def isVirus(X1,Y1,X2,Y2):
return ((X1-X2)**2 + (Y1-Y2)**2)**(1/2) <= D
uf = UnionFind(N);
for i in range(N):
for j in range(N):
if(isVirus(A[i][0],A[i][1],A[j][0],A[j][1])):
uf.union(i,j)
dict = uf.all_group_members()
for i in range(N):
if(i in dict[uf.find(0)]):
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc304_c/Python/45117916
|
condefects-python_data_1171
|
string = input()
start = string.find("|", 0)
end = string.find("|", start + 1) + 1
if not(start == (end - 2)): string = string.replace(string[start:end+1], "")
else: string = string.replace("|", "")
print(string)
string = input()
start = string.find("|", 0)
end = string.find("|", start + 1) + 1
if not(start == (end - 2)): string = string.replace(string[start:end], "")
else: string = string.replace("|", "")
print(string)
|
ConDefects/ConDefects/Code/abc344_a/Python/54865781
|
condefects-python_data_1172
|
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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
def dfs(x):
visited[x] = True
for to_x in to[x]:
if not visited[to_x]:
dfs(to_x)
for i in S[to_x]:
if len(S[x]) < 20:
S[x].add(i)
else:
m = min(S[to_x])
if i > m:
S[x].discard(m)
S[x].add(i)
################################################################
import sys; sys.setrecursionlimit(10**8)
N,Q = map(int,input().split())
X = [""] + list(map(int,input().split()))
to = [[] for _ in range(N+1)]
for _ in range(N-1):
A,B = map(int,input().split())
to[B].append(A); to[A].append(B)
S = [SortedMultiset([X[i]]) for i in range(N+1)]
visited = [False for _ in range(N+1)]
dfs(1)
for _ in range(Q):
V,K = map(int,input().split())
print(S[V][len(S[V])-K])
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedMultiset(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 SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(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 "SortedMultiset" + 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 count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
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
def dfs(x):
visited[x] = True
for to_x in to[x]:
if not visited[to_x]:
dfs(to_x)
for i in S[to_x]:
if len(S[x]) < 20:
S[x].add(i)
else:
m = min(S[x])
if i > m:
S[x].discard(m)
S[x].add(i)
################################################################
import sys; sys.setrecursionlimit(10**8)
N,Q = map(int,input().split())
X = [""] + list(map(int,input().split()))
to = [[] for _ in range(N+1)]
for _ in range(N-1):
A,B = map(int,input().split())
to[B].append(A); to[A].append(B)
S = [SortedMultiset([X[i]]) for i in range(N+1)]
visited = [False for _ in range(N+1)]
dfs(1)
for _ in range(Q):
V,K = map(int,input().split())
print(S[V][len(S[V])-K])
|
ConDefects/ConDefects/Code/abc239_e/Python/45522067
|
condefects-python_data_1173
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
q=[0]*n
for i in range(n):
p[i]-=1
q[p[i]]=i
e=[]
for i in range(n):
r=[j for j in range(i) if q[j]-q[i]>=k]
s=i
for t in r[::-1]:
q[s],q[t]=q[s],q[t]
e+=[(q[s],q[t])]
s=t
print(len(e))
for i,j in e:
print(i+1,j+1)
n,k=map(int,input().split())
p=list(map(int,input().split()))
q=[0]*n
for i in range(n):
p[i]-=1
q[p[i]]=i
e=[]
for i in range(n):
r=[j for j in range(i) if q[j]-q[i]>=k]
s=i
for t in r[::-1]:
e+=[(q[s],q[t])]
q[s],q[t]=q[t],q[s]
s=t
print(len(e))
for i,j in e:
print(i+1,j+1)
|
ConDefects/ConDefects/Code/arc180_b/Python/55029920
|
condefects-python_data_1174
|
# ﷽
from collections import deque
import sys
input = lambda: sys.stdin.readline().strip()
def inlst():return [int(i) for i in input().split()]
oo=float('inf')
def solve():
n,k=inlst()
lst=inlst()
q=[0]*n
for i,e in enumerate(lst):
q[e-1]=i
ans=deque()
for i in range(n):
cur=i
for j in range(i-1,-1,-1):
if q[j]-q[cur]>=k:
ans.append(( q[j]+1,q[cur]+1))
q[cur],q[j]=q[j],q[cur]
cur=j
print(len(ans))
for a in ans:print(*a)
def main():
# for i in range(int(input())):
solve()
if __name__ == "__main__":
main()
# ﷽
from collections import deque
import sys
input = lambda: sys.stdin.readline().strip()
def inlst():return [int(i) for i in input().split()]
oo=float('inf')
def solve():
n,k=inlst()
lst=inlst()
q=[0]*n
for i,e in enumerate(lst):
q[e-1]=i
ans=deque()
for i in range(n):
cur=i
for j in range(i-1,-1,-1):
if q[j]-q[cur]>=k:
ans.append((q[cur]+1, q[j]+1))
q[cur],q[j]=q[j],q[cur]
cur=j
print(len(ans))
for a in ans:print(*a)
def main():
# for i in range(int(input())):
solve()
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/arc180_b/Python/55028160
|
condefects-python_data_1175
|
from fractions import Fraction
inf = float("inf")
N = int(input())
X = []
for _ in range(N):
x, y = map(int, input().split())
a1 = x
b1 = y - 1
t1 = Fraction(b1, a1)
a2 = x-1
b2 = y
if a2 == 0:
t2 = inf
else:
t2 = Fraction(b2, a2)
X.append((t1, t2))
X.sort(key=lambda x:x[1])
ans = 0
R = -inf
for l, r in X:
if r > R:
ans += 1
R = r
print(ans)
from fractions import Fraction
inf = float("inf")
N = int(input())
X = []
for _ in range(N):
x, y = map(int, input().split())
a1 = x
b1 = y - 1
t1 = Fraction(b1, a1)
a2 = x-1
b2 = y
if a2 == 0:
t2 = inf
else:
t2 = Fraction(b2, a2)
X.append((t1, t2))
X.sort(key=lambda x:x[1])
ans = 0
R = -inf
for l, r in X:
if l >= R:
ans += 1
R = r
print(ans)
|
ConDefects/ConDefects/Code/abc225_e/Python/45312408
|
condefects-python_data_1176
|
n = int(input())
A = list(map(int, input().split()))
for i in range(2000):
if i not in A:
print(i)
break
n = int(input())
A = list(map(int, input().split()))
for i in range(2001):
if i not in A:
print(i)
break
|
ConDefects/ConDefects/Code/abc245_b/Python/45497244
|
condefects-python_data_1177
|
N = int(input())
A = set(map(int, input().split()))
for i in range(2000):
if i not in A:
print(i)
break
N = int(input())
A = set(map(int, input().split()))
for i in range(2001):
if i not in A:
print(i)
break
|
ConDefects/ConDefects/Code/abc245_b/Python/45513233
|
condefects-python_data_1178
|
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
if i not in A:
print(i)
break
N = int(input())
A = list(map(int,input().split()))
for i in range(2001):
if i not in A:
print(i)
break
|
ConDefects/ConDefects/Code/abc245_b/Python/45550937
|
condefects-python_data_1179
|
n=int(input())
a=list(map(int,input().split()))
a.sort()
if(n>=2):
a=a[1:]
cnt=0
ans='Yes'
for i in range(max(1,n-1)):
if(i>=1 and a[i]==a[i-1]):
cnt+=1
else:
cnt=1
if(cnt>=(n+1)//2):
ans='No'
break
print(ans)
n=int(input())
a=list(map(int,input().split()))
a.sort()
if(n>=2):
a=a[1:]
cnt=0
ans='Yes'
for i in range(n-1):
if(i>=1 and a[i]==a[i-1]):
cnt+=1
else:
cnt=1
if(cnt>=(n+1)//2):
ans='No'
break
print(ans)
|
ConDefects/ConDefects/Code/arc161_a/Python/44901264
|
condefects-python_data_1180
|
N=int(input())
A=list(map(int,input().split()))
A.sort()
if N==1:
print("Yes")
exit()
B=[0]*N
for i in range(N):
if i<=N//2:
B[2*i]=A[i]
else:
B[2*i-N]=A[i]
for i in range(N):
if i%2!=0:
continue
if B[i-1]<B[i] and B[i]>B[i+1]:
continue
else:
print("No")
break
else:
print("Yes")
N=int(input())
A=list(map(int,input().split()))
A.sort()
if N==1:
print("Yes")
exit()
B=[0]*N
for i in range(N):
if i<=N//2:
B[2*i]=A[i]
else:
B[2*i-N]=A[i]
for i in range(N):
if i%2==0:
continue
if B[i-1]<B[i] and B[i]>B[i+1]:
continue
else:
print("No")
break
else:
print("Yes")
|
ConDefects/ConDefects/Code/arc161_a/Python/45669630
|
condefects-python_data_1181
|
n=int(input())
a=[]
a=list(map(int,input().split()))
a.sort()
c1=0
c2=0
for i in range(n//2,-1,-1):
if a[i]==a[n//2]:
c1+=1
else:
break
for i in range(n//2+1,n):
if a[i]==a[n//2]:
c2+=1
else:
break
if (n+1)//2-c1>c2:
print("Yes")
else:
print("No")
n=int(input())
a=[]
a=list(map(int,input().split()))
a.sort()
c1=0
c2=0
for i in range(n//2,-1,-1):
if a[i]==a[n//2]:
c1+=1
else:
break
for i in range(n//2+1,n):
if a[i]==a[n//2]:
c2+=1
else:
break
if (n+1)//2-c1>c2 or c2==0:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/arc161_a/Python/46209025
|
condefects-python_data_1182
|
n = int(input())
A = list(map(int,input().split()))
if n==1:
print("")
exit()
for i in range(n-1):
if A[i] > A[i+1]:
x = A[i]
break
else:
x = A[i]
print(*[a for a in A if a!=x])
n = int(input())
A = list(map(int,input().split()))
if n==1:
print("")
exit()
for i in range(n-1):
if A[i] > A[i+1]:
x = A[i]
break
else:
x = A[i+1]
print(*[a for a in A if a!=x])
|
ConDefects/ConDefects/Code/arc133_a/Python/46026088
|
condefects-python_data_1183
|
import sys
input = sys.stdin.buffer.readline
# def input(): return sys.stdin.readline().rstrip()
# sys.setrecursionlimit(10 ** 7)
N = int(input())
A = list(map(int, (input().split())))
def f(x):
a = []
for i in range(N):
if A[i]!=x:
a.append(A[i])
return a
x = A[-1]
for i in range(N-1):
if A[i]>A[i+1]:
x = i
break
a = f(x)
print(*a)
import sys
input = sys.stdin.buffer.readline
# def input(): return sys.stdin.readline().rstrip()
# sys.setrecursionlimit(10 ** 7)
N = int(input())
A = list(map(int, (input().split())))
def f(x):
a = []
for i in range(N):
if A[i]!=x:
a.append(A[i])
return a
x = A[-1]
for i in range(N-1):
if A[i]>A[i+1]:
x = A[i]
break
a = f(x)
print(*a)
|
ConDefects/ConDefects/Code/arc133_a/Python/42717104
|
condefects-python_data_1184
|
N = int(input())
A = list(map(int, input().split()))
tmp = A[0]
for i in range(1, N):
if tmp > A[i]: continue
tmp = A[i]
for i in A:
if i != tmp:
print(i, end=" ")
print()
N = int(input())
A = list(map(int, input().split()))
tmp = A[0]
for i in range(1, N):
if tmp > A[i]: break
tmp = A[i]
for i in A:
if i != tmp:
print(i, end=" ")
print()
|
ConDefects/ConDefects/Code/arc133_a/Python/42236836
|
condefects-python_data_1185
|
n=int(input())
a=list(map(int,input().split()))
if a.count(a[0])==n:
print()
exit()
ind=0
pre=0
d=dict()
while ind!=n:
cnt=0
pre=ind-1
while ind!=n-1 and a[ind]==a[ind+1]:ind+=1
if ind==n-1:break
# print(pre,ind)
if pre!=-1 and a[pre]>a[ind] and d.get(a[pre],0)<=1:
ans=[]
for i in range(n):
if a[i]!=a[pre]:ans.append(a[i])
print(*ans)
exit()
# print(ind)
if a[ind] not in d:d[a[ind]]=1
else:d[a[ind]]+=1
# print(d)
ind+=1
mx=max(a)
ans=[]
for i in range(n):
if a[i]!=mx:ans.append(a[i])
print(*a)
n=int(input())
a=list(map(int,input().split()))
if a.count(a[0])==n:
print()
exit()
ind=0
pre=0
d=dict()
while ind!=n:
cnt=0
pre=ind-1
while ind!=n-1 and a[ind]==a[ind+1]:ind+=1
if ind==n-1:break
# print(pre,ind)
if pre!=-1 and a[pre]>a[ind] and d.get(a[pre],0)<=1:
ans=[]
for i in range(n):
if a[i]!=a[pre]:ans.append(a[i])
print(*ans)
exit()
# print(ind)
if a[ind] not in d:d[a[ind]]=1
else:d[a[ind]]+=1
# print(d)
ind+=1
mx=max(a)
ans=[]
for i in range(n):
if a[i]!=mx:ans.append(a[i])
print(*ans)
|
ConDefects/ConDefects/Code/arc133_a/Python/41861434
|
condefects-python_data_1186
|
n = int(input())
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
conn = [len(graph[i]) for i in range(n+1)]
leaf = []
for i in range(1,n+1):
if conn[i] == 1:
leaf.append(i)
ans = [0 for i in range(n+1)]
while len(leaf) >= 2:
x = leaf.pop()
y = leaf.pop()
ans[x] = y
ans[y] = x
for xy in graph[x]:
if conn[xy] > 1:
conn[xy] -= 1
if conn[xy] == 1:
leaf.append(xy)
for yx in graph[x]:
if conn[yx] > 1:
conn[yx] -= 1
if conn[yx] == 1:
leaf.append(yx)
if len(leaf) == 1:
ans[leaf[0]] = leaf[0]
print(*ans[1:])
n = int(input())
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
conn = [len(graph[i]) for i in range(n+1)]
leaf = []
for i in range(1,n+1):
if conn[i] == 1:
leaf.append(i)
ans = [0 for i in range(n+1)]
while len(leaf) >= 2:
x = leaf.pop()
y = leaf.pop()
ans[x] = y
ans[y] = x
for xy in graph[x]:
if conn[xy] > 1:
conn[xy] -= 1
if conn[xy] == 1:
leaf.append(xy)
for yx in graph[y]:
if conn[yx] > 1:
conn[yx] -= 1
if conn[yx] == 1:
leaf.append(yx)
if len(leaf) == 1:
ans[leaf[0]] = leaf[0]
print(*ans[1:])
|
ConDefects/ConDefects/Code/arc156_c/Python/38986255
|
condefects-python_data_1187
|
n = int(input())
ans = []
import collections
suu = collections.deque(range(1,n+1))
for i in range(n):
if i % 2 == 0:
ans.append(suu.popleft())
else:
ans.append(suu.pop())
#print(ans)
for i in range(n):
print(*ans)
for j in range(n):
ans[j] += 5
n = int(input())
ans = []
import collections
suu = collections.deque(range(1,n+1))
for i in range(n):
if i % 2 == 0:
ans.append(suu.popleft())
else:
ans.append(suu.pop())
#print(ans)
for i in range(n):
print(*ans)
for j in range(n):
ans[j] += n
|
ConDefects/ConDefects/Code/arc142_b/Python/36923533
|
condefects-python_data_1188
|
n=int(input())
a=[[i*n+j+1 for j in range(n)]for i in range(n)]
# for i in a:print(i)
for i in range(n):
if i%2==0:continue
for j in range(n//2):
a[i][2*j],a[i][2*j+1]=a[i][2*j+1],a[i][2*j]
for i in a:print(*i)
n=int(input())
a=[[i*n+j+1 for j in range(n)]for i in range(n)]
# for i in a:print(i)
for i in range(n):
# if i%2==0:continue
for j in range(n//2):
a[i][2*j],a[i][2*j+1]=a[i][2*j+1],a[i][2*j]
for i in a:print(*i)
|
ConDefects/ConDefects/Code/arc142_b/Python/43401988
|
condefects-python_data_1189
|
N=int(input())
A=[]
for i in range(N):
C,D=[],[]
for j in range(1,N+1):
n=3*i+j
if len(C)<(N+1)//2:
C.append(n)
else:
D.append(n)
ans=''
for j in range(1,N+1):
if j%2==1:
ans+=str(C[j//2])
else:
ans+=str(D[(j-1)//2])
ans+=' '
print(ans)
N=int(input())
A=[]
for i in range(N):
C,D=[],[]
for j in range(1,N+1):
n=N*i+j
if len(C)<(N+1)//2:
C.append(n)
else:
D.append(n)
ans=''
for j in range(1,N+1):
if j%2==1:
ans+=str(C[j//2])
else:
ans+=str(D[(j-1)//2])
ans+=' '
print(ans)
|
ConDefects/ConDefects/Code/arc142_b/Python/43257604
|
condefects-python_data_1190
|
N = int(input())
S,T = [], []
for i in range(N):
if i % 2 == 1:
S.append([i*N+x+1 for x in range(N)])
else:
T.append([i*N+x+1 for x in range(N)])
for s, t in zip(S,T):
print(*s)
print(*t)
N = int(input())
S,T = [], []
for i in range(N):
if i % 2 == 1:
S.append([i*N+x+1 for x in range(N)])
else:
T.append([i*N+x+1 for x in range(N)])
for s, t in zip(S,T):
print(*s)
print(*t)
if N % 2 == 1:
print(*T[-1])
|
ConDefects/ConDefects/Code/arc142_b/Python/44212876
|
condefects-python_data_1191
|
n=int(input())
k=list(range(n))
x=[0]*n
x[0::2]=k[n//2:]
x[1::2]=k[:n//2]
for i in x:
print(*list(range(i*n,(i+1)*n)))
n=int(input())
k=list(range(n))
x=[0]*n
x[0::2]=k[n//2:]
x[1::2]=k[:n//2]
for i in x:
print(*list(range(i*n+1,(i+1)*n+1)))
|
ConDefects/ConDefects/Code/arc142_b/Python/43475268
|
condefects-python_data_1192
|
from math import ceil
n=int(input())
l=[*range(1,n*n+1)]
idx=0
hlf=ceil(n*n/2)
for i in range(n//2):
print(*l[idx:idx+n])
print(*l[idx+hlf:hlf+idx+n])
idx+=n
if n//2!=n/2:
print(*l[idx:idx+n])
from math import ceil
n=int(input())
l=[*range(1,n*n+1)]
idx=0
hlf=n*ceil(n/2)
for i in range(n//2):
print(*l[idx:idx+n])
print(*l[idx+hlf:hlf+idx+n])
idx+=n
if n//2!=n/2:
print(*l[idx:idx+n])
|
ConDefects/ConDefects/Code/arc142_b/Python/43208367
|
condefects-python_data_1193
|
n = int(input())
n-=1
"""
九桁で、
1 2
5 6
7 9 が同じ数字でないといけない。
"""
# 1,2 5,6 7,9
#3 4 8は何でもいい
l = 100000
while n != 0:
l += 1
l %= 1000000
n -= 1
print(l)
ans = ["" for i in range(9)]
l_s = list(str(l))
ans[0] = l_s[0]
ans[1] = l_s[0]
ans[4] = l_s[3]
ans[5] = l_s[3]
ans[6] = l_s[4]
ans[8] = l_s[4]
ans[2] = l_s[1]
ans[3] = l_s[2]
ans[7] = l_s[5]
print("".join(ans))
n = int(input())
n-=1
"""
九桁で、
1 2
5 6
7 9 が同じ数字でないといけない。
"""
# 1,2 5,6 7,9
#3 4 8は何でもいい
l = 100000
while n != 0:
l += 1
l %= 1000000
n -= 1
#print(l)
ans = ["" for i in range(9)]
l_s = list(str(l))
ans[0] = l_s[0]
ans[1] = l_s[0]
ans[4] = l_s[3]
ans[5] = l_s[3]
ans[6] = l_s[4]
ans[8] = l_s[4]
ans[2] = l_s[1]
ans[3] = l_s[2]
ans[7] = l_s[5]
print("".join(ans))
|
ConDefects/ConDefects/Code/arc153_a/Python/45913281
|
condefects-python_data_1194
|
N=int(input())
cnt=0
#AABCDDEFE
for i in range(100000,999999):
cnt+=1
if cnt==N:
print(int(str(i)[0]+str(i)[0]+str(i)[1]+str(i)[2]+str(i)[3]+str(i)[3]+str(i)[4]+str(i)[5]+str(i)[4]))
exit()
N=int(input())
cnt=0
#AABCDDEFE
for i in range(100000,1000000):
cnt+=1
if cnt==N:
print(int(str(i)[0]+str(i)[0]+str(i)[1]+str(i)[2]+str(i)[3]+str(i)[3]+str(i)[4]+str(i)[5]+str(i)[4]))
exit()
|
ConDefects/ConDefects/Code/arc153_a/Python/41006180
|
condefects-python_data_1195
|
N = int(input())
n = N + 100000 - 1
a, b, c, d, e, f = str(n)
P = f"{a}{a}{b}{b}{c}{d}{d}{e}{f}{e}"
print(P)
N = int(input())
n = N + 100000 - 1
a, b, c, d, e, f = str(n)
P = f"{a}{a}{b}{c}{d}{d}{e}{f}{e}"
print(P)
|
ConDefects/ConDefects/Code/arc153_a/Python/44669278
|
condefects-python_data_1196
|
#https://atcoder.jp/contests/arc153/tasks/arc153_a
N = int(input())
A, B, C, D, E, F = str(100_000 + (N - 1))
ANS = "".join((A, A, B, C, D, D, E, F, E))
print(str(100_000 + (N - 1)))
#https://atcoder.jp/contests/arc153/tasks/arc153_a
N = int(input())
A, B, C, D, E, F = str(100_000 + (N - 1))
ANS = "".join((A, A, B, C, D, D, E, F, E))
print(ANS)
|
ConDefects/ConDefects/Code/arc153_a/Python/40626179
|
condefects-python_data_1197
|
x = int(input())
if x % 10 == 0:
print(x)
else:
print(x // 10 + 1)
x = int(input())
if x % 10 == 0:
print(x // 10)
else:
print(x // 10 + 1)
|
ConDefects/ConDefects/Code/abc345_b/Python/54913953
|
condefects-python_data_1198
|
X = int(input())
if X < 0:
result = int(X//10)
else:
result = int(X//10 + 1)
print(result)
X = int(input())
if X % 10 == 0:
result = int(X//10)
else:
result = int(X//10 + 1)
print(result)
|
ConDefects/ConDefects/Code/abc345_b/Python/54914858
|
condefects-python_data_1199
|
def main():
n = int(input())
print(n // 10)
if __name__ == '__main__':
main()
def main():
n = int(input())
print(-(-n // 10))
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc345_b/Python/54904819
|
condefects-python_data_1200
|
x = int(input())
if x % 10 == 0:
print(int(x / 10))
else:
print(int(x // 10 + 1))
x = int(input())
if x % 10 == 0:
print(int(x // 10))
else:
print(int(x // 10 + 1))
|
ConDefects/ConDefects/Code/abc345_b/Python/54787477
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.