id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_2301
|
MOD = 998244353
N, M = map(int, input().split())
ans = 0
for i in range(60):
if (M >> i) & 1:
ans += M // (1 << (i + 1)) * (1 << i) + max(0, (M % (1 << (i + 1))) - (1 << i) + 1)
ans %= MOD
print(ans)
MOD = 998244353
N, M = map(int, input().split())
ans = 0
for i in range(60):
if (M >> i) & 1:
ans += N // (1 << (i + 1)) * (1 << i) + max(0, (N % (1 << (i + 1))) - (1 << i) + 1)
ans %= MOD
print(ans)
|
ConDefects/ConDefects/Code/abc356_d/Python/55124661
|
condefects-python_data_2302
|
N,M = map(int,input().split())
MOD = 998244353
ret = 0
for i in range(60):
if(M and 2**i):
tmp = N // ((2**i)*2)
ret = ret + tmp*(2**i)
tmp = N % ((2**i)*2)
if(tmp >= (2**i)):
ret = ret + tmp - (2**i) + 1
ret = ret % MOD
print(ret)
N,M = map(int,input().split())
MOD = 998244353
ret = 0
for i in range(60):
if(M & 2**i):
tmp = N // ((2**i)*2)
ret = ret + tmp*(2**i)
tmp = N % ((2**i)*2)
if(tmp >= (2**i)):
ret = ret + tmp - (2**i) + 1
ret = ret % MOD
print(ret)
|
ConDefects/ConDefects/Code/abc356_d/Python/55026737
|
condefects-python_data_2303
|
import sys
import time
import collections
import itertools
import bisect
import copy
import math
import heapq
import random
from collections import deque, Counter, defaultdict
from itertools import accumulate, combinations, permutations, product
from functools import lru_cache
from heapq import heapify, heappush, heappop
from bisect import bisect_right, bisect_left
from copy import deepcopy
sys.setrecursionlimit((1 << 31) - 1)
#sys.set_int_max_str_digits(0)
input = lambda: sys.stdin.readline().rstrip()
INF = float('inf')
MOD = 998244353
DIR = [(1, 0), (-1, 0), (0, 1), (0, -1)]
DX = [1, 0, -1, 0, 1, 1, -1, -1]
DY = [0, 1, 0, -1, 1, -1, 1, -1]
def bisect_left_reverse(a, x):
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
def bisect_right_reverse(a, x):
if a[0] < x:
return 0
if x <= a[-1]:
return len(a)
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] < x:
ok = mid
else:
ng = mid
return ok
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 = collections.defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
class SegTree:
''' 点代入/区間総和
操作 segfunc 単位元
最小値 min(x, y) float('inf')
最大値 max(x, y) -float('inf')
区間和 x + y 0
区間積 x * y 1
最大公約数 math.gcd(x, y) 0
segfunc : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : k番目の値にxを加算
update : k番目の値をxに更新
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
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 segfunc(self, x, y):
return x+y
def add(self, k, x):
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 update(self, k, x):
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):
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
class LazySegTree_RAQ:
''' 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : 区間[l,r)の値にxを加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*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 segfunc(self, x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v == 0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self, l, r, x):
ids = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r & 1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self, l, r):
self.propagates(*self.gindex(l, r))
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
class LazySegTree_RUQ:
''' 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
update : 区間[l,r)の値をxに加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
if segfunc is not None:
self.segfunc = segfunc
self.tree = [ide_ele]*2*self.num
self.lazy = [None]*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 segfunc(self, x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[i] = None
self.lazy[2*i] = v
self.lazy[2*i+1] = v
self.tree[2*i] = v
self.tree[2*i+1] = v
def update(self, l, r, x):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.tree[l] = x
l += 1
if r & 1:
self.lazy[r-1] = x
self.tree[r-1] = x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def query(self, l, r):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
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
def main():
N,M=map(int,input().split())
ans=0
#for i in range(N+1):
# print(format(i, "010b"))
n2 = bin(N)[2:]
m2 = bin(M)[2:]
print(n2)
print(m2)
for i in range(min(len(n2),len(m2))):
i += 1
if m2[-i] == "0": continue
r = 2**i
div = (N+1)//r
rest = (N+1) - r*div
harf = r // 2
ans += div*harf + max(0,rest - harf)
print(ans%998244353)
return
if __name__ == '__main__':
main()
import sys
import time
import collections
import itertools
import bisect
import copy
import math
import heapq
import random
from collections import deque, Counter, defaultdict
from itertools import accumulate, combinations, permutations, product
from functools import lru_cache
from heapq import heapify, heappush, heappop
from bisect import bisect_right, bisect_left
from copy import deepcopy
sys.setrecursionlimit((1 << 31) - 1)
#sys.set_int_max_str_digits(0)
input = lambda: sys.stdin.readline().rstrip()
INF = float('inf')
MOD = 998244353
DIR = [(1, 0), (-1, 0), (0, 1), (0, -1)]
DX = [1, 0, -1, 0, 1, 1, -1, -1]
DY = [0, 1, 0, -1, 1, -1, 1, -1]
def bisect_left_reverse(a, x):
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
def bisect_right_reverse(a, x):
if a[0] < x:
return 0
if x <= a[-1]:
return len(a)
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] < x:
ok = mid
else:
ng = mid
return ok
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 = collections.defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
class SegTree:
''' 点代入/区間総和
操作 segfunc 単位元
最小値 min(x, y) float('inf')
最大値 max(x, y) -float('inf')
区間和 x + y 0
区間積 x * y 1
最大公約数 math.gcd(x, y) 0
segfunc : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : k番目の値にxを加算
update : k番目の値をxに更新
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
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 segfunc(self, x, y):
return x+y
def add(self, k, x):
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 update(self, k, x):
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):
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
class LazySegTree_RAQ:
''' 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : 区間[l,r)の値にxを加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*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 segfunc(self, x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v == 0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self, l, r, x):
ids = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r & 1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self, l, r):
self.propagates(*self.gindex(l, r))
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
class LazySegTree_RUQ:
''' 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
update : 区間[l,r)の値をxに加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
'''
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
if segfunc is not None:
self.segfunc = segfunc
self.tree = [ide_ele]*2*self.num
self.lazy = [None]*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 segfunc(self, x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[i] = None
self.lazy[2*i] = v
self.lazy[2*i+1] = v
self.tree[2*i] = v
self.tree[2*i+1] = v
def update(self, l, r, x):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.tree[l] = x
l += 1
if r & 1:
self.lazy[r-1] = x
self.tree[r-1] = x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def query(self, l, r):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
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
def main():
N,M=map(int,input().split())
ans=0
#for i in range(N+1):
# print(format(i, "010b"))
n2 = bin(N)[2:]
m2 = bin(M)[2:]
for i in range(min(len(n2),len(m2))):
i += 1
if m2[-i] == "0": continue
r = 2**i
div = (N+1)//r
rest = (N+1) - r*div
harf = r // 2
ans += div*harf + max(0,rest - harf)
print(ans%998244353)
return
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc356_d/Python/54727857
|
condefects-python_data_2304
|
#再起回数を増やす
import sys
sys.setrecursionlimit(10 ** 8)
from collections import defaultdict
#こんな感じで使う
#Dict = defaultdict(list)
def I():
"""
複数列、複数行の入力を縦方向にまとめint型のリストで返却する
入力例 :
A1 B1
A2 B2 -> A = [1,2] B = [B1,B2]
"""
return int(input())
def MI():
"""
スペース区切りで入力を受け取り、mapで返却する
入力例 : 1 2 3 4 5 -> 1,2,3,4,5
"""
return map(int, input().split())
def LI():
"""
スペース区切りで入力を受け取り、int型のlistで返却する
入力例 : 1 2 3 4 5 -> [1,2,3,4,5]
"""
return list(map(int, input().split()))
def LLI(rows_number):
"""
# 複数行の入力を空白で区切りint型の二次元配列に変換し返却する
入力例 :
1 2 3
4 5 6 -> [[1,2,3],[4,5,6]]
"""
if rows_number == 0:
return [[]]
else:
return [list(map(int, input().split())) for _ in range(rows_number)]
def LLS(rows_number):
"""
複数行の入力を一文字ずつ区切り二次元配列に変換し返却する
入力例 :
ABC
DEF -> [[A,B,C],[D,E,F]]
"""
if rows_number == 0:
return [[]]
else:
return [list(input()) for _ in range(rows_number)]
def IH(rows_number):
"""
一列、複数行の入力を縦方向にint型のまとめリストで返却する
入力例 :
A1
A2 -> A = [1,2]
"""
if rows_number == 0:
return []
else:
return [int(input()) for _ in range(rows_number)]
def LH(rows_number):
"""
複数列、複数行の入力を縦方向にまとめint型のリストで返却する
入力例 :
A1 B1
A2 B2 -> A = [1,2] B = [B1,B2]
"""
if rows_number == 0:
return None,None
else:
return map(list, zip(*[map(int,input().split()) for _ in range(rows_number)]))
def return_mod(numerator, denominator, mod = 998244353):
"""
分数のmodを返却する
"""
try:
inverse_denominator = pow(denominator, mod - 2, mod)
result = (numerator * inverse_denominator) % mod
return result
except ZeroDivisionError:
print("Error: Division by zero.")
except ValueError:
print("Error: Invalid mod value.")
def binary_search(data, value):
"""
二部探索を行う
"""
left = 0
right = len(data) - 1
while left <= right:
mid = (left + right) // 2
if data[mid] == value:
return mid
elif data[mid] < value:
left = mid + 1
else:
right = mid - 1
return -1
def binary_search_min(data, value):
"""
二部探索を行い、value以上の最小の値を返す
"""
left, right = 0, len(data) - 1
# data内の全ての要素がvalueより小さい場合
if data[right] < value:
return None
while left < right:
mid = (left + right) // 2
if data[mid] < value:
left = mid + 1
else:
right = mid
return data[left]
def binary_search_max(data, value):
"""
二部探索を行い、value以下の最大の値を返す
"""
left, right = 0, len(data) - 1
# data内の全ての要素がvalueより大きい場合
if data[left] > value:
return None
while left < right:
mid = (left + right + 1) // 2 # '+1' is to ensure we do not get stuck (always favor right)
if data[mid] > value:
right = mid - 1
else:
left = mid
return data[right]
def LUDU_to_array(LUDU):
"""
UDUを配列に変換する
"""
if LUDU == "L":
return [0,-1]
elif LUDU == "U":
return [-1,0]
elif LUDU == "D":
return [1,0]
elif LUDU == "R":
return [0,1]
def sorted_indices(arr):
"""
Aの要素を順に並び替え、並び替えた後に何番目にあるかを出力する
"""
sorted_arr = sorted((val, idx) for idx, val in enumerate(arr))
rank = [0] * len(arr)
for i, (_, idx) in enumerate(sorted_arr):
rank[idx] = i + 1
return rank
def E(e):
"""
enumerateの省略
"""
return enumerate(e)
debug_Setting = False
def printn(*x):
"""
デバック用のプリント
提出時はdebug_SettingをFalseにする
"""
if debug_Setting:
print(x)
N = I()
A = LI()
LIST = [i for i in range(N+1)]
DICT = defaultdict(list)
SUM = 0
NOWLEN = 0
S = -1
X = set()
for i,a in E(A):
if a == 1:
NOWLEN += 1
S = i
else:
while(True):
if S != -1 and len(DICT[a-1]) > 0:
if DICT[a-1][-1][0] not in X:
Y = DICT[a-1].pop()
if S != Y[0]:
Start = Y[0] + 1
End = i
while(True):
printn(Y[0],Start,End,X,LIST)
if LIST[Start] == Start:
if LIST[Start] < End:
LIST[Start] = End - 1
X.add(Start)
Start += 1
else:
if Start < LIST[Start]:
savex = LIST[Start]
LIST[Start] = End
Start = savex
else:
while(True):
pass
if Start >= End:
break
S = Y[0]
NOWLEN = Y[1]
break
else:
DICT[a-1].pop()
else:
NOWLEN = 0
S = -1
break
DICT[a].append((S,NOWLEN))
SUM += NOWLEN
# printn(a,i,S,NOWLEN,SUM,DICT,X)
print(SUM)
# DICT = defaultdict(list)
# SUM = 0
# NOWLEN = 0
# NOUSE = set()
# for i,a in E(A):
# if a == 1:
# NOWLEN += 1
# N = i
# else:
# while(True):
# if len(DICT[a-1]) == 0:
# DICT = defaultdict(list)
# break
# if DICT[a-1][-1][0] > LAST:
# printn(a,DICT[a-1][-1][0],LAST)
# DICT[a-1].pop()
# else:
# break
# if a-1 in DICT and len(DICT[a-1]) > 0 :
# # print(type(DICT[a-1][-1]))
# if type(DICT[a-1][-1]) == tuple:
# LAST = DICT[a-1][-1][0]
# NOWLEN = DICT[a-1][-1][1]
# else:
# NOWLEN = 0
# SUM += NOWLEN
# DICT[a].append((N,NOWLEN))
# printn(a,SUM,NOWLEN,LAST,N,DICT)
# print(SUM)
#再起回数を増やす
import sys
sys.setrecursionlimit(10 ** 8)
from collections import defaultdict
#こんな感じで使う
#Dict = defaultdict(list)
def I():
"""
複数列、複数行の入力を縦方向にまとめint型のリストで返却する
入力例 :
A1 B1
A2 B2 -> A = [1,2] B = [B1,B2]
"""
return int(input())
def MI():
"""
スペース区切りで入力を受け取り、mapで返却する
入力例 : 1 2 3 4 5 -> 1,2,3,4,5
"""
return map(int, input().split())
def LI():
"""
スペース区切りで入力を受け取り、int型のlistで返却する
入力例 : 1 2 3 4 5 -> [1,2,3,4,5]
"""
return list(map(int, input().split()))
def LLI(rows_number):
"""
# 複数行の入力を空白で区切りint型の二次元配列に変換し返却する
入力例 :
1 2 3
4 5 6 -> [[1,2,3],[4,5,6]]
"""
if rows_number == 0:
return [[]]
else:
return [list(map(int, input().split())) for _ in range(rows_number)]
def LLS(rows_number):
"""
複数行の入力を一文字ずつ区切り二次元配列に変換し返却する
入力例 :
ABC
DEF -> [[A,B,C],[D,E,F]]
"""
if rows_number == 0:
return [[]]
else:
return [list(input()) for _ in range(rows_number)]
def IH(rows_number):
"""
一列、複数行の入力を縦方向にint型のまとめリストで返却する
入力例 :
A1
A2 -> A = [1,2]
"""
if rows_number == 0:
return []
else:
return [int(input()) for _ in range(rows_number)]
def LH(rows_number):
"""
複数列、複数行の入力を縦方向にまとめint型のリストで返却する
入力例 :
A1 B1
A2 B2 -> A = [1,2] B = [B1,B2]
"""
if rows_number == 0:
return None,None
else:
return map(list, zip(*[map(int,input().split()) for _ in range(rows_number)]))
def return_mod(numerator, denominator, mod = 998244353):
"""
分数のmodを返却する
"""
try:
inverse_denominator = pow(denominator, mod - 2, mod)
result = (numerator * inverse_denominator) % mod
return result
except ZeroDivisionError:
print("Error: Division by zero.")
except ValueError:
print("Error: Invalid mod value.")
def binary_search(data, value):
"""
二部探索を行う
"""
left = 0
right = len(data) - 1
while left <= right:
mid = (left + right) // 2
if data[mid] == value:
return mid
elif data[mid] < value:
left = mid + 1
else:
right = mid - 1
return -1
def binary_search_min(data, value):
"""
二部探索を行い、value以上の最小の値を返す
"""
left, right = 0, len(data) - 1
# data内の全ての要素がvalueより小さい場合
if data[right] < value:
return None
while left < right:
mid = (left + right) // 2
if data[mid] < value:
left = mid + 1
else:
right = mid
return data[left]
def binary_search_max(data, value):
"""
二部探索を行い、value以下の最大の値を返す
"""
left, right = 0, len(data) - 1
# data内の全ての要素がvalueより大きい場合
if data[left] > value:
return None
while left < right:
mid = (left + right + 1) // 2 # '+1' is to ensure we do not get stuck (always favor right)
if data[mid] > value:
right = mid - 1
else:
left = mid
return data[right]
def LUDU_to_array(LUDU):
"""
UDUを配列に変換する
"""
if LUDU == "L":
return [0,-1]
elif LUDU == "U":
return [-1,0]
elif LUDU == "D":
return [1,0]
elif LUDU == "R":
return [0,1]
def sorted_indices(arr):
"""
Aの要素を順に並び替え、並び替えた後に何番目にあるかを出力する
"""
sorted_arr = sorted((val, idx) for idx, val in enumerate(arr))
rank = [0] * len(arr)
for i, (_, idx) in enumerate(sorted_arr):
rank[idx] = i + 1
return rank
def E(e):
"""
enumerateの省略
"""
return enumerate(e)
debug_Setting = False
def printn(*x):
"""
デバック用のプリント
提出時はdebug_SettingをFalseにする
"""
if debug_Setting:
print(x)
N = I()
A = LI()
LIST = [i for i in range(N+1)]
DICT = defaultdict(list)
SUM = 0
NOWLEN = 0
S = -1
X = set()
for i,a in E(A):
if a == 1:
NOWLEN += 1
S = i
else:
while(True):
if S != -1 and len(DICT[a-1]) > 0:
if DICT[a-1][-1][0] not in X:
Y = DICT[a-1].pop()
if S != Y[0]:
Start = Y[0] + 1
End = i
while(True):
printn(Y[0],Start,End,X,LIST)
if LIST[Start] == Start:
if LIST[Start] < End:
LIST[Start] = End - 1
X.add(Start)
Start += 1
else:
if Start < LIST[Start]:
savex = LIST[Start]
LIST[Start] = End
Start = savex
else:
while(True):
pass
if Start >= End:
break
S = Y[0]
NOWLEN = Y[1]
break
else:
DICT[a-1].pop()
else:
NOWLEN = 0
S = -1
DICT = defaultdict(list)
X = set()
break
DICT[a].append((S,NOWLEN))
SUM += NOWLEN
# printn(a,i,S,NOWLEN,SUM,DICT,X)
print(SUM)
# DICT = defaultdict(list)
# SUM = 0
# NOWLEN = 0
# NOUSE = set()
# for i,a in E(A):
# if a == 1:
# NOWLEN += 1
# N = i
# else:
# while(True):
# if len(DICT[a-1]) == 0:
# DICT = defaultdict(list)
# break
# if DICT[a-1][-1][0] > LAST:
# printn(a,DICT[a-1][-1][0],LAST)
# DICT[a-1].pop()
# else:
# break
# if a-1 in DICT and len(DICT[a-1]) > 0 :
# # print(type(DICT[a-1][-1]))
# if type(DICT[a-1][-1]) == tuple:
# LAST = DICT[a-1][-1][0]
# NOWLEN = DICT[a-1][-1][1]
# else:
# NOWLEN = 0
# SUM += NOWLEN
# DICT[a].append((N,NOWLEN))
# printn(a,SUM,NOWLEN,LAST,N,DICT)
# print(SUM)
|
ConDefects/ConDefects/Code/agc063_b/Python/44136745
|
condefects-python_data_2305
|
n = int(input())
A = list(map(int,input().split()))
count1 = 0
count2 = 0
for i in range(n):
a = A[i]
if (a == i+1):
count1 += 1
elif (A[a-1] == i+1):
count2 += 1
if (count1 >= 2):
print(count1 * (count1-1) // 2 + count2//2)
else:
print(count2)
n = int(input())
A = list(map(int,input().split()))
count1 = 0
count2 = 0
for i in range(n):
a = A[i]
if (a == i+1):
count1 += 1
elif (A[a-1] == i+1):
count2 += 1
if (count1 >= 2):
print(count1 * (count1-1) // 2 + count2//2)
else:
print(count2//2)
|
ConDefects/ConDefects/Code/abc262_c/Python/44821687
|
condefects-python_data_2306
|
n=int(input())
a=list(map(int,input().split()))
s=[list(map(str,input())) for i in range(n)]
q=int(input())
ans=[[[10**9,10**20] for i in range(n)] for i in range(n)]
for i in range(n):
ans[i][i]=[0,a[i]]
for i in range(n):
for j in range(n):
if s[i][j]=="Y":
ans[i][j]=[1,a[i]+a[j]]
for k in range(n):
for i in range(n):
for j in range(n):
if ans[i][j][0]>ans[i][k][0]+ans[k][j][0]:
ans[i][j]=[ans[i][k][0]+ans[k][j][0],ans[i][k][1]+ans[k][j][1]-a[k]]
elif ans[i][j][0]==ans[i][k][0]+ans[k][j][0]:
ans[i][j][1]=min(ans[i][k][1]+ans[k][j][1]-a[k],ans[i][j][1])
for i in range(q):
c,b=map(int,input().split())
c-=1;b-=1
if ans[c][b][1]==10**20:
print("Impossible")
else:
print(*ans[c][b])
n=int(input())
a=list(map(int,input().split()))
s=[list(map(str,input())) for i in range(n)]
q=int(input())
ans=[[[10**9,10**20] for i in range(n)] for i in range(n)]
for i in range(n):
ans[i][i]=[0,a[i]]
for i in range(n):
for j in range(n):
if s[i][j]=="Y":
ans[i][j]=[1,a[i]+a[j]]
for k in range(n):
for i in range(n):
for j in range(n):
if ans[i][j][0]>ans[i][k][0]+ans[k][j][0]:
ans[i][j]=[ans[i][k][0]+ans[k][j][0],ans[i][k][1]+ans[k][j][1]-a[k]]
elif ans[i][j][0]==ans[i][k][0]+ans[k][j][0]:
ans[i][j][1]=max(ans[i][k][1]+ans[k][j][1]-a[k],ans[i][j][1])
for i in range(q):
c,b=map(int,input().split())
c-=1;b-=1
if ans[c][b][1]==10**20:
print("Impossible")
else:
print(*ans[c][b])
|
ConDefects/ConDefects/Code/abc286_e/Python/45479724
|
condefects-python_data_2307
|
import collections
N = int(input())
A = list(map(int,input().split()))
S = [list(input()) for _ in range(N)]
max_value = [ [[0,0] for _ in range(N) ] for _ in range(N) ]
for start in range(N):
que = collections.deque([[start,A[start]]])
seen = [-1]*N
seen[start] = 0
while que:
from_i,value = que.popleft()
for to_i in range(N):
if S[from_i][to_i]=='Y' and (seen[to_i]==seen[from_i]+1 or seen[to_i]==-1):
if max_value[start][to_i][1]<value+A[to_i]:
max_value[start][to_i] = [seen[from_i]+1,value+A[to_i]]
if seen[to_i]==-1:
max_value[start][to_i] = [seen[from_i]+1,value+A[to_i]]
seen[to_i] = seen[from_i]+1
que.append([to_i,value+A[to_i]])
#print(max_value)
Q = int(input())
ans = []
for _ in range(Q):
U,V = map(int,input().split())
if max_value[U-1][V-1] != [0,0]:
print(*max_value[U-1][V-1])
else:
print('Impossible')
import collections
N = int(input())
A = list(map(int,input().split()))
S = [list(input()) for _ in range(N)]
max_value = [ [[0,0] for _ in range(N) ] for _ in range(N) ]
for start in range(N):
que = collections.deque([[start,A[start]]])
seen = [-1]*N
seen[start] = 0
while que:
from_i,value = que.popleft()
for to_i in range(N):
if S[from_i][to_i]=='Y' and (seen[to_i]==seen[from_i]+1 or seen[to_i]==-1):
if max_value[start][to_i][1]<value+A[to_i]:
max_value[start][to_i] = [seen[from_i]+1,value+A[to_i]]
seen[to_i] = seen[from_i]+1
que.append([to_i,value+A[to_i]])
#print(max_value)
Q = int(input())
ans = []
for _ in range(Q):
U,V = map(int,input().split())
if max_value[U-1][V-1] != [0,0]:
print(*max_value[U-1][V-1])
else:
print('Impossible')
|
ConDefects/ConDefects/Code/abc286_e/Python/45217169
|
condefects-python_data_2308
|
from collections import deque
n=int(input())
A=list(map(int,input().split()))
S=[input() for i in range(n)]
graph=[[] for i in range(n)]
for i in range(n):
for j in range(n):
if i==j:
continue
if S[i][j]=="Y":
graph[i].append(j)
ans=[[[10**12,-1] for i in range(n)] for j in range(n)]
for i in range(n):
d=deque()
d.append([i,0,A[i]])
while d:
v=d.popleft()
if v[1]>ans[i][v[0]][0] or v[2]<ans[i][v[0]][1]:
continue
for j in graph[v[0]]:
if v[1]<ans[i][j][0]-1:
ans[i][j]=[v[1]+1,v[2]+A[j]]
d.append([j,v[1]+1,v[2]+A[j]])
elif v[1]==ans[i][j][0]-1 and v[2]+A[j]>ans[i][v[1]][1]:
ans[i][j]=[v[1]+1,v[2]+A[j]]
d.append([j,v[1]+1,v[2]+A[j]])
q=int(input())
for i in range(q):
a,b=map(int,input().split())
a-=1
b-=1
if ans[a][b][0]==10**12:
print("Impossible")
else:
print(ans[a][b][0],ans[a][b][1])
from collections import deque
n=int(input())
A=list(map(int,input().split()))
S=[input() for i in range(n)]
graph=[[] for i in range(n)]
for i in range(n):
for j in range(n):
if i==j:
continue
if S[i][j]=="Y":
graph[i].append(j)
ans=[[[10**12,-1] for i in range(n)] for j in range(n)]
for i in range(n):
d=deque()
d.append([i,0,A[i]])
while d:
v=d.popleft()
if v[1]>ans[i][v[0]][0] or v[2]<ans[i][v[0]][1]:
continue
for j in graph[v[0]]:
if v[1]<ans[i][j][0]-1:
ans[i][j]=[v[1]+1,v[2]+A[j]]
d.append([j,v[1]+1,v[2]+A[j]])
elif v[1]==ans[i][j][0]-1 and v[2]+A[j]>ans[i][j][1]:
ans[i][j]=[v[1]+1,v[2]+A[j]]
d.append([j,v[1]+1,v[2]+A[j]])
q=int(input())
for i in range(q):
a,b=map(int,input().split())
a-=1
b-=1
if ans[a][b][0]==10**12:
print("Impossible")
else:
print(ans[a][b][0],ans[a][b][1])
|
ConDefects/ConDefects/Code/abc286_e/Python/46169747
|
condefects-python_data_2309
|
T = int(input())
for _ in range(T):
N,M,K = map(int,input().split())
S = input()
cnt = 0
lst = [1]
for i in range(1,len(S)):
if S[i] == S[i-1]:
lst[-1] += 1
else:
lst.append(1)
ans = 0
flag = False
for i in range(len(lst)-1):
if not flag:
ans += 1
flag = True
else:
if lst[i] > 1 and (lst[i+1] > 1 or i+1 == len(lst)-1):
ans += 1
flag = True
else:
flag = False
if ans > K:
print("No")
else:
print("Yes")
T = int(input())
for _ in range(T):
N,M,K = map(int,input().split())
S = input()
cnt = 0
lst = [1]
for i in range(1,len(S)):
if S[i] == S[i-1]:
lst[-1] += 1
else:
lst.append(1)
ans = 0
flag = False
for i in range(len(lst)-1):
if not flag:
ans += 1
flag = True
else:
if lst[i] > 1:
ans += 1
flag = True
else:
flag = False
if ans > K:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/agc060_b/Python/37547592
|
condefects-python_data_2310
|
t = int(input())
for _ in range(t):
n,m,k=map(int,input().split(' '))
s=input()
i=0
l=len(s)
ans=0
while(i<l-1):
if(i+3<=l and (s[i:i+3]=='RDR' or s[i:i+3]=='DRD')):
ans+=1
i+=2
elif(s[i:i+2]=='RD' or s[i:i+2]=='DR'):
ans+=1
i+=1
else:
i+=1
print(ans)
t = int(input())
for _ in range(t):
n,m,k=map(int,input().split(' '))
s=input()
i=0
l=len(s)
ans=0
while(i<l-1):
if(i+3<=l and (s[i:i+3]=='RDR' or s[i:i+3]=='DRD')):
ans+=1
i+=2
elif(s[i:i+2]=='RD' or s[i:i+2]=='DR'):
ans+=1
i+=1
else:
i+=1
print('Yes' if ans<=k else 'No')
|
ConDefects/ConDefects/Code/agc060_b/Python/41598368
|
condefects-python_data_2311
|
def check(aaa):
""" A0とA1に対する操作回数の差分 d を求める """
bbb = aaa.copy()
bbb.append(aaa[0])
for i in range(2, n):
tmp = bbb[i - 1]
bbb[i - 1] -= tmp
bbb[i] += tmp * 2
bbb[i + 1] -= tmp
if bbb[-2] + bbb[-1] != 0:
return None
d, m = divmod(bbb[-2], len(aaa))
if m != 0:
return None
return d
def check2(aaa, s, d):
bbb = aaa.copy()
bbb.append(aaa[0])
bbb[-2] -= s
bbb[-1] += s * 2 - (s - d)
bbb[0] += s * 2 - (s - d)
bbb[1] += (s - d) * 2 - s
bbb[2] -= (s - d)
cnt = s + s - d
for i in range(2, n):
tmp = bbb[i - 1]
if tmp < 0:
return False, 0
cnt += tmp
bbb[i - 1] -= tmp
bbb[i] += tmp * 2
bbb[i + 1] -= tmp
return True, cnt
n = int(input())
aaa = list(map(int, input().split()))
d = check(aaa)
if d is None:
print(-1)
exit()
if d < 0:
aaa.reverse()
aaa = aaa[-2:] + aaa[:-2]
d *= -1
l = d - 1
r = 1 << 30
while l + 1 < r:
m = (l + r) // 2
res, cnt = check2(aaa, m, d)
if res:
r = m
else:
l = m
_, ans = check2(aaa, r, d)
print(ans)
def check(aaa):
""" A0とA1に対する操作回数の差分 d を求める """
bbb = aaa.copy()
bbb.append(aaa[0])
for i in range(2, n):
tmp = bbb[i - 1]
bbb[i - 1] -= tmp
bbb[i] += tmp * 2
bbb[i + 1] -= tmp
if bbb[-2] + bbb[-1] != 0:
return None
d, m = divmod(bbb[-2], len(aaa))
if m != 0:
return None
return d
def check2(aaa, s, d):
bbb = aaa.copy()
bbb.append(aaa[0])
bbb[-2] -= s
bbb[-1] += s * 2 - (s - d)
bbb[0] += s * 2 - (s - d)
bbb[1] += (s - d) * 2 - s
bbb[2] -= (s - d)
cnt = s + s - d
for i in range(2, n):
tmp = bbb[i - 1]
if tmp < 0:
return False, 0
cnt += tmp
bbb[i - 1] -= tmp
bbb[i] += tmp * 2
bbb[i + 1] -= tmp
return True, cnt
n = int(input())
aaa = list(map(int, input().split()))
d = check(aaa)
if d is None:
print(-1)
exit()
if d < 0:
aaa.reverse()
aaa = aaa[-2:] + aaa[:-2]
d *= -1
l = d - 1
r = 1 << 60
while l + 1 < r:
m = (l + r) // 2
res, cnt = check2(aaa, m, d)
if res:
r = m
else:
l = m
_, ans = check2(aaa, r, d)
print(ans)
|
ConDefects/ConDefects/Code/arc129_d/Python/27435812
|
condefects-python_data_2312
|
N = int(input())
A = list(map(int,input().split()))
if sum(A) != 0:
print(-1)
exit()
B = [0]
for a in A:
B.append(B[-1] + a)
sb = sum(B)
if sb%N != 0:
print(-1)
exit()
ans = abs(sb)//N
if sb > 0:
for i in range(1,N):
B[i] -= sb//N
B[N-1] -= sb//N
if sb < 0:
for i in range(1,N):
B[i] -= sb//N
B[1] -= sb//N
def is_ok(k):
if k < 0: return False
B[1] += k
C = [0]
for b in B:
C.append(C[-1] + b)
if C[-1] < 0:
B[1] -= k
return False
B[1] -= k
return True
ng = -1
ok = 10**9
while ok-ng > 1:
m = (ok+ng)//2
if is_ok(m):
ok = m
else:
ng = m
B[1] += ok
C = [0]
for b in B:
C.append(C[-1] + b)
ans += ok*2 + sum(C[:-2])
print(ans)
N = int(input())
A = list(map(int,input().split()))
if sum(A) != 0:
print(-1)
exit()
B = [0]
for a in A:
B.append(B[-1] + a)
sb = sum(B)
if sb%N != 0:
print(-1)
exit()
ans = abs(sb)//N
if sb > 0:
for i in range(1,N):
B[i] -= sb//N
B[N-1] -= sb//N
if sb < 0:
for i in range(1,N):
B[i] -= sb//N
B[1] -= sb//N
def is_ok(k):
if k < 0: return False
B[1] += k
C = [0]
for b in B:
C.append(C[-1] + b)
if C[-1] < 0:
B[1] -= k
return False
B[1] -= k
return True
ng = -1
ok = 10**12
while ok-ng > 1:
m = (ok+ng)//2
if is_ok(m):
ok = m
else:
ng = m
B[1] += ok
C = [0]
for b in B:
C.append(C[-1] + b)
ans += ok*2 + sum(C[:-2])
print(ans)
|
ConDefects/ConDefects/Code/arc129_d/Python/27941784
|
condefects-python_data_2313
|
import sys
input = sys.stdin.readline
N=int(input())
A=list(map(int,input().split()))
if sum(A)!=0:
print(-1)
exit()
S=[0]
for a in A:
S.append(S[-1]+a)
x=sum(S)
if x%N!=0:
print(-1)
exit()
#print(x,S)
if x<0:
ANS=-x//N
A[0]+=ANS*2
A[1]-=ANS
A[-1]-=ANS
elif x>0:
ANS=x//N
A[-1]+=ANS*2
A[0]-=ANS
A[-2]-=ANS
C=A[:]
OK=10**9
NG=-1
while OK>NG+1:
mid=(OK+NG)//2
C[0]+=mid*2
C[1]-=mid
C[-1]-=mid
C[-1]+=mid*2
C[0]-=mid
C[-2]-=mid
S=[0]
for a in C:
S.append(S[-1]+a)
C[0]-=mid*2
C[1]+=mid
C[-1]+=mid
C[-1]-=mid*2
C[0]+=mid
C[-2]+=mid
for i in range(len(S)-1):
if S[i]<0:
NG=mid
break
S[i+1]+=S[i]
else:
OK=mid
#print(OK)
ANS+=OK*2
A[0]+=OK*2
A[1]-=OK
A[-1]-=OK
A[-1]+=OK*2
A[0]-=OK
A[-2]-=OK
S=[0]
for a in A:
S.append(S[-1]+a)
for i in range(len(S)-1):
S[i+1]+=S[i]
ANS+=S[i]
print(ANS)
import sys
input = sys.stdin.readline
N=int(input())
A=list(map(int,input().split()))
if sum(A)!=0:
print(-1)
exit()
S=[0]
for a in A:
S.append(S[-1]+a)
x=sum(S)
if x%N!=0:
print(-1)
exit()
#print(x,S)
if x<0:
ANS=-x//N
A[0]+=ANS*2
A[1]-=ANS
A[-1]-=ANS
elif x>0:
ANS=x//N
A[-1]+=ANS*2
A[0]-=ANS
A[-2]-=ANS
C=A[:]
OK=10**17
NG=-1
while OK>NG+1:
mid=(OK+NG)//2
C[0]+=mid*2
C[1]-=mid
C[-1]-=mid
C[-1]+=mid*2
C[0]-=mid
C[-2]-=mid
S=[0]
for a in C:
S.append(S[-1]+a)
C[0]-=mid*2
C[1]+=mid
C[-1]+=mid
C[-1]-=mid*2
C[0]+=mid
C[-2]+=mid
for i in range(len(S)-1):
if S[i]<0:
NG=mid
break
S[i+1]+=S[i]
else:
OK=mid
#print(OK)
ANS+=OK*2
A[0]+=OK*2
A[1]-=OK
A[-1]-=OK
A[-1]+=OK*2
A[0]-=OK
A[-2]-=OK
S=[0]
for a in A:
S.append(S[-1]+a)
for i in range(len(S)-1):
S[i+1]+=S[i]
ANS+=S[i]
print(ANS)
|
ConDefects/ConDefects/Code/arc129_d/Python/27452332
|
condefects-python_data_2314
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
INF = 10**18
#INF = 10**2
N, M = map(int, input().split())
Ass = [[0]*(N+2)] + [[0]+list(map(int, input().split())) for _ in range(N)]
accss = [[0]*(N+1) for _ in range(N+1)]
for x in range(1, N+1):
for y in range(1, N+1):
accss[x][y] = accss[x][y-1] + Ass[x][y]
for x in range(1, N+1):
for y in range(1, N+1):
accss[x][y] += accss[x-1][y]
# print('# accss:')
# for accs in accss:
# print('# ', accs)
def getRangeSum2D(accAss, xFr, xTo, yFr, yTo):
return accAss[xTo+1][yTo+1] - accAss[xTo+1][yFr] - accAss[xFr][yTo+1] + accAss[xFr][yFr]
M1 = M-1
smss = [[0]*(N+1) for _ in range(N+1)]
for x in range(N-M1):
for y in range(N-M1):
smss[x+1][y+1] = getRangeSum2D(accss, x, x+M1, y, y+M1)
# print('# smss:')
# for sms in smss:
# print('# ', sms)
N2 = N+2
mxULss = [[-INF]*(N2) for _ in range(N2)]
for x in range(M, N+1):
for y in range(M, N+1):
mxULss[x][y] = max(smss[x-M1][y-M1], mxULss[x-1][y], mxULss[x][y-1])
mxURss = [[-INF]*(N2) for _ in range(N2)]
for x in range(M, N+1):
for y in reversed(range(1, N-M1+1)):
mxURss[x][y] = max(smss[x-M1][y], mxURss[x-1][y], mxURss[x][y+1])
mxDLss = [[-INF]*(N2) for _ in range(N2)]
for x in reversed(range(1, N-M1+1)):
for y in range(M, N+1):
mxDLss[x][y] = max(smss[x][y-M1], mxDLss[x+1][y], mxDLss[x][y-1])
mxDRss = [[-INF]*(N2) for _ in range(N2)]
for x in reversed(range(1, N-M1+1)):
for y in reversed(range(1, N-M1+1)):
mxDRss[x][y] = max(smss[x][y], mxDRss[x+1][y], mxDRss[x][y+1])
# print('# mxULss:')
# for mxULs in mxULss:
# print('# ', mxULs)
# print('# mxURss:')
# for mxURs in mxURss:
# print('# ', mxURs)
# print('# mxDLss:')
# for mxDLs in mxDLss:
# print('# ', mxDLs)
# print('# mxDRss:')
# for mxDRs in mxDRss:
# print('# ', mxDRs)
mxRows = list(map(max, smss))
mxColumns = list(max(sms) for sms in zip(*smss))
#print('# mxRows:', mxRows)
#print('# mxColumns:', mxColumns)
ans = 0
for x1 in range(M, N-M1+1):
a1 = mxULss[x1][N]
a2 = 0
for x3 in range(x1+M+1, N-M1+1):
mx = mxRows[x3-M]
if mx > a2:
a2 = mx
a3 = mxDLss[x3][N]
area = a1+a2+a3
# print('# (x1, x3):', (x1, x3), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y1 in range(M, N-M1+1):
a1 = mxULss[N][y1]
a2 = 0
for y3 in range(y1+M+1, N-M1+1):
mx = mxColumns[y3-M]
if mx > a2:
a2 = mx
a3 = mxULss[N][y3]
area = a1+a2+a3
# print('# (x1, x3):', (x1, x3), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for x in range(M, N-M+1):
a1 = mxULss[x][N]
for y in range(M, N-M+1):
a2 = mxDLss[x+1][y]
a3 = mxDRss[x+1][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y in range(M, N-M+1):
a1 = mxULss[N][y]
for x in range(M, N-M+1):
a2 = mxURss[x][y+1]
a3 = mxDRss[x+1][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for x in range(M, N-M+1):
a1 = mxDRss[x+1][1]
for y in range(M, N-M+1):
a2 = mxULss[x][y]
a3 = mxURss[x][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y in range(M, N-M+1):
a1 = mxDRss[1][y+1]
for x in range(M, N-M+1):
a2 = mxULss[x][y]
a3 = mxDLss[x+1][y]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
print(ans)
solve()
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
INF = 10**18
#INF = 10**2
N, M = map(int, input().split())
Ass = [[0]*(N+2)] + [[0]+list(map(int, input().split())) for _ in range(N)]
accss = [[0]*(N+1) for _ in range(N+1)]
for x in range(1, N+1):
for y in range(1, N+1):
accss[x][y] = accss[x][y-1] + Ass[x][y]
for x in range(1, N+1):
for y in range(1, N+1):
accss[x][y] += accss[x-1][y]
# print('# accss:')
# for accs in accss:
# print('# ', accs)
def getRangeSum2D(accAss, xFr, xTo, yFr, yTo):
return accAss[xTo+1][yTo+1] - accAss[xTo+1][yFr] - accAss[xFr][yTo+1] + accAss[xFr][yFr]
M1 = M-1
smss = [[0]*(N+1) for _ in range(N+1)]
for x in range(N-M1):
for y in range(N-M1):
smss[x+1][y+1] = getRangeSum2D(accss, x, x+M1, y, y+M1)
# print('# smss:')
# for sms in smss:
# print('# ', sms)
N2 = N+2
mxULss = [[-INF]*(N2) for _ in range(N2)]
for x in range(M, N+1):
for y in range(M, N+1):
mxULss[x][y] = max(smss[x-M1][y-M1], mxULss[x-1][y], mxULss[x][y-1])
mxURss = [[-INF]*(N2) for _ in range(N2)]
for x in range(M, N+1):
for y in reversed(range(1, N-M1+1)):
mxURss[x][y] = max(smss[x-M1][y], mxURss[x-1][y], mxURss[x][y+1])
mxDLss = [[-INF]*(N2) for _ in range(N2)]
for x in reversed(range(1, N-M1+1)):
for y in range(M, N+1):
mxDLss[x][y] = max(smss[x][y-M1], mxDLss[x+1][y], mxDLss[x][y-1])
mxDRss = [[-INF]*(N2) for _ in range(N2)]
for x in reversed(range(1, N-M1+1)):
for y in reversed(range(1, N-M1+1)):
mxDRss[x][y] = max(smss[x][y], mxDRss[x+1][y], mxDRss[x][y+1])
# print('# mxULss:')
# for mxULs in mxULss:
# print('# ', mxULs)
# print('# mxURss:')
# for mxURs in mxURss:
# print('# ', mxURs)
# print('# mxDLss:')
# for mxDLs in mxDLss:
# print('# ', mxDLs)
# print('# mxDRss:')
# for mxDRs in mxDRss:
# print('# ', mxDRs)
mxRows = list(map(max, smss))
mxColumns = list(max(sms) for sms in zip(*smss))
#print('# mxRows:', mxRows)
#print('# mxColumns:', mxColumns)
ans = 0
for x1 in range(M, N-M1+1):
a1 = mxULss[x1][N]
a2 = 0
for x3 in range(x1+M+1, N-M1+1):
mx = mxRows[x3-M]
if mx > a2:
a2 = mx
a3 = mxDLss[x3][N]
area = a1+a2+a3
# print('# (x1, x3):', (x1, x3), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y1 in range(M, N-M1+1):
a1 = mxULss[N][y1]
a2 = 0
for y3 in range(y1+M+1, N-M1+1):
mx = mxColumns[y3-M]
if mx > a2:
a2 = mx
a3 = mxURss[N][y3]
area = a1+a2+a3
# print('# (x1, x3):', (x1, x3), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for x in range(M, N-M+1):
a1 = mxULss[x][N]
for y in range(M, N-M+1):
a2 = mxDLss[x+1][y]
a3 = mxDRss[x+1][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y in range(M, N-M+1):
a1 = mxULss[N][y]
for x in range(M, N-M+1):
a2 = mxURss[x][y+1]
a3 = mxDRss[x+1][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for x in range(M, N-M+1):
a1 = mxDRss[x+1][1]
for y in range(M, N-M+1):
a2 = mxULss[x][y]
a3 = mxURss[x][y+1]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
for y in range(M, N-M+1):
a1 = mxDRss[1][y+1]
for x in range(M, N-M+1):
a2 = mxULss[x][y]
a3 = mxDLss[x+1][y]
area = a1+a2+a3
# print('# (x, y):', (x, y), '/ (a1, a2, a3):', (a1, a2, a3), '/ area:', area)
if area > ans:
ans = area
print(ans)
solve()
|
ConDefects/ConDefects/Code/abc347_f/Python/52760025
|
condefects-python_data_2315
|
#ABC347F
#二次元累積和 Grid[Sh:Gh)[Sw:Gw)の矩形和を求める(半開区間なので注意)
class Csum2D:
def __init__(self,H=1,W=1):
self._H=H; self._W=W; self._G=[[0]*W for _ in range(H)]; self._made=0
def add(self,h,w,x):
if -H<=h<H and -W<=w<W and not self._made: self._G[h][w]+=x; return 1
else: return 0
def build(self,Grid=0): #二次元累積和を構築する。グリッドがあれば転記し構築
if Grid:
self._H,self._W=len(Grid),len(max(Grid[i] for i in range(len(Grid))))
self._G=[[0]*self._W for _ in range(self._H)]
for h in range(self._H):
for w in range(len(Grid[h])): self._G[h][w]=Grid[h][w]
for h in range(self._H): self._G[h].append(0)
self._G.append([0]*(self._W+1)); self._H+=1; self._W+=1; self._made=1
for h in range(self._H-1):
for w in range(self._W-1):
self._G[h][w]+=self._G[h][w-1]+self._G[h-1][w]-self._G[h-1][w-1]
def query(self,Sh,Sw,Gh,Gw):
Sh,Sw,Gh,Gw=Sh-1,Sw-1,Gh-1,Gw-1
return self._G[Gh][Gw]-self._G[Sh][Gw]-self._G[Gh][Sw]+self._G[Sh][Sw]
#Disjoint Sparse Table 構築 O(NlogN), クエリ O(1)
class Disjoint_Sparse_Table: #結合律(A+B)+C = A+(B+C)が成り立てばOK
def __init__(self, A, identity_e, function):
self._N = N = len(A); self._logN = logN = (N - 1).bit_length()
self._M = M = 2 ** logN; self._e = e = identity_e; self._f = f = function
self._A = A = A + [e] * (M - N); self._T = T = [[e] * logN for _ in range(M)]
for x in range(logN):
t = 1 << x
for s in range(t, M, t << 1):
T[s][x] = A[s]
for j in range(s + 1, s + t, +1): T[j][x] = f(T[j-1][x], A[j])
for s in range(M - t - 1, -1, -t << 1):
T[s][x] = A[s]
for j in range(s - 1, s - t, -1): T[j][x] = f(A[j], T[j+1][x])
def fold(self, Lt, Rt): #半開区間[Lt:Rt)の作用値を返す
Lt, Rt = max(0, Lt), min(self._M, Rt) - 1; x = (Lt ^ Rt).bit_length() - 1
if not 0 <= Lt <= Rt < self._M: return self._e
if Lt == Rt: return self._A[Lt]
return self._f( self._T[Lt][x], self._T[Rt][x] )
#Segment Tree: O(logN)
class SegmentTree:
def __init__(self, n, identity_e, combine_f): self._n = n; self._size = 1 << (n-1).bit_length(); self._identity_e = identity_e; self._combine_f = combine_f; self._node = [self._identity_e] * 2 * self._size
def build(self, array):
assert len(array) == self._n, 'array too large'
for i,v in enumerate(array, start = self._size): self._node[i] = v
for i in range(self._size - 1, 0, -1): self._node[i] = self._combine_f(self._node[i<<1|0], self._node[i<<1|1])
def update(self, index, value): #一点更新
i = self._size + index; 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)の区間値を得る
L += self._size; R += self._size; vL = vR = self._identity_e
while L < R:
if L & 1: vL = self._combine_f(vL, self._node[L]); L += 1
if R & 1: R -= 1; vR = self._combine_f(self._node[R], vR)
L >>= 1; R >>= 1
return self._combine_f(vL, vR)
#down: Falseなら単調増加、Trueなら単調減少を仮定する。
#[Lt:Rt]の作用値がX以上/以下 となる、最小のRtを返す。閉区間なので扱い注意。
def bisect(self, Lt, X, down = False):
if Lt >= self._n: return self._n
now = Lt + self._size; cnt = self._identity_e
while 1: #nodeの上昇
f = now & 3; now = now >> 2 if f == 0 else now >> 1 if f == 2 else now; t = self._combine_f(cnt, self._node[now])
if not down and t >= X: break
elif down and t <= X: break
else:
cnt = t; now += 1
if now & (now - 1) == 0: return self._n
while now < self._size: #下降
Lt, Rt = self._node[now<<1|0], self._node[now<<1|1]
if not down and self._combine_f(cnt, Lt) >= X: now = now<<1|0
elif down and self._combine_f(cnt, Lt) <= X: now = now<<1|0
else: cnt = self._combine_f(cnt, Lt); now = now<<1|1
return now - self._size
N, M = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
#90度回転
def rotate(S):
return [[S[- h - 1][w] for h in range(N)] for w in range(N)]
#品に割るか、目に割るかを試す
def solve(S):
C = Csum2D(N, N)
C.build(S)
ans = 0
#1. 目割り
dp = [- 10 ** 18] * N
for h in range(N - M + 1):
for w in range(N - M + 1):
dp[h] = max(dp[h], C.query(h, w, h + M, w + M))
DST = Disjoint_Sparse_Table(dp, - 10 ** 18, max)
for a in range(N):
for b in range(a + M, N):
c = b + M
if c + M <= N:
ans = max(ans, dp[a] + dp[b] + DST.fold(c, N))
#2. 品割り
ST = SegmentTree(N, - 10 ** 18, max)
for h in range(N - M, -1, -1):
for w in range(N - M + 1):
if ST.fold(w, w + 1) < C.query(h, w, h + M, w + M):
ST.update(w, C.query(h, w, h + M, w + M))
t = h - M
if t >= 0:
for w in range(N - M + 1):
if w - M >= 0:
ans = max(ans, DST.fold(0, t + 1) + ST.fold(0, w - M) + ST.fold(w, N))
return ans
ans = 0
for t in range(4):
ans = max(ans, solve(A))
A = rotate(A)
print(ans)
#ABC347F
#二次元累積和 Grid[Sh:Gh)[Sw:Gw)の矩形和を求める(半開区間なので注意)
class Csum2D:
def __init__(self,H=1,W=1):
self._H=H; self._W=W; self._G=[[0]*W for _ in range(H)]; self._made=0
def add(self,h,w,x):
if -H<=h<H and -W<=w<W and not self._made: self._G[h][w]+=x; return 1
else: return 0
def build(self,Grid=0): #二次元累積和を構築する。グリッドがあれば転記し構築
if Grid:
self._H,self._W=len(Grid),len(max(Grid[i] for i in range(len(Grid))))
self._G=[[0]*self._W for _ in range(self._H)]
for h in range(self._H):
for w in range(len(Grid[h])): self._G[h][w]=Grid[h][w]
for h in range(self._H): self._G[h].append(0)
self._G.append([0]*(self._W+1)); self._H+=1; self._W+=1; self._made=1
for h in range(self._H-1):
for w in range(self._W-1):
self._G[h][w]+=self._G[h][w-1]+self._G[h-1][w]-self._G[h-1][w-1]
def query(self,Sh,Sw,Gh,Gw):
Sh,Sw,Gh,Gw=Sh-1,Sw-1,Gh-1,Gw-1
return self._G[Gh][Gw]-self._G[Sh][Gw]-self._G[Gh][Sw]+self._G[Sh][Sw]
#Disjoint Sparse Table 構築 O(NlogN), クエリ O(1)
class Disjoint_Sparse_Table: #結合律(A+B)+C = A+(B+C)が成り立てばOK
def __init__(self, A, identity_e, function):
self._N = N = len(A); self._logN = logN = (N - 1).bit_length()
self._M = M = 2 ** logN; self._e = e = identity_e; self._f = f = function
self._A = A = A + [e] * (M - N); self._T = T = [[e] * logN for _ in range(M)]
for x in range(logN):
t = 1 << x
for s in range(t, M, t << 1):
T[s][x] = A[s]
for j in range(s + 1, s + t, +1): T[j][x] = f(T[j-1][x], A[j])
for s in range(M - t - 1, -1, -t << 1):
T[s][x] = A[s]
for j in range(s - 1, s - t, -1): T[j][x] = f(A[j], T[j+1][x])
def fold(self, Lt, Rt): #半開区間[Lt:Rt)の作用値を返す
Lt, Rt = max(0, Lt), min(self._M, Rt) - 1; x = (Lt ^ Rt).bit_length() - 1
if not 0 <= Lt <= Rt < self._M: return self._e
if Lt == Rt: return self._A[Lt]
return self._f( self._T[Lt][x], self._T[Rt][x] )
#Segment Tree: O(logN)
class SegmentTree:
def __init__(self, n, identity_e, combine_f): self._n = n; self._size = 1 << (n-1).bit_length(); self._identity_e = identity_e; self._combine_f = combine_f; self._node = [self._identity_e] * 2 * self._size
def build(self, array):
assert len(array) == self._n, 'array too large'
for i,v in enumerate(array, start = self._size): self._node[i] = v
for i in range(self._size - 1, 0, -1): self._node[i] = self._combine_f(self._node[i<<1|0], self._node[i<<1|1])
def update(self, index, value): #一点更新
i = self._size + index; 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)の区間値を得る
L += self._size; R += self._size; vL = vR = self._identity_e
while L < R:
if L & 1: vL = self._combine_f(vL, self._node[L]); L += 1
if R & 1: R -= 1; vR = self._combine_f(self._node[R], vR)
L >>= 1; R >>= 1
return self._combine_f(vL, vR)
#down: Falseなら単調増加、Trueなら単調減少を仮定する。
#[Lt:Rt]の作用値がX以上/以下 となる、最小のRtを返す。閉区間なので扱い注意。
def bisect(self, Lt, X, down = False):
if Lt >= self._n: return self._n
now = Lt + self._size; cnt = self._identity_e
while 1: #nodeの上昇
f = now & 3; now = now >> 2 if f == 0 else now >> 1 if f == 2 else now; t = self._combine_f(cnt, self._node[now])
if not down and t >= X: break
elif down and t <= X: break
else:
cnt = t; now += 1
if now & (now - 1) == 0: return self._n
while now < self._size: #下降
Lt, Rt = self._node[now<<1|0], self._node[now<<1|1]
if not down and self._combine_f(cnt, Lt) >= X: now = now<<1|0
elif down and self._combine_f(cnt, Lt) <= X: now = now<<1|0
else: cnt = self._combine_f(cnt, Lt); now = now<<1|1
return now - self._size
N, M = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
#90度回転
def rotate(S):
return [[S[- h - 1][w] for h in range(N)] for w in range(N)]
#品に割るか、目に割るかを試す
def solve(S):
C = Csum2D(N, N)
C.build(S)
ans = 0
#1. 目割り
dp = [- 10 ** 18] * N
for h in range(N - M + 1):
for w in range(N - M + 1):
dp[h] = max(dp[h], C.query(h, w, h + M, w + M))
DST = Disjoint_Sparse_Table(dp, - 10 ** 18, max)
for a in range(N):
for b in range(a + M, N):
c = b + M
if c + M <= N:
ans = max(ans, dp[a] + dp[b] + DST.fold(c, N))
#2. 品割り
ST = SegmentTree(N, - 10 ** 18, max)
for h in range(N - M, -1, -1):
for w in range(N - M + 1):
if ST.fold(w, w + 1) < C.query(h, w, h + M, w + M):
ST.update(w, C.query(h, w, h + M, w + M))
t = h - M
if t >= 0:
for w in range(N - M + 1):
if w - M >= 0:
ans = max(ans, DST.fold(0, t + 1) + ST.fold(0, w - M + 1) + ST.fold(w, N))
return ans
ans = 0
for t in range(4):
ans = max(ans, solve(A))
A = rotate(A)
print(ans)
|
ConDefects/ConDefects/Code/abc347_f/Python/51970859
|
condefects-python_data_2316
|
S=input()
T=input()
A=["R G B","B R G","G B R"]
if S in A == T in A:
print("Yes")
else:
print("No")
S=input()
T=input()
A=["R G B","B R G","G B R"]
if (S in A) == (T in A):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc244_d/Python/45311340
|
condefects-python_data_2317
|
S=list(input().split())
T=list(input().split())
count=0
for i in range(3):
if S[i]==T[i]:
count+=1
print("Yes") if count!=2 else print("No")
S=list(input().split())
T=list(input().split())
count=0
for i in range(3):
if S[i]!=T[i]:
count+=1
print("Yes") if count!=2 else print("No")
|
ConDefects/ConDefects/Code/abc244_d/Python/46208474
|
condefects-python_data_2318
|
s = input()
t = input()
cnt = 0
for i in range(3):
if s[i] != t[i]:
cnt += 1
if cnt == 0:
print("Yes")
elif cnt == 3:
if t in s + s:
print("Yes")
else:
print("No")
s = input()
t = input()
s = s.replace(' ', '')
t = t.replace(' ', '')
cnt = 0
for i in range(3):
if s[i] != t[i]:
cnt += 1
if cnt == 0:
print("Yes")
elif cnt == 3:
if t in s + s:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc244_d/Python/45792017
|
condefects-python_data_2319
|
S = list(map(str, input().split()))
T = list(map(str, input().split()))
diff = 0
for i in range(3):
if S[i] != T[i]:
diff += 1
if diff % 2 == 0:
print('Yes')
else:
print('No')
S = list(map(str, input().split()))
T = list(map(str, input().split()))
diff = 0
for i in range(3):
if S[i] != T[i]:
diff += 1
if diff == 0 or diff % 2 == 1:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc244_d/Python/44600103
|
condefects-python_data_2320
|
S = [a for a in input().split()]
T = [a for a in input().split()]
cnt = 0
for i in range(3):
if S[i] == T[i]:
cnt += 1
if cnt%2 == 1:
print("Yes")
else:
print("No")
S = [a for a in input().split()]
T = [a for a in input().split()]
cnt = 0
for i in range(3):
if S[i] == T[i]:
cnt += 1
if cnt == 3 or cnt == 0:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc244_d/Python/45666207
|
condefects-python_data_2321
|
S1,S2,S3 = input().split()
T1,T2,T3 = input().split()
cnt = 0
if S1 != T1:
cnt += 1
if S2 != T2:
cnt += 1
if S3 != T3:
cnt += 1
print("Yes" if cnt%2==0 else "No")
S1,S2,S3 = input().split()
T1,T2,T3 = input().split()
cnt = 0
if S1 != T1:
cnt += 1
if S2 != T2:
cnt += 1
if S3 != T3:
cnt += 1
print("Yes" if cnt==0 or cnt==3 else "No")
|
ConDefects/ConDefects/Code/abc244_d/Python/46207866
|
condefects-python_data_2322
|
from collections import deque, defaultdict
from decimal import Decimal
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from itertools import permutations, combinations
from random import randrange, choices
from string import ascii_lowercase, ascii_uppercase
from os import environ
from copy import deepcopy
import math
import sys
sys.setrecursionlimit(10000000)
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())
s = input().split()
t = input().split()
def f(cnt, s0, s1, s2):
if cnt == 10:
return s0 == s[0] and s1 == s[1] and s2 == s[2]
return f(cnt + 1, s1, s0, s2) or f(cnt + 1, s0, s2, s1) or f(cnt + 1, s2, s1, s0)
ans = f(0, s[0], s[1], s[2])
print('Yes') if ans else print('No')
from collections import deque, defaultdict
from decimal import Decimal
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from itertools import permutations, combinations
from random import randrange, choices
from string import ascii_lowercase, ascii_uppercase
from os import environ
from copy import deepcopy
import math
import sys
sys.setrecursionlimit(10000000)
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())
s = input().split()
t = input().split()
def f(cnt, s0, s1, s2):
if cnt == 10:
return s0 == t[0] and s1 == t[1] and s2 == t[2]
return f(cnt + 1, s1, s0, s2) or f(cnt + 1, s0, s2, s1) or f(cnt + 1, s2, s1, s0)
ans = f(0, s[0], s[1], s[2])
print('Yes') if ans else print('No')
|
ConDefects/ConDefects/Code/abc244_d/Python/44593613
|
condefects-python_data_2323
|
A = ["RGB","GBR","BRG"]
S = input()
T = input()
print('Yes' if (S in A) == (T in A) else 'No')
A = ["R G B","G B R","B R G"]
S = input()
T = input()
print('Yes' if (S in A) == (T in A) else 'No')
|
ConDefects/ConDefects/Code/abc244_d/Python/45508442
|
condefects-python_data_2324
|
n,l,r = map(int,input().split())
n_l = [0]*(n.bit_length())
for i in range(n.bit_length()):
if n >> i & 1:
n_l[i] = 1
l_d = l.bit_length()
r_d = r.bit_length()
l_l = [0]*(l_d)
r_l = [0]*(r_d)
for i in range(l_d):
if l >> i & 1:
l_l[i] = 1
for i in range(r_d):
if r >> i & 1:
r_l[i] = 1
if n < l:
print(0)
exit()
ans = 0
power = [1]
for i in range(min(len(n_l),r_d)):
power.append(2*power[-1])
for i in range(min(len(n_l),r_d)):
if n_l[i] == 1:
ans += min(power[i+1]-1,r)-max(power[i],l)+1
print(ans)
n,l,r = map(int,input().split())
n_l = [0]*(n.bit_length())
for i in range(n.bit_length()):
if n >> i & 1:
n_l[i] = 1
l_d = l.bit_length()
r_d = r.bit_length()
l_l = [0]*(l_d)
r_l = [0]*(r_d)
for i in range(l_d):
if l >> i & 1:
l_l[i] = 1
for i in range(r_d):
if r >> i & 1:
r_l[i] = 1
if n < l:
print(0)
exit()
ans = 0
power = [1]
for i in range(min(len(n_l),r_d)):
power.append(2*power[-1])
for i in range(min(len(n_l),r_d)):
if n_l[i] == 1:
ans += max(min(power[i+1]-1,r)-max(power[i],l),-1)+1
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/38752586
|
condefects-python_data_2325
|
import sys
input = sys.stdin.readline
n, l, r = map(int, input().split())
out = 0
for i in range(60):
lo = max(l, 1 << i)
hi = min(r + 1, 2 * lo)
if hi >= lo and n & (1 << i):
out += hi - lo
print(out)
import sys
input = sys.stdin.readline
n, l, r = map(int, input().split())
out = 0
for i in range(60):
lo = max(l, 1 << i)
hi = min(r + 1, 1 << (i + 1))
if hi >= lo and n & (1 << i):
out += hi - lo
print(out)
|
ConDefects/ConDefects/Code/arc129_a/Python/43963825
|
condefects-python_data_2326
|
N, L, R = map(int, input().split())
ans = 0
for k in range(100):
if N&(1<<k):
rr = (1 << (k+1)) -1
ll = 1 << k
nums = rr - ll + 1
if R < rr:
nums -= (rr-R)
if ll < L:
nums -= (L-ll)
ans += nums
print(ans)
N, L, R = map(int, input().split())
ans = 0
for k in range(100):
if N&(1<<k):
rr = (1 << (k+1)) -1
ll = 1 << k
if rr < L or R < ll:
continue
nums = rr - ll + 1
if R < rr:
nums -= (rr-R)
if ll < L:
nums -= (L-ll)
ans += nums
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/37037100
|
condefects-python_data_2327
|
n,l,r=map(int,input().split())
ans=0
for i in range(60):
if (n>>i)&1:
ans+=min(r+1,(1<<(i+1)))-max(l,1<<i)
print(ans)
n,l,r=map(int,input().split())
ans=0
for i in range(60):
if (n>>i)&1:
ans+=max(0,min(r+1,(1<<(i+1)))-max(l,1<<i))
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/37413709
|
condefects-python_data_2328
|
n,l,r = map(int,input().split())
z=format(n,'b')
z=int(z)
s=list(str(z))
m=len(s)
ans=0
for i in range(m):
if n>>i&1 == 1:
if 2**i<=l<r<2**(i+1):
ans+=r-l+1
elif 2**i<l<2**(i+1):
ans+=2**(i+1)-l
elif 2**i<=r<2**(i+1):
ans+=r-2**i+1
else:
ans+=2**i
print(ans)
n,l,r = map(int,input().split())
z=format(n,'b')
z=int(z)
s=list(str(z))
m=len(s)
ans=0
for i in range(m):
if n>>i&1 == 1:
if 2**i<=l<r<2**(i+1):
ans+=r-l+1
elif 2**i<l<2**(i+1):
ans+=2**(i+1)-l
elif 2**i<=r<2**(i+1):
ans+=r-2**i+1
elif l<=2**i<2**(i+1)<r:
ans+=2**i
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/38833629
|
condefects-python_data_2329
|
n, l, r = map(int, input().split())
bin_n = bin(n)[2:]
rev = reversed(bin_n)
wari = []
for i, c in enumerate(rev):
if c == '1':
wari.append(2 ** i)
ans = 0
for num in wari:
s = num
e = s * 2 - 1
cnt = min(r, e) - max(l, s) + 1
ans += cnt
print(ans)
n, l, r = map(int, input().split())
bin_n = bin(n)[2:]
rev = reversed(bin_n)
wari = []
for i, c in enumerate(rev):
if c == '1':
wari.append(2 ** i)
ans = 0
for num in wari:
s = num
e = s * 2 - 1
cnt = min(r, e) - max(l, s) + 1
ans += max(cnt, 0)
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/44795955
|
condefects-python_data_2330
|
N, L, R = map(int, input().split())
n = format(N, 'b')
ans = 0
l = len(n)
x = 2 ** l
for i in range(len(n)):
x = x // 2
if n[i] == '1':
ans += min(R, 2 * x - 1) - max(L, x) + 1
print(ans)
N, L, R = map(int, input().split())
n = format(N, 'b')
ans = 0
l = len(n)
x = 2 ** l
for i in range(len(n)):
x = x // 2
if n[i] == '1':
ans += max(-1, min(R, 2 * x - 1) - max(L, x)) + 1
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/38487358
|
condefects-python_data_2331
|
import sys, math
from collections import deque
sys.setrecursionlimit(10 ** 9)
N, L, R = map(int,input().split())
p = N.bit_length()
ans = 0
for i in range(p):
if not (N >> i) & 1:
continue
ups = min(R, (1 << (i + 1)) - 1)
los = max(L, (1 << i))
ans += ups - los + 1
print(ans)
import sys, math
from collections import deque
sys.setrecursionlimit(10 ** 9)
N, L, R = map(int,input().split())
p = N.bit_length()
ans = 0
for i in range(p):
if not (N >> i) & 1:
continue
ups = min(R, (1 << (i + 1)) - 1)
los = max(L, (1 << i))
ans += max(ups - los + 1, 0)
print(ans)
|
ConDefects/ConDefects/Code/arc129_a/Python/39058948
|
condefects-python_data_2332
|
import sys
from collections import *
from functools import lru_cache, partial
from itertools import *
from pprint import pprint
def debug(*args, end='\n'): print(*args, end=end, file=sys.stderr)
dpprint = partial(pprint, stream=sys.stderr)
sys.setrecursionlimit(10 ** 6)
MOD=998244353
N = int(input())
# p x q^3 <= q^4 <= N
# q <= N^(1/4)
M = 700000
# M までの素数を列挙する
is_prime = [True] * (M + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, M + 1):
if not is_prime[i]:
continue
for j in range(i * 2, M + 1, i):
is_prime[j] = False
primes = [i for i, p in enumerate(is_prime, start=0) if p]
# debug(f"{is_prime[:20]=}")
# debug(f"{primes[:20]=}")
# debug(f"{len(primes)=}")
O = len(primes)
ans = 0
for i in range(O):
p = primes[i]
for j in range(i + 1, O):
q = primes[j]
if p * q * q * q > N:
break
ans += 1
print(ans)
import sys
from collections import *
from functools import lru_cache, partial
from itertools import *
from pprint import pprint
def debug(*args, end='\n'): print(*args, end=end, file=sys.stderr)
dpprint = partial(pprint, stream=sys.stderr)
sys.setrecursionlimit(10 ** 6)
MOD=998244353
N = int(input())
# p x q^3 <= q^4 <= N
# q <= N^(1/4)
M = 1000000
# M までの素数を列挙する
is_prime = [True] * (M + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, M + 1):
if not is_prime[i]:
continue
for j in range(i * 2, M + 1, i):
is_prime[j] = False
primes = [i for i, p in enumerate(is_prime, start=0) if p]
# debug(f"{is_prime[:20]=}")
# debug(f"{primes[:20]=}")
# debug(f"{len(primes)=}")
O = len(primes)
ans = 0
for i in range(O):
p = primes[i]
for j in range(i + 1, O):
q = primes[j]
if p * q * q * q > N:
break
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc250_d/Python/45811839
|
condefects-python_data_2333
|
n = int(input())
prl = [0] *(10**6)
def pr_jg(p):
pr = int(p ** (1/2)) + 1
m = 2
while m <= pr:
if p % m == 0:
return(False)
m += 1
return True
k = int((n//2) ** (1/3))
prl[0] = 2
cur = 1
for i in range(3,k+1):
if pr_jg(i):
prl[cur] = i
cur += 1
maxv = cur-1
ans = 0
for i in range(cur):
for j in range(maxv,i,-1):
if prl[i] * (prl[j]**3) <= n:
maxv = j
ans += j - i
break
print(ans)
n = int(input())
prl = [0] *(10**6)
def pr_jg(p):
pr = int(p ** (1/2)) + 1
m = 2
while m <= pr:
if p % m == 0:
return(False)
m += 1
return True
k = int((n//2) ** (1/3))
prl[0] = 2
cur = 1
for i in range(3,k+2):
if pr_jg(i):
prl[cur] = i
cur += 1
maxv = cur-1
ans = 0
for i in range(cur):
for j in range(maxv,i,-1):
if prl[i] * (prl[j]**3) <= n:
maxv = j
ans += j - i
break
print(ans)
|
ConDefects/ConDefects/Code/abc250_d/Python/44996552
|
condefects-python_data_2334
|
def enum_primes(n):
prime_flag = [1] * (n + 1)
prime_flag[0] = 0
prime_flag[1] = 0
i = 2
while i * i <= n:
if prime_flag[i]:
for j in range(2 * i, n + 1, i):
prime_flag[j] = 0
i += 1
return [i for i in range(n + 1) if prime_flag[i]]
N=int(input())
n=int(N**(1/3))+1
li=enum_primes(n)
ans=0
for i in range(len(li)):
p=li[i]
ok=i
ng=len(li)-1
while ng-ok>1:
j=(ok+ng)//2
q=li[j]
if p*q**3<=N:
ok=j
else:
ng=j
if ok>i:
ans+=ok-i
print(ans)
def enum_primes(n):
prime_flag = [1] * (n + 1)
prime_flag[0] = 0
prime_flag[1] = 0
i = 2
while i * i <= n:
if prime_flag[i]:
for j in range(2 * i, n + 1, i):
prime_flag[j] = 0
i += 1
return [i for i in range(n + 1) if prime_flag[i]]
N=int(input())
n=int(N**(1/3))+1
li=enum_primes(n)
ans=0
for i in range(len(li)):
p=li[i]
ok=i
ng=len(li)
while ng-ok>1:
j=(ok+ng)//2
q=li[j]
if p*q**3<=N:
ok=j
else:
ng=j
if ok>i:
ans+=ok-i
print(ans)
|
ConDefects/ConDefects/Code/abc250_d/Python/45025075
|
condefects-python_data_2335
|
# エラトステネスの篩
def Eratosthenes(N):
# 素数であるかの判定リスト
IsPrime=[True]*(N+1)
# i=2,3,4,...
i=2
# i≤√Nまで⇔i^2≤Nまで
while i**2<=N:
# iが素数でなければ
if IsPrime[i]==False:
# 次のiへ
i+=1
continue
# k=2,3,4,...
k=2
while i*k<=N:
# iの倍数は素数でない
IsPrime[i*k]=False
# 次のkへ
k+=1
# 次のkへ
i+=1
# 素数リスト
PList=[]
# i=2~N
for i in range(2,N+1):
# iが素数ならば
if IsPrime[i]==True:
# リストへ入れる
PList.append(i)
# リストを返す
return PList
N = int(input())
Alist = Eratosthenes(10**3)
lenAlist = len(Alist)
k=lenAlist-1
ans = 0
for i in range(lenAlist):
while i<k and N<Alist[i]*Alist[k]**3:
k-=1
if k<=i:
print(ans)
exit()
ans+=k-i
# エラトステネスの篩
def Eratosthenes(N):
# 素数であるかの判定リスト
IsPrime=[True]*(N+1)
# i=2,3,4,...
i=2
# i≤√Nまで⇔i^2≤Nまで
while i**2<=N:
# iが素数でなければ
if IsPrime[i]==False:
# 次のiへ
i+=1
continue
# k=2,3,4,...
k=2
while i*k<=N:
# iの倍数は素数でない
IsPrime[i*k]=False
# 次のkへ
k+=1
# 次のkへ
i+=1
# 素数リスト
PList=[]
# i=2~N
for i in range(2,N+1):
# iが素数ならば
if IsPrime[i]==True:
# リストへ入れる
PList.append(i)
# リストを返す
return PList
N = int(input())
Alist = Eratosthenes(10**6)
lenAlist = len(Alist)
k=lenAlist-1
ans = 0
for i in range(lenAlist):
while i<k and N<Alist[i]*Alist[k]**3:
k-=1
if k<=i:
print(ans)
exit()
ans+=k-i
|
ConDefects/ConDefects/Code/abc250_d/Python/45700046
|
condefects-python_data_2336
|
import heapq
n,m,k,l=map(int,input().split())
a=list(map(int,input().split()))
a=[0]+a
b=list(map(int,input().split()))
g=[[] for _ in range(n+1)]
for _ in range(m):
u,v,c=map(int,input().split())
g[u].append([v,c])
g[v].append([u,c])
ans=[[[10**18,-1] for _ in range(2)] for _ in range(n+1)]
hq=[]
for i in range(l):
heapq.heappush(hq,(0,b[i],a[b[i]]))
ans[b[i]][0]=[0,a[b[i]]]
while hq:
v,p,q=heapq.heappop(hq)
bool=True
for i in range(2):
if ans[p][i][1]==q and ans[p][i][0]==v:
bool=False
if bool:
continue
for i,j in g[p]:
bool=False
for k in range(2):
if ans[i][k][1]==q:
bool=True
if ans[i][k][0]>v+j:
ans[i][k]=[v+j,q]
if ans[i][0][0]<ans[i][1][0]:
ans[i][0],ans[i][1]=ans[i][1],ans[i][0]
heapq.heappush(hq,(v+j,i,q))
if bool:
continue
if ans[i][0][0]>v+j:
ans[i][1]=ans[i][0]
ans[i][0]=[v+j,q]
heapq.heappush(hq,(v+j,i,q))
elif ans[i][1][0]>v+j:
ans[i][1]=[v+j,q]
heapq.heappush(hq,(v+j,i,q))
fans=[-1]*n
for i in range(1,n+1):
for j in range(2):
if ans[i][j][1]==-1:
continue
if ans[i][j][1]!=a[i]:
fans[i-1]=ans[i][j][0]
break
print(*fans)
import heapq
n,m,k,l=map(int,input().split())
a=list(map(int,input().split()))
a=[0]+a
b=list(map(int,input().split()))
g=[[] for _ in range(n+1)]
for _ in range(m):
u,v,c=map(int,input().split())
g[u].append([v,c])
g[v].append([u,c])
ans=[[[10**18,-1] for _ in range(2)] for _ in range(n+1)]
hq=[]
for i in range(l):
heapq.heappush(hq,(0,b[i],a[b[i]]))
ans[b[i]][0]=[0,a[b[i]]]
while hq:
v,p,q=heapq.heappop(hq)
bool=True
for i in range(2):
if ans[p][i][1]==q and ans[p][i][0]==v:
bool=False
if bool:
continue
for i,j in g[p]:
bool=False
for k in range(2):
if ans[i][k][1]==q:
bool=True
if ans[i][k][0]>v+j:
ans[i][k]=[v+j,q]
if ans[i][0][0]>ans[i][1][0]:
ans[i][0],ans[i][1]=ans[i][1],ans[i][0]
heapq.heappush(hq,(v+j,i,q))
if bool:
continue
if ans[i][0][0]>v+j:
ans[i][1]=ans[i][0]
ans[i][0]=[v+j,q]
heapq.heappush(hq,(v+j,i,q))
elif ans[i][1][0]>v+j:
ans[i][1]=[v+j,q]
heapq.heappush(hq,(v+j,i,q))
fans=[-1]*n
for i in range(1,n+1):
for j in range(2):
if ans[i][j][1]==-1:
continue
if ans[i][j][1]!=a[i]:
fans[i-1]=ans[i][j][0]
break
print(*fans)
|
ConDefects/ConDefects/Code/abc245_g/Python/51453180
|
condefects-python_data_2337
|
from heapq import heappop, heappush
from typing import List, Tuple
INF = int(4e18)
def abc245g(
n: int, edges: List[Tuple[int, int, int]], colors: List[int], criticals: List[int]
) -> List[int]:
adjList = [[] for _ in range(n)]
for u, v, w in edges:
adjList[u].append((v, w))
adjList[v].append((u, w))
dist1, dist2 = [INF] * n, [INF] * n
fromColor1, fromColor2 = [-1] * n, [-1] * n
pq = []
for v in criticals:
dist1[v] = 0
fromColor1[v] = colors[v]
heappush(pq, (0, v, colors[v]))
while pq:
curDist, cur, curColor = heappop(pq)
if dist1[cur] != curDist and dist2[cur] != curDist:
continue
for next, weight in adjList[cur]:
nextDist = curDist + weight
if nextDist < dist1[next]:
if fromColor1[next] != curColor:
dist2[next] = dist1[next]
fromColor2[next] = fromColor1[next]
dist1[next] = nextDist
fromColor1[next] = curColor
heappush(pq, (dist1[next], next, curColor))
elif dist1[next] < nextDist < dist2[next] and fromColor1[next] != curColor:
dist2[next] = nextDist
fromColor2[next] = curColor
heappush(pq, (dist2[next], next, curColor))
res = [dist1[v] if fromColor1[v] != c else dist2[v] for v, c in enumerate(colors)]
for i in range(n):
if res[i] == INF:
res[i] = -1
return res
if __name__ == "__main__":
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
N, M, K, L = map(int, input().split())
colors = [v - 1 for v in map(int, input().split())]
criticals = [v - 1 for v in map(int, input().split())]
edges = []
for _ in range(M):
u, v, w = map(int, input().split())
edges.append((u - 1, v - 1, w))
print(*abc245g(N, edges, colors, criticals))
from heapq import heappop, heappush
from typing import List, Tuple
INF = int(4e18)
def abc245g(
n: int, edges: List[Tuple[int, int, int]], colors: List[int], criticals: List[int]
) -> List[int]:
adjList = [[] for _ in range(n)]
for u, v, w in edges:
adjList[u].append((v, w))
adjList[v].append((u, w))
dist1, dist2 = [INF] * n, [INF] * n
fromColor1, fromColor2 = [-1] * n, [-1] * n
pq = []
for v in criticals:
dist1[v] = 0
fromColor1[v] = colors[v]
heappush(pq, (0, v, colors[v]))
while pq:
curDist, cur, curColor = heappop(pq)
if dist1[cur] != curDist and dist2[cur] != curDist:
continue
for next, weight in adjList[cur]:
nextDist = curDist + weight
if nextDist < dist1[next]:
if fromColor1[next] != curColor:
dist2[next] = dist1[next]
fromColor2[next] = fromColor1[next]
dist1[next] = nextDist
fromColor1[next] = curColor
heappush(pq, (dist1[next], next, curColor))
elif nextDist < dist2[next] and fromColor1[next] != curColor:
dist2[next] = nextDist
fromColor2[next] = curColor
heappush(pq, (dist2[next], next, curColor))
res = [dist1[v] if fromColor1[v] != c else dist2[v] for v, c in enumerate(colors)]
for i in range(n):
if res[i] == INF:
res[i] = -1
return res
if __name__ == "__main__":
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
N, M, K, L = map(int, input().split())
colors = [v - 1 for v in map(int, input().split())]
criticals = [v - 1 for v in map(int, input().split())]
edges = []
for _ in range(M):
u, v, w = map(int, input().split())
edges.append((u - 1, v - 1, w))
print(*abc245g(N, edges, colors, criticals))
|
ConDefects/ConDefects/Code/abc245_g/Python/49870441
|
condefects-python_data_2338
|
# import io
# import sys
# _INPUT = """\
# 5 998244353
# """
# sys.stdin = io.StringIO(_INPUT)
n, mod = map(int, input().split())
dp = [[0]*(n+2) for _ in range(n+2)]
dp[0][0] = 1
dp[1][0] = -1
ans = 0
for i in range(n+1):
for j in range(n+1):
if i!=0:
dp[i][j] += dp[i-1][j]
dp[i][j] %= mod
for k, d in ((1, 2), (10, 3), (100, 4), (1000, 5)):
if i+k>n or j+d>n: break
dp[i+k][j+d] += dp[i][j]*(26 if i==0 else 25)
dp[i+k][j+d] %= mod
dp[min(i+k*10, n+1)][j+d] -= dp[i][j]*(26 if i==0 else 25)
dp[min(i+k*10, n+1)][j+d] %= mod
# print(dp)
print(sum(dp[n][:n]))
# import io
# import sys
# _INPUT = """\
# 5 998244353
# """
# sys.stdin = io.StringIO(_INPUT)
n, mod = map(int, input().split())
dp = [[0]*(n+2) for _ in range(n+2)]
dp[0][0] = 1
dp[1][0] = -1
ans = 0
for i in range(n+1):
for j in range(n+1):
if i!=0:
dp[i][j] += dp[i-1][j]
dp[i][j] %= mod
for k, d in ((1, 2), (10, 3), (100, 4), (1000, 5)):
if i+k>n or j+d>n: break
dp[i+k][j+d] += dp[i][j]*(26 if i==0 else 25)
dp[i+k][j+d] %= mod
dp[min(i+k*10, n+1)][j+d] -= dp[i][j]*(26 if i==0 else 25)
dp[min(i+k*10, n+1)][j+d] %= mod
# print(dp)
print(sum(dp[n][:n])%mod)
|
ConDefects/ConDefects/Code/abc249_e/Python/51504381
|
condefects-python_data_2339
|
n,M=map(int,input().split())
q=[[0]*(n+1) for i in range(n+1)]
q[0][0]=1
q[1][0]=-1
for i in range(n+1):
for j in range(n+1):
q[i][j]+=q[i-1][j]
q[i][j]%=M
for k in range(1,5):
if i+10**(k-1)<=n and j+1+k<=n:
q[i+10**(k-1)][j+1+k]+=q[i][j]*(25+(i==0))
if i+10**k<=n:
q[i+10**k][j+1+k]-=q[i][j]*(25+(i==0))
print(sum(q[n][:n])%M)
n,M=map(int,input().split())
q=[[0]*(n+1) for i in range(n+2)]
q[0][0]=1
q[1][0]=-1
for i in range(n+1):
for j in range(n+1):
q[i][j]+=q[i-1][j]
q[i][j]%=M
for k in range(1,5):
if i+10**(k-1)<=n and j+1+k<=n:
q[i+10**(k-1)][j+1+k]+=q[i][j]*(25+(i==0))
if i+10**k<=n:
q[i+10**k][j+1+k]-=q[i][j]*(25+(i==0))
print(sum(q[n][:n])%M)
|
ConDefects/ConDefects/Code/abc249_e/Python/47998431
|
condefects-python_data_2340
|
import sys
input = sys.stdin.readline
from collections import deque,Counter
N,K=map(int,input().split())
A=sorted(map(int,input().split()))
C=Counter(A)
mod=998244353
FACT=[1]
for i in range(1,N+10):
FACT.append(FACT[-1]*i%mod)
now=1
Q=deque(A)
ANS=1
while Q:
if Q[-1]+Q[0]>=K:
Q.pop()
ANS=ANS*now%mod
now+=1
else:
Q.popleft()
ANS=ANS*now%mod
now-=1
for v in C.values():
if v==1:
continue
ANS=ANS*pow(v,mod-2,mod)%mod
print(ANS)
import sys
input = sys.stdin.readline
from collections import deque,Counter
N,K=map(int,input().split())
A=sorted(map(int,input().split()))
C=Counter(A)
mod=998244353
FACT=[1]
for i in range(1,N+10):
FACT.append(FACT[-1]*i%mod)
now=1
Q=deque(A)
ANS=1
while Q:
if Q[-1]+Q[0]>=K:
Q.pop()
ANS=ANS*now%mod
now+=1
else:
Q.popleft()
ANS=ANS*now%mod
now-=1
for v in C.values():
if v==1:
continue
ANS=ANS*pow(FACT[v],mod-2,mod)%mod
print(ANS)
|
ConDefects/ConDefects/Code/arc148_e/Python/35986831
|
condefects-python_data_2341
|
from collections import Counter
P = 998244353
N, K = map(int, input().split())
nn = N + 10
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
A = [int(a) * 2 - K for a in input().split()]
R = [a for a in A if a > 0]
L = [-a for a in A if a < 0]
SS = sorted(set(R + L), key = lambda x: -x)
CR = Counter(R)
CL = Counter(L)
ans = 1
pos = 1
for i in SS:
a = CR[i]
ans = ans * C(pos + a - 1, a) % P
pos += a
a = CL[i]
ans = ans * C(pos, a) % P
pos -= a
print(ans)
from collections import Counter
P = 998244353
N, K = map(int, input().split())
nn = N + 10
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
A = [int(a) * 2 - K for a in input().split()]
R = [a for a in A if a >= 0]
L = [-a for a in A if a < 0]
SS = sorted(set(R + L), key = lambda x: -x)
CR = Counter(R)
CL = Counter(L)
ans = 1
pos = 1
for i in SS:
a = CR[i]
ans = ans * C(pos + a - 1, a) % P
pos += a
a = CL[i]
ans = ans * C(pos, a) % P
pos -= a
print(ans)
|
ConDefects/ConDefects/Code/arc148_e/Python/35713028
|
condefects-python_data_2342
|
N,K=map(int,input().split())
A=sorted([int(x) for x in input().split()])
mod=998244353
d=1
from collections import Counter
C=Counter(A)
for c in C:
for i in range(C[c]):
d*=i+1
d%=mod
x=pow(d,mod-2,mod)
t=1
j=N-1
for i in range(N):
while j>i:
if A[j]+A[i]>=K:
t+=1
else:
break
j-=1
if i==j:
break
x*=t*(t-1)
x%=mod
t-=1
for i in range(t+1):
x*=i+1
x%=mod
print(x)
N,K=map(int,input().split())
A=sorted([int(x) for x in input().split()])
mod=998244353
d=1
from collections import Counter
C=Counter(A)
for c in C:
for i in range(C[c]):
d*=i+1
d%=mod
x=pow(d,mod-2,mod)
t=1
j=N-1
for i in range(N):
while j>i:
if A[j]+A[i]>=K:
t+=1
else:
break
j-=1
if i==j:
break
x*=t*(t-1)
x%=mod
t-=1
for i in range(t):
x*=i+1
x%=mod
print(x)
|
ConDefects/ConDefects/Code/arc148_e/Python/34804387
|
condefects-python_data_2343
|
N,K=map(int,input().split())
A=[int(x) for x in input().split()]
mod=998244353
A.sort()
d=1
from collections import Counter
C=Counter(A)
for c in C:
for i in range(C[c]):
d*=i+1
d%=mod
dp=[1,0]
t=0
j=N-1
for i in range(N):
while j>=i:
if A[j]+A[i]>=K:
t+=1
else:
break
j-=1
if i==j:
break
dp2=[0,0]
dp2[0]=dp[0]*t*(t-1)%mod
dp2[1]=(dp[0]*t*2 +dp[1]*(t*(t-1)+t*2)) %mod
dp=dp2.copy()
t-=1
ans1=dp[0]
for i in range(t+1):
ans1*=i+1
ans1%=mod
ans2=dp[1]
for i in range(t+1):
ans2*=i+1
ans2%=mod
ans=ans1+ans2
ans*=pow(d,mod-2,mod)
print(ans%mod)
N,K=map(int,input().split())
A=[int(x) for x in input().split()]
mod=998244353
A.sort()
d=1
from collections import Counter
C=Counter(A)
for c in C:
for i in range(C[c]):
d*=i+1
d%=mod
dp=[1,0]
t=0
j=N-1
for i in range(N):
while j>i:
if A[j]+A[i]>=K:
t+=1
else:
break
j-=1
if i==j:
break
dp2=[0,0]
dp2[0]=dp[0]*t*(t-1)%mod
dp2[1]=(dp[0]*t*2 +dp[1]*(t*(t-1)+t*2)) %mod
dp=dp2.copy()
t-=1
ans1=dp[0]
for i in range(t+1):
ans1*=i+1
ans1%=mod
ans2=dp[1]
for i in range(t+1):
ans2*=i+1
ans2%=mod
ans=ans1+ans2
ans*=pow(d,mod-2,mod)
print(ans%mod)
|
ConDefects/ConDefects/Code/arc148_e/Python/34801295
|
condefects-python_data_2344
|
from collections import Counter
M = 998244353
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
res = 1
j = n-1
fact = [1] * (n+1)
for i in range(1, n+1):
fact[i] = fact[i-1] * i % M
for i, x in enumerate(a):
if x >= (k+1) // 2:
break
while a[j] + x >= k:
res = res * max(0, n-j-i) % M
j -= 1
res = res * max(0, n-j-i) % M
while j >= i:
res = res * max(0, n-j-i) % M
j -= 1
for v in Counter(a).values():
res = res * pow(v, M-2, M) % M
print(res)
from collections import Counter
M = 998244353
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
res = 1
j = n-1
fact = [1] * (n+1)
for i in range(1, n+1):
fact[i] = fact[i-1] * i % M
for i, x in enumerate(a):
if x >= (k+1) // 2:
break
while a[j] + x >= k:
res = res * max(0, n-j-i) % M
j -= 1
res = res * max(0, n-j-i) % M
while j >= i:
res = res * max(0, n-j-i) % M
j -= 1
for v in Counter(a).values():
res = res * pow(fact[v], M-2, M) % M
print(res)
|
ConDefects/ConDefects/Code/arc148_e/Python/39108367
|
condefects-python_data_2345
|
n = int(input())
ans = ""
for i in range(n + 1):
judge = False
for j in range(1,9):
if n % j == 0:
if i % (n / j) == 0:
judge = True
ans += str(j)
break
if judge:
pass
else:
ans += "-"
print(ans)
n = int(input())
ans = ""
for i in range(n + 1):
judge = False
for j in range(1,10):
if n % j == 0:
if i % (n / j) == 0:
judge = True
ans += str(j)
break
if judge:
pass
else:
ans += "-"
print(ans)
|
ConDefects/ConDefects/Code/abc319_b/Python/46199988
|
condefects-python_data_2346
|
N = int(input())
D=[]
for i in range(1,9):
if N % i ==0:
D.append(i)
S =[1]+["-"]*(N)
for i in range(1,N+1):
for d in D:
if i % (N/d) == 0:
S[i] = d
break
print(*S,sep="")
N = int(input())
D=[]
for i in range(1,10):
if N % i ==0:
D.append(i)
S =[1]+["-"]*(N)
for i in range(1,N+1):
for d in D:
if i % (N/d) == 0:
S[i] = d
break
print(*S,sep="")
|
ConDefects/ConDefects/Code/abc319_b/Python/45808237
|
condefects-python_data_2347
|
N = int(input())
def judge_num(num):
for j in range(1,11):
if N % j == 0:
if num % (N / j) == 0:
return str(j)
break
return "-"
ans = str()
for i in range(0, N+1):
ans = ans + judge_num(i)
print(ans)
N = int(input())
def judge_num(num):
for j in range(1,10):
if N % j == 0:
if num % (N / j) == 0:
return str(j)
break
return "-"
ans = str()
for i in range(0, N+1):
ans = ans + judge_num(i)
print(ans)
|
ConDefects/ConDefects/Code/abc319_b/Python/45999150
|
condefects-python_data_2348
|
import sympy as sp
def solver():
N = int(input())
divisors = sp.divisors(N)
# divisros のうち1から9までの約数を取り出す
divisors = [i for i in divisors if 1 <= i <= 9]
for i in range(N + 2):
flag = False
for j in divisors:
tmp = N // j
if i % tmp == 0:
print(j, end="")
flag = True
break
if not flag:
print("-", end="")
if __name__ == "__main__":
solver()
import sympy as sp
def solver():
N = int(input())
divisors = sp.divisors(N)
# divisros のうち1から9までの約数を取り出す
divisors = [i for i in divisors if 1 <= i <= 9]
for i in range(N + 1):
flag = False
for j in divisors:
tmp = N // j
if i % tmp == 0:
print(j, end="")
flag = True
break
if not flag:
print("-", end="")
if __name__ == "__main__":
solver()
|
ConDefects/ConDefects/Code/abc319_b/Python/45811398
|
condefects-python_data_2349
|
n = int(input())
s = ["-"] * (n+1)
for i in range(n+1):
for j in range(1, 9):
if n % j == 0 and i % (n/j) == 0:
s[i] = str(j)
break
result = ''.join(s)
print(result)
n = int(input())
s = ["-"] * (n+1)
for i in range(n+1):
for j in range(1, 10):
if n % j == 0 and i % (n/j) == 0:
s[i] = str(j)
break
result = ''.join(s)
print(result)
|
ConDefects/ConDefects/Code/abc319_b/Python/45813638
|
condefects-python_data_2350
|
def get_divisors_list(num):
divisors = []
for i in range(1, num+1 if num < 9 else 9):
if num % i == 0:
divisors.append(i)
return divisors
def main():
n = int(input())
divisors = get_divisors_list(n)
answer = ""
for i in range(n+1):
is_found = False
for j in divisors:
if i % (n / j) == 0:
answer += str(j)
is_found = True
break
if not is_found:
answer += "-"
print(answer)
if __name__ == "__main__":
main()
def get_divisors_list(num):
divisors = []
for i in range(1, num+1 if num < 9 else 10):
if num % i == 0:
divisors.append(i)
return divisors
def main():
n = int(input())
divisors = get_divisors_list(n)
answer = ""
for i in range(n+1):
is_found = False
for j in divisors:
if i % (n / j) == 0:
answer += str(j)
is_found = True
break
if not is_found:
answer += "-"
print(answer)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc319_b/Python/45969465
|
condefects-python_data_2351
|
def getInt():
return int(input())
def main():
n = getInt()
a = [j for j in range(1, 9) if n % j == 0]
r = ''
for i in range(n + 1):
x = [b for b in a if i % (n / b) == 0]
if len(x) == 0:
r += '-'
else:
r += str(min(x))
print(r)
if __name__ == "__main__":
main()
def getInt():
return int(input())
def main():
n = getInt()
a = [j for j in range(1, 10) if n % j == 0]
r = ''
for i in range(n + 1):
x = [b for b in a if i % (n / b) == 0]
if len(x) == 0:
r += '-'
else:
r += str(min(x))
print(r)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc319_b/Python/46206496
|
condefects-python_data_2352
|
class Centroid_decomposition:
def __init__(self, N, graph):
self._N = N
self._C = C = [dict() for _ in range(N)]
self._B = B = [list() for _ in range(N)]
Q = [(0, -1)]
S = [1] * N
for now,back in Q:
for nxt in G[now]:
if nxt != back: Q.append((nxt, now))
while Q:
now,back = Q.pop()
if back != -1: S[back] += S[now]
#重心分解(再帰での実装例)
def find(now):
while True: #1. 重心探索
for nxt in G[now]:
if len(C[nxt]) == 0 and S[nxt] * 2 > S[now]:
S[now], S[nxt] = S[now] - S[nxt], S[now]
now = nxt
break
else: break
R = [(now, -1)] #2. BFSで部分木を全探索
while R:
i,b = R.pop()
C[now][i] = []
for t in G[i]:
if len(C[t]) == 0 and b != t:
R.append((t, i))
C[now][i].append(t)
if S[now] > 1: #3. 部分木を重心分解
for nxt in G[now]:
if len(C[nxt]) == 0:
find(nxt)
for i in C[now]: #4. 帰りがけにB: belongに反映
B[i].append(now)
#重心分解(非再帰での実装例)
Q = [now]
R = []
while Q:
now = Q.pop()
if now >= 0: #行きがけの処理
Q.append(~now)
while True:
for nxt in G[now]:
if len(C[nxt]) == 0 and S[nxt] * 2 > S[now]:
S[now], S[nxt] = S[now] - S[nxt], S[now]
now = nxt
break
else: break
R.append((now, -1))
while R:
i,b = R.pop()
C[now][i] = []
for t in G[i]:
if len(C[t]) == 0 and b != t:
R.append((t, i))
C[now][i].append(t)
if S[now] > 1:
for nxt in G[now]:
if len(C[nxt]) == 0:
Q.append(nxt)
else: #帰りがけの処理
now = ~now
for i in C[now]:
B[i].append(now)
#入力受取
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N - 1):
a,b = map(int,input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
#重心分解
C = Centroid_decomposition(N, G)
#親を探す
P = [-1] * N
for i in range(N):
L = C._B[i] #所属の一覧 左ほど小さい部分木
if len(L) > 1:
P[i] = L[1] + 1
#答えを出力
print(*P)
class Centroid_decomposition:
def __init__(self, N, graph):
self._N = N
self._C = C = [dict() for _ in range(N)]
self._B = B = [list() for _ in range(N)]
Q = [(0, -1)]
S = [1] * N
for now,back in Q:
for nxt in G[now]:
if nxt != back: Q.append((nxt, now))
while Q:
now,back = Q.pop()
if back != -1: S[back] += S[now]
#重心分解(再帰での実装例)
def find(now):
while True: #1. 重心探索
for nxt in G[now]:
if len(C[nxt]) == 0 and S[nxt] * 2 > S[now]:
S[now], S[nxt] = S[now] - S[nxt], S[now]
now = nxt
break
else: break
R = [(now, -1)] #2. BFSで部分木を全探索
while R:
i,b = R.pop()
C[now][i] = []
for t in G[i]:
if len(C[t]) == 0 and b != t:
R.append((t, i))
C[now][i].append(t)
if S[now] > 1: #3. 部分木を重心分解
for nxt in G[now]:
if len(C[nxt]) == 0:
find(nxt)
for i in C[now]: #4. 帰りがけにB: belongに反映
B[i].append(now)
#重心分解(非再帰での実装例)
Q = [now]
R = []
while Q:
now = Q.pop()
if now >= 0: #行きがけの処理
while True:
for nxt in G[now]:
if len(C[nxt]) == 0 and S[nxt] * 2 > S[now]:
S[now], S[nxt] = S[now] - S[nxt], S[now]
now = nxt
break
else: break
Q.append(~now) #ここで追加
R.append((now, -1))
while R:
i,b = R.pop()
C[now][i] = []
for t in G[i]:
if len(C[t]) == 0 and b != t:
R.append((t, i))
C[now][i].append(t)
if S[now] > 1:
for nxt in G[now]:
if len(C[nxt]) == 0:
Q.append(nxt)
else: #帰りがけの処理
now = ~now
for i in C[now]:
B[i].append(now)
#入力受取
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N - 1):
a,b = map(int,input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
#重心分解
C = Centroid_decomposition(N, G)
#親を探す
P = [-1] * N
for i in range(N):
L = C._B[i] #所属の一覧 左ほど小さい部分木
if len(L) > 1:
P[i] = L[1] + 1
#答えを出力
print(*P)
|
ConDefects/ConDefects/Code/abc291_h/Python/50116430
|
condefects-python_data_2353
|
def Make_Centroid_Tree():
parent = [0] * N
size = [0] * N
used = [0] * N
def dfs(root):
que = [N * N]
order = []
while que:
x = que.pop()
v, u = x % N, x // N
order.append([v, u])
for w in g[v]:
if w == u or used[w]:
continue
que.append(w + v * N)
order.reverse()
for v, u in order:
size[v] = 1
for w in g[v]:
if w == u or used[w]:
continue
size[v] += size[w]
border = size[root] // 2
centroid = -1
for v, u in order:
if size[v] < border:
continue
flag = 1
for w in g[v]:
if w == u or used[w]:
continue
if size[w] > border:
flag = 0
if flag:
centroid = v
return centroid
que = [N * N]
while que:
x = que.pop()
root, p = x % N, x // N
centroid = dfs(root)
parent[centroid] = p
used[centroid] = 1
for w in g[centroid]:
if used[w]:
continue
que.append(w + centroid * N)
for i, p in enumerate(parent):
parent[i] = p if p != N else -1
return parent
N = int(input())
g = [[] for _ in range(N)]
for _ in range(N - 1):
v, w = map(int, input().split())
v -= 1
w -= 1
g[v].append(w)
g[w].append(v)
par = Make_Centroid_Tree()
ans = [a + 1 if a != -1 else -1 for a in par]
print(*ans)
def Make_Centroid_Tree():
parent = [0] * N
size = [0] * N
used = [0] * N
def dfs(root):
que = [root + N * N]
order = []
while que:
x = que.pop()
v, u = x % N, x // N
order.append([v, u])
for w in g[v]:
if w == u or used[w]:
continue
que.append(w + v * N)
order.reverse()
for v, u in order:
size[v] = 1
for w in g[v]:
if w == u or used[w]:
continue
size[v] += size[w]
border = size[root] // 2
centroid = -1
for v, u in order:
if size[v] < border:
continue
flag = 1
for w in g[v]:
if w == u or used[w]:
continue
if size[w] > border:
flag = 0
if flag:
centroid = v
return centroid
que = [N * N]
while que:
x = que.pop()
root, p = x % N, x // N
centroid = dfs(root)
parent[centroid] = p
used[centroid] = 1
for w in g[centroid]:
if used[w]:
continue
que.append(w + centroid * N)
for i, p in enumerate(parent):
parent[i] = p if p != N else -1
return parent
N = int(input())
g = [[] for _ in range(N)]
for _ in range(N - 1):
v, w = map(int, input().split())
v -= 1
w -= 1
g[v].append(w)
g[w].append(v)
par = Make_Centroid_Tree()
ans = [a + 1 if a != -1 else -1 for a in par]
print(*ans)
|
ConDefects/ConDefects/Code/abc291_h/Python/51212589
|
condefects-python_data_2354
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def is_ok(mid):
if sum(map(lambda x: x <= mid, A)) >= sum(map(lambda x: x >= mid, B)):
return True
else:
return False
def binary_search(ok, ng):
while ng - ok > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ng = mid
else:
ok = mid
return ng
print(binary_search(1, 1000000000))
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def is_ok(mid):
if sum(map(lambda x: x <= mid, A)) >= sum(map(lambda x: x >= mid, B)):
return True
else:
return False
def binary_search(ok, ng):
while ng - ok > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ng = mid
else:
ok = mid
return ng
print(binary_search(0, 1000000001))
|
ConDefects/ConDefects/Code/abc312_c/Python/45722260
|
condefects-python_data_2355
|
from bisect import bisect_left
def check(k):
x = bisect_left(a, k)
y = m - bisect_left(b, k)
return x >= y
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
ng = -1
ok = 10**10
while abs(ok - ng) > 1:
mid = ok + ng >> 1
if check(mid):
ok = mid
else:
ng = mid
print(ok)
from bisect import bisect_left
def check(k):
x = bisect_left(a, k + 0.5)
y = m - bisect_left(b, k)
return x >= y
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
ng = -1
ok = 10**10
while abs(ok - ng) > 1:
mid = ok + ng >> 1
if check(mid):
ok = mid
else:
ng = mid
print(ok)
|
ConDefects/ConDefects/Code/abc312_c/Python/45722066
|
condefects-python_data_2356
|
N,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
from bisect import bisect_right
from bisect import bisect_left
A.sort()
B.sort()
l=0
r=10**9
while l<r:
m=(l+r)//2
a=bisect_right(A,m)
b=M-bisect_left(B,m)
if a>=b:
r=m
else:
l=m+1
print(l)
N,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
from bisect import bisect_right
from bisect import bisect_left
A.sort()
B.sort()
l=0
r=10**9+1
while l<r:
m=(l+r)//2
a=bisect_right(A,m)
b=M-bisect_left(B,m)
if a>=b:
r=m
else:
l=m+1
print(l)
|
ConDefects/ConDefects/Code/abc312_c/Python/45923293
|
condefects-python_data_2357
|
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
amax = A[-1]
bmax = B[-1]
#ok = 10**9
ok = max(amax,bmax)
ng = 0
while abs(ok-ng)>1:
mid = (ok+ng)//2
sell = 0
for a in A:
if a <= mid:
sell += 1
buy = 0
for b in B:
if b >= mid:
buy += 1
#print(f"ok={ok},ng={ng}")
#print(f"sell={sell},buy={buy},mid={mid}")
if sell >= buy:
ok = mid
else:
ng = mid
#print(f"mid={mid}")
print(ok)
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
amax = A[-1]
bmax = B[-1]
#ok = 10**9
ok = max(amax,bmax+1)
ng = 0
while abs(ok-ng)>1:
mid = (ok+ng)//2
sell = 0
for a in A:
if a <= mid:
sell += 1
buy = 0
for b in B:
if b >= mid:
buy += 1
#print(f"ok={ok},ng={ng}")
#print(f"sell={sell},buy={buy},mid={mid}")
if sell >= buy:
ok = mid
else:
ng = mid
#print(f"mid={mid}")
print(ok)
|
ConDefects/ConDefects/Code/abc312_c/Python/46004421
|
condefects-python_data_2358
|
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
B = sorted(list(map(int, input().split())), reverse=True)
def bisect(ok, ng, solve):
while abs(ok - ng) > 1:
mid = (ng + ok) // 2
if solve(mid):
ok = mid
else:
ng = mid
return ok
def solve(x):
A_num = bisect(0, N, lambda m: A[m] <= x) + 1
if A[A_num-1] > x:
A_num = 0
B_num = bisect(0, M, lambda m: B[m] >= x) + 1
if B[B_num-1] < x:
B_num = 0
return A_num >= B_num
print(bisect(10 ** 9, -1, solve))
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
B = sorted(list(map(int, input().split())), reverse=True)
def bisect(ok, ng, solve):
while abs(ok - ng) > 1:
mid = (ng + ok) // 2
if solve(mid):
ok = mid
else:
ng = mid
return ok
def solve(x):
A_num = bisect(0, N, lambda m: A[m] <= x) + 1
if A[A_num-1] > x:
A_num = 0
B_num = bisect(0, M, lambda m: B[m] >= x) + 1
if B[B_num-1] < x:
B_num = 0
return A_num >= B_num
print(bisect(10 ** 9 + 1, -1, solve))
|
ConDefects/ConDefects/Code/abc312_c/Python/46056572
|
condefects-python_data_2359
|
#! /usr/bin/env python3
import numpy as np
import sys
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
B = list(map(int, input().rstrip().split()))
A.sort()
B.sort()
ans = 10**9
for i, a in enumerate(A):
idx = bisect_left(B, a)
if i+1 >= M - idx:
ans = min(ans, a)
break
for i, b in enumerate(B):
idx = bisect_right(A, b+1)
if idx >= M - i - 1:
ans = min(ans, b+1)
break
print(ans)
#! /usr/bin/env python3
import numpy as np
import sys
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, M = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
B = list(map(int, input().rstrip().split()))
A.sort()
B.sort()
ans = 10**10
for i, a in enumerate(A):
idx = bisect_left(B, a)
if i+1 >= M - idx:
ans = min(ans, a)
break
for i, b in enumerate(B):
idx = bisect_right(A, b+1)
if idx >= M - i - 1:
ans = min(ans, b+1)
break
print(ans)
|
ConDefects/ConDefects/Code/abc312_c/Python/46017936
|
condefects-python_data_2360
|
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
#A,B の判定
def check(x):
#売っても良い人数
anum = 0
for i in A:
if i<= x:
anum += 1
#買ってもいい人数
bnum = 0
for i in B:
if i >= x:
bnum += 1
return True if anum>= bnum else False
Le = 0
Ri = 1_000_000_000
while abs(Le-Ri)>1:
mid = (Le+Ri)//2
flag = check(mid)
if flag:
Ri = mid
else:
Le = mid
# print(Le,Ri)
print(Ri)
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
#A,B の判定
def check(x):
#売っても良い人数
anum = 0
for i in A:
if i<= x:
anum += 1
#買ってもいい人数
bnum = 0
for i in B:
if i >= x:
bnum += 1
return True if anum>= bnum else False
Le = 0
Ri = 1_000_000_001
while abs(Le-Ri)>1:
mid = (Le+Ri)//2
flag = check(mid)
if flag:
Ri = mid
else:
Le = mid
# print(Le,Ri)
print(Ri)
|
ConDefects/ConDefects/Code/abc312_c/Python/45783776
|
condefects-python_data_2361
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
mx = max(A[-1],B[-1])
def is_ok(x):
sell = len([a for a in A if a<=x])
buy = len([b for b in B if b>=x])
return sell>=buy
def binary_search(ng, ok):
"""
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
ng ok は とり得る最小の値-1 とり得る最大の値+1
最大最小が逆の場合はよしなにひっくり返す
"""
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(binary_search(0,mx))
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
mx = max(A[-1],B[-1])
def is_ok(x):
sell = len([a for a in A if a<=x])
buy = len([b for b in B if b>=x])
return sell>=buy
def binary_search(ng, ok):
"""
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
ng ok は とり得る最小の値-1 とり得る最大の値+1
最大最小が逆の場合はよしなにひっくり返す
"""
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(binary_search(0,mx+1))
|
ConDefects/ConDefects/Code/abc312_c/Python/46028780
|
condefects-python_data_2362
|
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
def count_seller(mid):
cnt = 0
for i in range(len(A)):
if A[i] <= mid:
cnt += 1
return cnt
def count_buyer(mid):
cnt = 0
for i in range(len(B)):
if B[i] >= mid:
cnt += 1
return cnt
# 二分探索する
left = -1
right = 1000000000
while right > (1 + left):
mid = (left + right) // 2
# mid円における売り手の人数
n_of_seller = count_seller(mid)
# mid円における買い手の人数
n_of_buyer = count_buyer(mid)
# 売り手＝買い手の場合、rightを出力するようにしたいので、等号はこっちに入れる。
if n_of_seller >= n_of_buyer:
right = mid
else: #n_of_seller < n_of_buyer
left = mid
print(right)
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
def count_seller(mid):
cnt = 0
for i in range(len(A)):
if A[i] <= mid:
cnt += 1
return cnt
def count_buyer(mid):
cnt = 0
for i in range(len(B)):
if B[i] >= mid:
cnt += 1
return cnt
# 二分探索する
left = -1
right = 10000000000
while right > (1 + left):
mid = (left + right) // 2
# mid円における売り手の人数
n_of_seller = count_seller(mid)
# mid円における買い手の人数
n_of_buyer = count_buyer(mid)
# 売り手＝買い手の場合、rightを出力するようにしたいので、等号はこっちに入れる。
if n_of_seller >= n_of_buyer:
right = mid
else: #n_of_seller < n_of_buyer
left = mid
print(right)
|
ConDefects/ConDefects/Code/abc312_c/Python/46019234
|
condefects-python_data_2363
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
#A,Bの判定
def check(x):
#売ってもいい人数
anum = 0
for i in A:
if i <= x:
anum += 1
#買ってもいい人数
bnum = 0
for i in B:
if i >= x:
bnum += 1
return True if anum >= bnum else False
Le = 0
Ri = 1_000_000_001
#checkを満たすxを二分探索する
while abs(Le-Ri)>1:
mid = (Le+Ri)//2
flag = check(mid)
if flag:
Ri = mid
else:
Le = mid
print(Le)
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
#A,Bの判定
def check(x):
#売ってもいい人数
anum = 0
for i in A:
if i <= x:
anum += 1
#買ってもいい人数
bnum = 0
for i in B:
if i >= x:
bnum += 1
return True if anum >= bnum else False
Le = 0
Ri = 1_000_000_001
#checkを満たすxを二分探索する
while abs(Le-Ri)>1:
mid = (Le+Ri)//2
flag = check(mid)
if flag:
Ri = mid
else:
Le = mid
print(Ri)
|
ConDefects/ConDefects/Code/abc312_c/Python/45814496
|
condefects-python_data_2364
|
# abc312c_InvisibleHand.py
from bisect import bisect_left,bisect_right
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
low = 0
high = 10**9
while low +1 < high:
m = (high+low)//2
fx = bisect_right(A,m)
gx = M - bisect_left(B,m)
if fx >= gx: high = m
else: low = m
print(high)
# abc312c_InvisibleHand.py
from bisect import bisect_left,bisect_right
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
low = 0
high = 10**9+1
while low +1 < high:
m = (high+low)//2
fx = bisect_right(A,m)
gx = M - bisect_left(B,m)
if fx >= gx: high = m
else: low = m
print(high)
|
ConDefects/ConDefects/Code/abc312_c/Python/46161992
|
condefects-python_data_2365
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def check(X):
a = 0
b = 0
for i in range(N):
if A[i] <= X:
a += 1
for i in range(M):
if B[i] >= X:
b += 1
if a >= b:
flag = True
else:
flag = False
return flag
left = 0
right = 1000000000
while (right - left) > 1:
mid = (right + left)//2
flag = check(mid)
if flag:
right = mid
else:
left = mid
print(right)
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def check(X):
a = 0
b = 0
for i in range(N):
if A[i] <= X:
a += 1
for i in range(M):
if B[i] >= X:
b += 1
if a >= b:
flag = True
else:
flag = False
return flag
left = 0
right = 1000000001
while (right - left) > 1:
mid = (right + left)//2
flag = check(mid)
if flag:
right = mid
else:
left = mid
print(right)
|
ConDefects/ConDefects/Code/abc312_c/Python/45783787
|
condefects-python_data_2366
|
r=range
K=int(input().split()[1])
N=int(K**.5)
S=(K-N*N)//2
f=lambda a,b:[print(x,y,a-x-y)for x in r(b)for y in r(b)if x+y<=a and x+y+b>=a]
f(S-2,N)
f(S+N-1,N+1)
f(S+N+N-1,N)
if(K+N*N)%2:print(N,N,N)
r=range
K=int(input().split()[1])
N=int(K**.5)
S=(K-N*N)//2
f=lambda a,b:[print(x,y,a-x-y)for x in r(b)for y in r(b)if x+y<=a and x+y+b>a]
f(S-2,N)
f(S+N-1,N+1)
f(S+N+N-1,N)
if(K+N*N)%2:print(N,N,N)
|
ConDefects/ConDefects/Code/arc175_e/Python/51661723
|
condefects-python_data_2367
|
a,b=map(int,input().split())
if abs(a-b)== 1 or 9:
print("Yes")
else:
print("No")
a,b=map(int,input().split())
if b - a == 1 or b - a == 9:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc240_a/Python/45813906
|
condefects-python_data_2368
|
a,b=map(int,input().split())
if abs(a%10-b%10)==1:
print('Yes')
else:print('No')
a,b=map(int,input().split())
if b-a==1 or (a==1 and b==10):
print('Yes')
else:print('No')
|
ConDefects/ConDefects/Code/abc240_a/Python/45299721
|
condefects-python_data_2369
|
a,b=map(int,input().split())
print(['YNeos'[a!=1::2],'YNeos'[b-1!=a::2]][b<10])
a,b=map(int,input().split())
print(['YNeos'[1<a<9::2],'YNeos'[b-1!=a::2]][b<10])
|
ConDefects/ConDefects/Code/abc240_a/Python/45200852
|
condefects-python_data_2370
|
a,b = map(int,input().split())
if abs(a % 10 - b % 10) == 1:
print("Yes")
else:
print("No")
a,b = map(int,input().split())
if abs(a % 10 - b % 10) in [1,9]:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc240_a/Python/45439093
|
condefects-python_data_2371
|
A,B = map(int,input().split())
if B-A == 1 or A-B == 9:
print("Yes")
else:
print("No")
A,B = map(int,input().split())
if B-A == 1 or B-A == 9:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc240_a/Python/45456899
|
condefects-python_data_2372
|
a, b = map(int, input().split())
if b - a or b - a == 9:
print('Yes')
else:
print('No')
a, b = map(int, input().split())
if b - a == 1 or b - a == 9:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc240_a/Python/45439558
|
condefects-python_data_2373
|
a,b = map(int,input().split())
ok = [(i,i+1) for i in range(9)]
ok.append((1,10))
if (a,b) in ok:
print("Yes")
else:
print("No")
a,b = map(int,input().split())
ok = [(i,i+1) for i in range(1,10)]
ok.append((1,10))
if (a,b) in ok:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc240_a/Python/46212840
|
condefects-python_data_2374
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n=I()
A=LI()
def f(t,l):
if t==0:
return 0
nl1=[]
nl2= []
for li in l:
if li>>t&1:
nl1+=[li]
else:
nl2+=[li]
if nl1 and nl2:
return min(f(t-1,nl1),f(t-1,nl2))|(1<<t)
else:
return f(t-1,l)
print(f(31,A))
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n=I()
A=LI()
def f(t,l):
if t==-1:
return 0
nl1=[]
nl2= []
for li in l:
if li>>t&1:
nl1+=[li]
else:
nl2+=[li]
if nl1 and nl2:
return min(f(t-1,nl1),f(t-1,nl2))|(1<<t)
else:
return f(t-1,l)
print(f(31,A))
|
ConDefects/ConDefects/Code/abc281_f/Python/45038482
|
condefects-python_data_2375
|
def dfs(digit,A,res):
S = []
T = []
for a in A:
if (a >> digit) & 1:
S.append(a)
else:
T.append(a)
if digit == 0:
global ans
if len(S) == 0:
ans = min(ans,res)
elif len(T) == 0:
ans = min(ans,res)
else:
ans = min(ans,res+1)
return
if len(S) == 0:
dfs(digit-1,T,res)
elif len(T) == 0:
dfs(digit-1,S,res)
else:
dfs(digit-1,S,res+2**digit)
dfs(digit-1,S,res+2**digit)
N = int(input())
A = list(map(int,input().split()))
ans = 2**30
dfs(29,A,0)
print(ans)
def dfs(digit,A,res):
S = []
T = []
for a in A:
if (a >> digit) & 1:
S.append(a)
else:
T.append(a)
if digit == 0:
global ans
if len(S) == 0:
ans = min(ans,res)
elif len(T) == 0:
ans = min(ans,res)
else:
ans = min(ans,res+1)
return
if len(S) == 0:
dfs(digit-1,T,res)
elif len(T) == 0:
dfs(digit-1,S,res)
else:
dfs(digit-1,S,res+2**digit)
dfs(digit-1,T,res+2**digit)
N = int(input())
A = list(map(int,input().split()))
ans = 2**30
dfs(29,A,0)
print(ans)
|
ConDefects/ConDefects/Code/abc281_f/Python/45472060
|
condefects-python_data_2376
|
import sys
sys.setrecursionlimit(10**6)
# sys.set_int_max_str_digits(10**6)
# mod = 998244353
# ds = [(-1,0),(0,1),(1,0),(0,-1)]
# inf = float('inf')
# ni,nj=i+di,j+dj
# 0<=ni<H and 0<=nj<W
# alph = 'abcdefghijklmnopqrstuvwxyz'
def rint(offset=0,base=10): return list(map(lambda x: int(x, base)+offset, input().split()))
def full(s, f=int, *args): return [full(s[1:], f) if len(s) > 1 else f(*args) for _ in range(s[0])]
def shift(*args,offset=-1): return (a+offset for a in args)
M, = rint()
# S = []
S = [list(map(int, list(input()))) for _ in range(3)]
# S = input()
from collections import deque
import heapq
inf = float("inf")
def next_chance(i,t,d):
for dt in range(M):
if S[i][(t+dt)%M] == d:
return dt
return inf
def options(t,d, vis):
best = inf
best_i = []
for i in range(3):
if not vis[i]:
score = next_chance(i,t,d)
if score < best:
best_i = [i]
best = score
elif score == best:
best_i.append(i)
return best, best_i
ans = inf
for d in range(10):
vis = [False]*3
def dfs(t,d):
if all(vis):
return -1
dt, opts = options(t,d,vis)
if dt == inf:
return inf
cost = inf
for s in opts:
if not vis[s]:
vis[s] = True
cost = min(cost, dfs(t+dt+1,d))+1
vis[s] = False
return dt+cost
ans = min(ans, dfs(0,d))
print(ans if ans != inf else -1)
# ans = False
# print("Yes" if ans else "No")
import sys
sys.setrecursionlimit(10**6)
# sys.set_int_max_str_digits(10**6)
# mod = 998244353
# ds = [(-1,0),(0,1),(1,0),(0,-1)]
# inf = float('inf')
# ni,nj=i+di,j+dj
# 0<=ni<H and 0<=nj<W
# alph = 'abcdefghijklmnopqrstuvwxyz'
def rint(offset=0,base=10): return list(map(lambda x: int(x, base)+offset, input().split()))
def full(s, f=int, *args): return [full(s[1:], f) if len(s) > 1 else f(*args) for _ in range(s[0])]
def shift(*args,offset=-1): return (a+offset for a in args)
M, = rint()
# S = []
S = [list(map(int, list(input()))) for _ in range(3)]
# S = input()
from collections import deque
import heapq
inf = float("inf")
def next_chance(i,t,d):
for dt in range(M):
if S[i][(t+dt)%M] == d:
return dt
return inf
def options(t,d, vis):
best = inf
best_i = []
for i in range(3):
if not vis[i]:
score = next_chance(i,t,d)
if score < best:
best_i = [i]
best = score
elif score == best:
best_i.append(i)
return best, best_i
ans = inf
for d in range(10):
vis = [False]*3
def dfs(t,d):
if all(vis):
return -1
dt, opts = options(t,d,vis)
if dt == inf:
return inf
cost = inf
for s in opts:
if not vis[s]:
vis[s] = True
cost = min(cost, dfs(t+dt+1,d)+1)
vis[s] = False
return dt+cost
ans = min(ans, dfs(0,d))
print(ans if ans != inf else -1)
# ans = False
# print("Yes" if ans else "No")
|
ConDefects/ConDefects/Code/abc320_c/Python/55010802
|
condefects-python_data_2377
|
"""
cf. https://atcoder.jp/contests/abc288/editorial/5659
"""
INF = 10**12
def solve(n, m, a, c, x):
x = [_-1 for _ in x]
# i番目の商品までで、j個の商品を買ったときに、必要なコスト
cost = [[INF] * n for i in range(n)]
for i in range(n):
cost[i][0] = c[i]
for j in range(1, i+1):
cost[i][j] = min(cost[i][j-1], c[i-j])
# 購入が必須かどうか
required = [False] * n
for i in x:
required[i] = True
dp = [[INF] * (n+1) for i in range(n+1)] # (現在の商品, 購入した数) => 最小金額
dp[0][0] = 0
for i in range(n):
for j in range(i+1):
dp[i+1][j+1] = min(dp[i+1][j+1], dp[i][j] + a[i] + cost[i][j])
if not required[i]: # 商品iを買わない
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
return min(dp[n][m:])
n, m = map(int, input().split())
a = [*map(int, input().split())]
c = [*map(int, input().split())]
x = [*map(int, input().split())]
print(solve(n, m, a, c, x))
"""
cf. https://atcoder.jp/contests/abc288/editorial/5659
"""
INF = 10**20
def solve(n, m, a, c, x):
x = [_-1 for _ in x]
# i番目の商品までで、j個の商品を買ったときに、必要なコスト
cost = [[INF] * n for i in range(n)]
for i in range(n):
cost[i][0] = c[i]
for j in range(1, i+1):
cost[i][j] = min(cost[i][j-1], c[i-j])
# 購入が必須かどうか
required = [False] * n
for i in x:
required[i] = True
dp = [[INF] * (n+1) for i in range(n+1)] # (現在の商品, 購入した数) => 最小金額
dp[0][0] = 0
for i in range(n):
for j in range(i+1):
dp[i+1][j+1] = min(dp[i+1][j+1], dp[i][j] + a[i] + cost[i][j])
if not required[i]: # 商品iを買わない
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
return min(dp[n][m:])
n, m = map(int, input().split())
a = [*map(int, input().split())]
c = [*map(int, input().split())]
x = [*map(int, input().split())]
print(solve(n, m, a, c, x))
|
ConDefects/ConDefects/Code/abc288_e/Python/41523056
|
condefects-python_data_2378
|
from bisect import *
N = int(input())
A = list(map(int, input().split()))
at = [[] for _ in range(N)]
for i, x in enumerate(A):
at[x - 1].append(i)
Q = int(input())
for it in range(Q):
L, R, X = map(int, input().split())
L -= 1
have = bisect_right(at[X - 1], R) - bisect_left(at[X - 1], L)
print(have)
from bisect import *
N = int(input())
A = list(map(int, input().split()))
at = [[] for _ in range(N)]
for i, x in enumerate(A):
at[x - 1].append(i)
Q = int(input())
for it in range(Q):
L, R, X = map(int, input().split())
L -= 1
have = bisect_left(at[X - 1], R) - bisect_left(at[X - 1], L)
print(have)
|
ConDefects/ConDefects/Code/abc248_d/Python/45763368
|
condefects-python_data_2379
|
import sys
from collections import deque,defaultdict
import heapq
import math
import collections
import itertools
import bisect
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
lli = lambda n: [li() for _ in range(n)]
N = ii()
A = li()
Q = ii()
d = defaultdict(list)
for i in range(N):
d[A[i]].append(i+1)
ans = []
for i in range(Q):
L,R,X = mi()
if d[X]:
left = bisect.bisect_left(d[X],L)
right = bisect.bisect_right(d[X],R)
ans.append(right-left)
else:
ans.append(0)
print(ans)
import sys
from collections import deque,defaultdict
import heapq
import math
import collections
import itertools
import bisect
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
lli = lambda n: [li() for _ in range(n)]
N = ii()
A = li()
Q = ii()
d = defaultdict(list)
for i in range(N):
d[A[i]].append(i+1)
ans = []
for i in range(Q):
L,R,X = mi()
if d[X]:
left = bisect.bisect_left(d[X],L)
right = bisect.bisect_right(d[X],R)
ans.append(right-left)
else:
ans.append(0)
print(*ans,sep="\n")
|
ConDefects/ConDefects/Code/abc248_d/Python/45983434
|
condefects-python_data_2380
|
from collections import defaultdict as dd
import bisect
N = int(input())
A =list(map(int, input().split()))
Q = int(input())
idx = [ [] for _ in range(N+1) ]
for i in range(N):
idx[A[i]].append(i+1)
for _ in range(Q):
L,R,X =map(int, input().split())
l = bisect.bisect_left(idx[X], L)
r = bisect.bisect_left(idx[X], R)
print(r-l)
from collections import defaultdict as dd
import bisect
N = int(input())
A =list(map(int, input().split()))
Q = int(input())
idx = [ [] for _ in range(N+1) ]
for i in range(N):
idx[A[i]].append(i+1)
for _ in range(Q):
L,R,X =map(int, input().split())
l = bisect.bisect_left(idx[X], L)
r = bisect.bisect_right(idx[X], R)
print(r-l)
|
ConDefects/ConDefects/Code/abc248_d/Python/45297242
|
condefects-python_data_2381
|
import bisect
N,T = input().split()
N = int(N)
k = len(T)
left = []
right = []
for i in range(N):
s = input()
c = 0
for j in s:
if j == T[c]: c += 1
if c == k: break
left.append(c)
c = 0
for j in s[::-1]:
if j == T[k-1-c]: c += 1
if c == k: break
right.append(c)
left.sort()
right.sort()
c = 0
for j in range(k+1):
x = bisect.bisect(left,j)-bisect.bisect_left(left,j)
y = N-bisect.bisect_left(right,k-1)
c += x*y
print(c)
import bisect
N,T = input().split()
N = int(N)
k = len(T)
left = []
right = []
for i in range(N):
s = input()
c = 0
for j in s:
if j == T[c]: c += 1
if c == k: break
left.append(c)
c = 0
for j in s[::-1]:
if j == T[k-1-c]: c += 1
if c == k: break
right.append(c)
left.sort()
right.sort()
c = 0
for j in range(k+1):
x = bisect.bisect(left,j)-bisect.bisect_left(left,j)
y = N-bisect.bisect_left(right,k-j)
c += x*y
print(c)
|
ConDefects/ConDefects/Code/abc324_e/Python/52742757
|
condefects-python_data_2382
|
from sortedcontainers import SortedList
n=int(input())
s=[*input()]
cnts=[]
i=0
while i<n:
if s[i]=="R":
for j in range(1,n+5):
if i-j<0 or s[i-j]!='A':
cnta=j-1
break
for j in range(1,n+5):
if i+j>=n or s[i+j]!='C':
cntc=j-1
break
i+=cnta
if min(cnta,cntc)!=0:
cnts.append(min(cnta,cntc))
i+=1
stl=SortedList(cnts)
ans=0
while stl:
tmp=stl.pop()
if tmp-1!=0:stl.add(tmp-1)
ans+=1
if not stl:break
stl.pop(0)
ans+=1
print(ans)
from sortedcontainers import SortedList
n=int(input())
s=[*input()]
cnts=[]
i=0
while i<n:
if s[i]=="R":
for j in range(1,n+5):
if i-j<0 or s[i-j]!='A':
cnta=j-1
break
for j in range(1,n+5):
if i+j>=n or s[i+j]!='C':
cntc=j-1
break
i+=cntc
if min(cnta,cntc)!=0:
cnts.append(min(cnta,cntc))
i+=1
stl=SortedList(cnts)
ans=0
while stl:
tmp=stl.pop()
if tmp-1!=0:stl.add(tmp-1)
ans+=1
if not stl:break
stl.pop(0)
ans+=1
print(ans)
|
ConDefects/ConDefects/Code/arc140_b/Python/45660608
|
condefects-python_data_2383
|
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
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
N = int(input())
S = input()
M = SortedMultiset()
for i in range(1, N-1):
if S[i-1:i+2] == 'ARC':
l,r = i-1, i+1
while l-1 > 0 and S[l-1] == 'A':
l -= 1
while r+1 < N and S[r+1] == 'C':
r += 1
m = min(i-l, r-i)
M.add(m)
cnt = 1
while M:
if cnt % 2 != 0:
v = M[-1]
M.discard(v)
if v - 1 > 0:
M.add(v-1)
else:
v = M[0]
M.discard(v)
cnt += 1
print(cnt-1)
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
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
N = int(input())
S = input()
M = SortedMultiset()
for i in range(1, N-1):
if S[i-1:i+2] == 'ARC':
l,r = i-1, i+1
while l-1 >= 0 and S[l-1] == 'A':
l -= 1
while r+1 < N and S[r+1] == 'C':
r += 1
m = min(i-l, r-i)
M.add(m)
cnt = 1
while M:
if cnt % 2 != 0:
v = M[-1]
M.discard(v)
if v - 1 > 0:
M.add(v-1)
else:
v = M[0]
M.discard(v)
cnt += 1
print(cnt-1)
|
ConDefects/ConDefects/Code/arc140_b/Python/44778158
|
condefects-python_data_2384
|
from collections import deque
N=int(input())
S=input()
def solve(N,S):
rs=[]
As,Cs=0,0
st=False
for s in S:
if s=='C':
Cs+=1
else:
if st:
st=False
rs[-1]=min(rs[-1],Cs)
Cs=0
if s=='R':
st=True
rs.append(As)
if s=='A':
As+=1
else:
As=0
if st:
rs[-1]=min(rs[-1],Cs)
print(rs)
sil,gold=0,deque()
for r in rs:
if r==0:
continue
elif r==1:
sil+=1
else:
gold.append(r)
time=0
while True:
time+=1
if time%2==1:
if len(gold)!=0:
p=gold.popleft()
p-=1
if p==1:
sil+=1
else:
gold.append(p)
elif sil>0:
sil-=1
else:
print(time-1)
return
else:
if sil>0:
sil-=1
elif len(gold)!=0:
p=gold.popleft()
else:
print(time-1)
return
'''
import itertools
import random
s='AAARRRCCC'
lis=list(itertools.permutations(s))
cs=random.sample(lis,5)
for c in cs:
print(c)
solve(9,c)
'''
solve(N,S)
from collections import deque
N=int(input())
S=input()
def solve(N,S):
rs=[]
As,Cs=0,0
st=False
for s in S:
if s=='C':
Cs+=1
else:
if st:
st=False
rs[-1]=min(rs[-1],Cs)
Cs=0
if s=='R':
st=True
rs.append(As)
if s=='A':
As+=1
else:
As=0
if st:
rs[-1]=min(rs[-1],Cs)
#print(rs)
sil,gold=0,deque()
for r in rs:
if r==0:
continue
elif r==1:
sil+=1
else:
gold.append(r)
time=0
while True:
time+=1
if time%2==1:
if len(gold)!=0:
p=gold.popleft()
p-=1
if p==1:
sil+=1
else:
gold.append(p)
elif sil>0:
sil-=1
else:
print(time-1)
return
else:
if sil>0:
sil-=1
elif len(gold)!=0:
p=gold.popleft()
else:
print(time-1)
return
'''
import itertools
import random
s='AAARRRCCC'
lis=list(itertools.permutations(s))
cs=random.sample(lis,5)
for c in cs:
print(c)
solve(9,c)
'''
solve(N,S)
|
ConDefects/ConDefects/Code/arc140_b/Python/40407040
|
condefects-python_data_2385
|
n=int(input())
s=list(map(str,input()))
R=[]
for i in range(1,n-1):
if s[i]=="R":
R.append(i)
ARCnum=0
ARClen=[]
for k in R:
le=0
nu=0
for i in range(1,min(k+1,n-k)):
if s[k-i]=="A" and s[k+i]=="C":
le+=1
nu=1
else:
ARCnum+=nu
if le>0:
ARClen.append(le-2)
break
if i==min(k,n-k-1):
ARCnum+=nu
if le>0:
ARClen.append(le-2)
break
ARClen.sort()
su=0
i=0
odd=0
even=0
while su<=0 and i<len(ARClen):
su+=ARClen[i]
if ARClen[i]==-1:
even+=1
i+=1
if su<=0:
print(2*ARCnum+sum(ARClen))
else:
print(2*i)
n=int(input())
s=list(map(str,input()))
R=[]
for i in range(1,n-1):
if s[i]=="R":
R.append(i)
ARCnum=0
ARClen=[]
for k in R:
le=0
nu=0
for i in range(1,min(k+1,n-k)):
if s[k-i]=="A" and s[k+i]=="C":
le+=1
nu=1
else:
ARCnum+=nu
if le>0:
ARClen.append(le-2)
break
if i==min(k,n-k-1):
ARCnum+=nu
if le>0:
ARClen.append(le-2)
break
ARClen.sort()
su=0
i=0
odd=0
even=0
while su<=0 and i<len(ARClen):
su+=ARClen[i]
if ARClen[i]==-1:
even+=1
i+=1
if su<=0:
print(2*ARCnum+sum(ARClen))
else:
print(2*ARCnum)
|
ConDefects/ConDefects/Code/arc140_b/Python/43246102
|
condefects-python_data_2386
|
import heapq
from collections import defaultdict
class MultiSet_Max():
"""
Multi Setクラス
Attributes
--------------------
add_heap : list
追加する要素を集めたヒープキュー
del_heap : list
削除する要素をヒープキュー
"""
def __init__(self):
self.add_heapq = []
self.del_heapq = []
self.di = defaultdict(int)
self.size = 0
def add(self, x: int | float):
"""
要素x をMulti Setに追加する
Parameters
--------------------
x: 追加する要素
"""
heapq.heappush(self.add_heapq, -x)
self.di[x] += 1
self.size += 1
def discard(self, x: int | float):
"""
要素x をMulti Setから削除する
Parameters
--------------------
x: 削除する要素
"""
heapq.heappush(self.del_heapq, -x)
self.di[x] = max(self.di[x] - 1, 0)
self.size -= 1
def get_max(self):
"""
Multi Setの最小要素を取得する
Returns
--------------------
min_value: Multi Setの最小要素
"""
while self.del_heapq and self.add_heapq[0] == self.del_heapq[0]:
heapq.heappop(self.add_heapq)
heapq.heappop(self.del_heapq)
max_value = -self.add_heapq[0]
return max_value
def pop_max(self):
"""
Multi Setの最小要素を削除する
Returns
--------------------
min_value: Multi Setの最小要素
"""
max_value = self.get_max()
self.discard(max_value)
return max_value
def is_empty(self):
"""
Multi Setが空かどうか判定する
Returns
--------------------
is_empty: Multi Setが空かどうか
"""
is_empty = len(self.add_heapq) - len(self.del_heapq) <= 0
return is_empty
def count(self, x: int | float):
"""
要素xの個数を返す
Returns
--------------------
x_count: 要素xの個数
"""
x_count = self.di[x]
return x_count
def __len__(self):
"""
Multi Set内にある要素の個数を返す
Returns
--------------------
size: 要素数
"""
return self.size
class MultiSet_Min():
"""
Multi Setクラス
Attributes
--------------------
add_heap : list
追加する要素を集めたヒープキュー
del_heap : list
削除する要素をヒープキュー
"""
def __init__(self):
self.add_heapq = []
self.del_heapq = []
self.di = defaultdict(int)
self.size = 0
def add(self, x: int | float):
"""
要素x をMulti Setに追加する
Parameters
--------------------
x: 追加する要素
"""
heapq.heappush(self.add_heapq, x)
self.di[x] += 1
self.size += 1
def discard(self, x: int | float):
"""
要素x をMulti Setから削除する
Parameters
--------------------
x: 削除する要素
"""
heapq.heappush(self.del_heapq, x)
self.di[x] = max(self.di[x] - 1, 0)
self.size -= 1
def get_min(self):
"""
Multi Setの最大要素を取得する
Returns
--------------------
max_value: Multi Setの最大要素
"""
while self.del_heapq and self.add_heapq[0] == self.del_heapq[0]:
heapq.heappop(self.add_heapq)
heapq.heappop(self.del_heapq)
min_value = self.add_heapq[0]
return min_value
def pop_min(self):
"""
Multi Setの最大要素を削除する
Returns
--------------------
max_value: Multi Setの最大要素
"""
min_value = self.get_min()
self.discard(min_value)
return min_value
def is_empty(self):
"""
Multi Setが空かどうか判定する
Returns
--------------------
is_empty: Multi Setが空かどうか
"""
is_empty = len(self.add_heapq) - len(self.del_heapq) <= 0
return is_empty
def count(self, x: int | float):
"""
要素xの個数を返す
Returns
--------------------
x_count: 要素xの個数
"""
x_count = self.di[x]
return x_count
def __len__(self):
"""
Multi Set内にある要素の個数を返す
Returns
--------------------
size: 要素数
"""
return self.size
# TODO:
# 双方向MultiSetを使って、
# 奇数回目のときは最大値をデクリメント、
# 偶数回目のときは最小値を消去
# それの実行回数を数える。
N = int(input())
S = input()
state = S[0]
A_cnt = 1 if state == "A" else 0
C_cnt = 1 if state == "C" else 0
mset_max = MultiSet_Max()
mset_min = MultiSet_Min()
for s in S[1:]:
if s == "A":
if state == "A":
A_cnt += 1
if state == "R":
A_cnt = 1
C_cnt = 0
if state == "C":
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
A_cnt = 1
C_cnt = 0
if s == "R":
if state == "A":
pass
if state == "R":
A_cnt = 0
C_cnt = 0
if state == "C":
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
A_cnt = 0
C_cnt = 0
if s == "C":
if state == "A":
A_cnt = 0
C_cnt = 1
if state == "R":
C_cnt = 1
if state == "C":
C_cnt += 1
state = s
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
cnt = 0
while not mset_max.is_empty() or not mset_min.is_empty():
cnt += 1
if cnt % 2 == 0:
delval = mset_min.pop_min()
mset_max.discard(delval)
if cnt % 2 == 1:
subval = mset_max.pop_max()
if subval - 1 > 0:
mset_max.add(subval - 1)
mset_min.discard(subval)
mset_min.add(subval)
else:
mset_min.discard(subval)
print(cnt)
import heapq
from collections import defaultdict
class MultiSet_Max():
"""
Multi Setクラス
Attributes
--------------------
add_heap : list
追加する要素を集めたヒープキュー
del_heap : list
削除する要素をヒープキュー
"""
def __init__(self):
self.add_heapq = []
self.del_heapq = []
self.di = defaultdict(int)
self.size = 0
def add(self, x: int | float):
"""
要素x をMulti Setに追加する
Parameters
--------------------
x: 追加する要素
"""
heapq.heappush(self.add_heapq, -x)
self.di[x] += 1
self.size += 1
def discard(self, x: int | float):
"""
要素x をMulti Setから削除する
Parameters
--------------------
x: 削除する要素
"""
heapq.heappush(self.del_heapq, -x)
self.di[x] = max(self.di[x] - 1, 0)
self.size -= 1
def get_max(self):
"""
Multi Setの最小要素を取得する
Returns
--------------------
min_value: Multi Setの最小要素
"""
while self.del_heapq and self.add_heapq[0] == self.del_heapq[0]:
heapq.heappop(self.add_heapq)
heapq.heappop(self.del_heapq)
max_value = -self.add_heapq[0]
return max_value
def pop_max(self):
"""
Multi Setの最小要素を削除する
Returns
--------------------
min_value: Multi Setの最小要素
"""
max_value = self.get_max()
self.discard(max_value)
return max_value
def is_empty(self):
"""
Multi Setが空かどうか判定する
Returns
--------------------
is_empty: Multi Setが空かどうか
"""
is_empty = len(self.add_heapq) - len(self.del_heapq) <= 0
return is_empty
def count(self, x: int | float):
"""
要素xの個数を返す
Returns
--------------------
x_count: 要素xの個数
"""
x_count = self.di[x]
return x_count
def __len__(self):
"""
Multi Set内にある要素の個数を返す
Returns
--------------------
size: 要素数
"""
return self.size
class MultiSet_Min():
"""
Multi Setクラス
Attributes
--------------------
add_heap : list
追加する要素を集めたヒープキュー
del_heap : list
削除する要素をヒープキュー
"""
def __init__(self):
self.add_heapq = []
self.del_heapq = []
self.di = defaultdict(int)
self.size = 0
def add(self, x: int | float):
"""
要素x をMulti Setに追加する
Parameters
--------------------
x: 追加する要素
"""
heapq.heappush(self.add_heapq, x)
self.di[x] += 1
self.size += 1
def discard(self, x: int | float):
"""
要素x をMulti Setから削除する
Parameters
--------------------
x: 削除する要素
"""
heapq.heappush(self.del_heapq, x)
self.di[x] = max(self.di[x] - 1, 0)
self.size -= 1
def get_min(self):
"""
Multi Setの最大要素を取得する
Returns
--------------------
max_value: Multi Setの最大要素
"""
while self.del_heapq and self.add_heapq[0] == self.del_heapq[0]:
heapq.heappop(self.add_heapq)
heapq.heappop(self.del_heapq)
min_value = self.add_heapq[0]
return min_value
def pop_min(self):
"""
Multi Setの最大要素を削除する
Returns
--------------------
max_value: Multi Setの最大要素
"""
min_value = self.get_min()
self.discard(min_value)
return min_value
def is_empty(self):
"""
Multi Setが空かどうか判定する
Returns
--------------------
is_empty: Multi Setが空かどうか
"""
is_empty = len(self.add_heapq) - len(self.del_heapq) <= 0
return is_empty
def count(self, x: int | float):
"""
要素xの個数を返す
Returns
--------------------
x_count: 要素xの個数
"""
x_count = self.di[x]
return x_count
def __len__(self):
"""
Multi Set内にある要素の個数を返す
Returns
--------------------
size: 要素数
"""
return self.size
# TODO:
# 双方向MultiSetを使って、
# 奇数回目のときは最大値をデクリメント、
# 偶数回目のときは最小値を消去
# それの実行回数を数える。
N = int(input())
S = input()
state = S[0]
A_cnt = 1 if state == "A" else 0
C_cnt = 1 if state == "C" else 0
mset_max = MultiSet_Max()
mset_min = MultiSet_Min()
for s in S[1:]:
if s == "A":
if state == "A":
A_cnt += 1
if state == "R":
A_cnt = 1
C_cnt = 0
if state == "C":
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
A_cnt = 1
C_cnt = 0
if s == "R":
if state == "A":
pass
if state == "R":
A_cnt = 0
C_cnt = 0
if state == "C":
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
A_cnt = 0
C_cnt = 0
if s == "C":
if state == "A":
A_cnt = 0
C_cnt = 1
if state == "R":
C_cnt = 1
if state == "C":
C_cnt += 1
state = s
val = min(A_cnt, C_cnt)
if val > 0:
mset_max.add(val)
mset_min.add(val)
cnt = 0
while not mset_max.is_empty() or not mset_min.is_empty():
cnt += 1
if cnt % 2 == 0:
delval = mset_min.pop_min()
mset_max.discard(delval)
if cnt % 2 == 1:
subval = mset_max.pop_max()
if subval - 1 > 0:
mset_max.add(subval - 1)
mset_min.discard(subval)
mset_min.add(subval - 1)
else:
mset_min.discard(subval)
print(cnt)
|
ConDefects/ConDefects/Code/arc140_b/Python/45256391
|
condefects-python_data_2387
|
from collections import Counter
n=int(input())
A=sorted(list(map(int,input().split())))
M=10**6
acount=[0]*(M+1)
for i in range(n):
acount[A[i]]+=1
for i in range(M):
acount[i+1]+=acount[i]
ans=0
for num,ct in Counter(A).items():
ans+=ct*(ct-1)//2
for j in range(1,M//num):
c=acount[min(M,(j+1)*num-1)]-acount[j*num-1]
if j==1:
c-=ct
ans+=c*ct*j
print(ans)
from collections import Counter
n=int(input())
A=sorted(list(map(int,input().split())))
M=10**6
acount=[0]*(M+1)
for i in range(n):
acount[A[i]]+=1
for i in range(M):
acount[i+1]+=acount[i]
ans=0
for num,ct in Counter(A).items():
ans+=ct*(ct-1)//2
for j in range(1,M//num+1):
c=acount[min(M,(j+1)*num-1)]-acount[j*num-1]
if j==1:
c-=ct
ans+=c*ct*j
print(ans)
|
ConDefects/ConDefects/Code/abc356_e/Python/54960213
|
condefects-python_data_2388
|
#!/usr/bin/env python3
import math
import sys
from bisect import ( # type: ignore
bisect,
bisect_left,
bisect_right,
insort,
insort_left,
insort_right,
)
from collections import Counter, defaultdict, deque # type: ignore
from heapq import ( # type: ignore
heapify,
heappop,
heappush,
heappushpop,
heapreplace,
merge,
)
from itertools import accumulate, combinations, permutations, product # type: ignore
from typing import Any, Generic, Iterable, Iterator, List, Optional, Tuple, TypeVar
T = TypeVar("T")
# fmt: off
def InputI(): return int(sys.stdin.buffer.readline())
def InputIM(): return map(int, sys.stdin.buffer.readline().split())
def InputIL(): return list(map(int, sys.stdin.buffer.readline().split()))
def InputS(): return sys.stdin.buffer.readline().rstrip().decode("utf-8")
def InputSS(): return sys.stdin.buffer.readline().rstrip().decode("utf-8").split()
def InputIR(n): return [InputI() for _ in range(n)]
def InputILR(n): return [InputIL() for _ in range(n)]
def InputSR(n): return [InputS() for _ in range(n)]
def InputSSR(n): return [InputSS() for _ in range(n)]
def InputSLR(n): return [list(InputS()) for _ in range(n)]
def InputSLIR(n): return [[int(i) for i in list(InputS())] for _ in range(n)]
inf = float("inf")
mod = 998244353
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)
# fmt: on
N = InputI()
A = InputIL()
A.sort()
le = [0] * (2*10**6+1)
for i in range(N):
le[A[i]] += 1
for i in range(1, 2*10**6+1):
le[i] += le[i-1]
cnt_A = dict(Counter(A))
ans = 0
for key, value in cnt_A.items():
for alpha in range(1, A[-1]//key+1):
if alpha == 1:
ans += alpha * (le[(alpha+1)*key-1] - le[alpha*key])
ans += alpha * value * (value-1) // 2
else:
ans += alpha * (le[(alpha+1)*key-1] - le[alpha*key-1]) * value
print(ans)
#!/usr/bin/env python3
import math
import sys
from bisect import ( # type: ignore
bisect,
bisect_left,
bisect_right,
insort,
insort_left,
insort_right,
)
from collections import Counter, defaultdict, deque # type: ignore
from heapq import ( # type: ignore
heapify,
heappop,
heappush,
heappushpop,
heapreplace,
merge,
)
from itertools import accumulate, combinations, permutations, product # type: ignore
from typing import Any, Generic, Iterable, Iterator, List, Optional, Tuple, TypeVar
T = TypeVar("T")
# fmt: off
def InputI(): return int(sys.stdin.buffer.readline())
def InputIM(): return map(int, sys.stdin.buffer.readline().split())
def InputIL(): return list(map(int, sys.stdin.buffer.readline().split()))
def InputS(): return sys.stdin.buffer.readline().rstrip().decode("utf-8")
def InputSS(): return sys.stdin.buffer.readline().rstrip().decode("utf-8").split()
def InputIR(n): return [InputI() for _ in range(n)]
def InputILR(n): return [InputIL() for _ in range(n)]
def InputSR(n): return [InputS() for _ in range(n)]
def InputSSR(n): return [InputSS() for _ in range(n)]
def InputSLR(n): return [list(InputS()) for _ in range(n)]
def InputSLIR(n): return [[int(i) for i in list(InputS())] for _ in range(n)]
inf = float("inf")
mod = 998244353
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)
# fmt: on
N = InputI()
A = InputIL()
A.sort()
le = [0] * (2*10**6+1)
for i in range(N):
le[A[i]] += 1
for i in range(1, 2*10**6+1):
le[i] += le[i-1]
cnt_A = dict(Counter(A))
ans = 0
for key, value in cnt_A.items():
for alpha in range(1, A[-1]//key+1):
if alpha == 1:
ans += alpha * (le[(alpha+1)*key-1] - le[alpha*key]) * value
ans += alpha * value * (value-1) // 2
else:
ans += alpha * (le[(alpha+1)*key-1] - le[alpha*key-1]) * value
print(ans)
|
ConDefects/ConDefects/Code/abc356_e/Python/54889247
|
condefects-python_data_2389
|
from itertools import permutations
N, H, W = map(int, input().split())
A, B = [None]*N, [None]*N
for i in range(N):
A[i], B[i] = map(int, input().split())
def check(p, s):
cnt = 0
S = [[False for _ in range(W)] for _ in range(H)]
for i in range(H):
for j in range(W):
if S[i][j] == False:
if cnt == N:
return False
if s & 1<<cnt:
a, b = A[p[cnt]], B[p[cnt]]
else:
a, b = B[p[cnt]], A[p[cnt]]
if 0 <= i+a <= H and 0 <= j+b <= W:
cnt += 1
for di in range(a):
for dj in range(b):
S[i+di][j+dj] = True
else:
return False
return True
for v in permutations(range(N)):
for k in range(1<<N):
if check(v, k):
print('Yes')
quit()
print('No')
from itertools import permutations
N, H, W = map(int, input().split())
A, B = [None]*N, [None]*N
for i in range(N):
A[i], B[i] = map(int, input().split())
def check(p, s):
cnt = 0
S = [[False for _ in range(W)] for _ in range(H)]
for i in range(H):
for j in range(W):
if S[i][j] == False:
if cnt == N:
return False
if s & 1<<cnt:
a, b = A[p[cnt]], B[p[cnt]]
else:
a, b = B[p[cnt]], A[p[cnt]]
if 0 <= i+a <= H and 0 <= j+b <= W:
cnt += 1
for di in range(a):
for dj in range(b):
if S[i+di][j+dj]:
return False
S[i+di][j+dj] = True
else:
return False
return True
for v in permutations(range(N)):
for k in range(1<<N):
if check(v, k):
print('Yes')
quit()
print('No')
|
ConDefects/ConDefects/Code/abc345_d/Python/54472552
|
condefects-python_data_2390
|
from itertools import product
import copy
import sys
sys.setrecursionlimit(1 << 20)
N,H,W = map(int, input().split())
AB = list()
for _ in range(N):
a,b = map(int, input().split())
AB.append([a,b])
global ans
ans = False
C = [ [True for _ in range(W)] for i in range(H)]
check = [0,1,0,1,1]
def dfs(x,y,rem,masu):
global ans
R = copy.deepcopy(rem)
M = copy.deepcopy(masu)
flag = True
#if bits==check:
# print("############")
#if x==H and y==W:
#print("##########")
#print(bits)
#for i in range(H):
# print(M[i])
if C==M:
#print(bits)
ans = True
return
if y==W:
for i in range(H):
flag = False
for j in range(W):
if M[i][j] == False:
x = i
y = j
flag = True
break
if flag:
break
"""
if bits==check:
print("#")
print(x,y)
print(R)
for i in range(H):
print(M[i])
"""
for i in range(len(R)):
#if bits==check:
# print("#####")
# print(x,y,R[i][0],R[i][1])
# print(x+R[i][0],y+R[i][1])
if x+R[i][0]<=H and y+R[i][1]<=W:
#if bits==check:
# print("##")
R_tmp = copy.deepcopy(R)
R_tmp.remove(R_tmp[i])
M_tmp = copy.deepcopy(M)
flag = True
for a in range(x,x+R[i][0]):
for b in range(y,y+R[i][1]):
if M_tmp[a][b]==True:
flag = False
M_tmp[a][b] = True
if flag==True:
dfs(x, y+R[i][1], R_tmp, M_tmp)
if x+R[i][1]<=H and y+R[i][0]<=W:
#if bits==check:
# print("###")
R_tmp = copy.deepcopy(R)
R_tmp.remove(R_tmp[i])
M_tmp = copy.deepcopy(M)
flag = True
for a in range(x,x+R[i][1]):
for b in range(y,y+R[i][0]):
if M_tmp[a][b]==True:
flag = False
M_tmp[a][b] = True
if flag==True:
dfs(x, y+R[i][0], R_tmp, M_tmp)
for bits in product([0,1],repeat=N):
bits = list(bits)
#print(bits)
item = list()
for i in range(N):
if bits[i]:
item.append(AB[i])
masu = [ [False for _ in range(W)] for j in range(H)]
csum = 0
for p in item:
csum += p[0]
if csum != H*W:
continue
dfs(0,0,item,masu)
if ans:
print("Yes")
else:
print("No")
from itertools import product
import copy
import sys
sys.setrecursionlimit(1 << 20)
N,H,W = map(int, input().split())
AB = list()
for _ in range(N):
a,b = map(int, input().split())
AB.append([a,b])
global ans
ans = False
C = [ [True for _ in range(W)] for i in range(H)]
check = [0,1,0,1,1]
def dfs(x,y,rem,masu):
global ans
R = copy.deepcopy(rem)
M = copy.deepcopy(masu)
flag = True
#if bits==check:
# print("############")
#if x==H and y==W:
#print("##########")
#print(bits)
#for i in range(H):
# print(M[i])
if C==M:
#print(bits)
ans = True
return
if y==W:
for i in range(H):
flag = False
for j in range(W):
if M[i][j] == False:
x = i
y = j
flag = True
break
if flag:
break
"""
if bits==check:
print("#")
print(x,y)
print(R)
for i in range(H):
print(M[i])
"""
for i in range(len(R)):
#if bits==check:
# print("#####")
# print(x,y,R[i][0],R[i][1])
# print(x+R[i][0],y+R[i][1])
if x+R[i][0]<=H and y+R[i][1]<=W:
#if bits==check:
# print("##")
R_tmp = copy.deepcopy(R)
R_tmp.remove(R_tmp[i])
M_tmp = copy.deepcopy(M)
flag = True
for a in range(x,x+R[i][0]):
for b in range(y,y+R[i][1]):
if M_tmp[a][b]==True:
flag = False
M_tmp[a][b] = True
if flag==True:
dfs(x, y+R[i][1], R_tmp, M_tmp)
if x+R[i][1]<=H and y+R[i][0]<=W:
#if bits==check:
# print("###")
R_tmp = copy.deepcopy(R)
R_tmp.remove(R_tmp[i])
M_tmp = copy.deepcopy(M)
flag = True
for a in range(x,x+R[i][1]):
for b in range(y,y+R[i][0]):
if M_tmp[a][b]==True:
flag = False
M_tmp[a][b] = True
if flag==True:
dfs(x, y+R[i][0], R_tmp, M_tmp)
for bits in product([0,1],repeat=N):
bits = list(bits)
#print(bits)
item = list()
for i in range(N):
if bits[i]:
item.append(AB[i])
masu = [ [False for _ in range(W)] for j in range(H)]
csum = 0
for p in item:
csum += p[0]*p[1]
if csum != H*W:
continue
dfs(0,0,item,masu)
if ans:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc345_d/Python/54461819
|
condefects-python_data_2391
|
def find_first_empty_pos():
for i in range(H):
for j in range(W):
if not G[i][j]:
return i,j
return -1,-1
def is_place(h,w,a,b):
if h+a > H or w+b > W:
return False
for i in range(h,h+a):
for j in range(w,w+b):
if G[i][j] != 0:
return False
return True
def place_or_delete(h,w,a,b,v):
for i in range(h,h+a):
for j in range(w,w+b):
G[i][j] = v
# 深さ優先探索
def dfs(r_node):
i,j = find_first_empty_pos()
if i == j == -1:
print("Yes")
exit()
for idx in r_node:
height,width = T[idx]
for a,b in [(height,width),(width,height)]:
if is_place(i,j,a,b):
place_or_delete(i,j,a,b,1)
dfs(S-{idx})
place_or_delete(i,j,a,b,0)
N,H,W = map(int,input().split())
T = [tuple(map(int,input().split())) for _ in range(N)]
G = [[0]*W for _ in range(H)]
S = set(range(N))
dfs(S)
print("No")
def find_first_empty_pos():
for i in range(H):
for j in range(W):
if not G[i][j]:
return i,j
return -1,-1
def is_place(h,w,a,b):
if h+a > H or w+b > W:
return False
for i in range(h,h+a):
for j in range(w,w+b):
if G[i][j] != 0:
return False
return True
def place_or_delete(h,w,a,b,v):
for i in range(h,h+a):
for j in range(w,w+b):
G[i][j] = v
# 深さ優先探索
def dfs(r_node):
i,j = find_first_empty_pos()
if i == j == -1:
print("Yes")
exit()
for idx in r_node:
height,width = T[idx]
for a,b in [(height,width),(width,height)]:
if is_place(i,j,a,b):
place_or_delete(i,j,a,b,1)
dfs(r_node-{idx})
place_or_delete(i,j,a,b,0)
N,H,W = map(int,input().split())
T = [tuple(map(int,input().split())) for _ in range(N)]
G = [[0]*W for _ in range(H)]
S = set(range(N))
dfs(S)
print("No")
|
ConDefects/ConDefects/Code/abc345_d/Python/53727420
|
condefects-python_data_2392
|
N = int(input())
grid = [[0 for _ in range(N)] for j in range(N)]
grid[(N+1)//2-1][(N+1)//2-1] = "T"
dir=[[0,1],[1,0],[0,-1],[-1,0]]
dirPath = 0
x=y=0
grid[x][y] = 1
for i in range(2,N**2):
while x+dir[dirPath][0] < 0 or x+dir[dirPath][0] > N-1 or y+dir[dirPath][1] < 0 or y+dir[dirPath][1] > N-1 or grid[x+dir[dirPath][0]][y+dir[dirPath][1]] != 0 :
dirPath = (dirPath+1)%4
x = x + dir[dirPath][0]
y = y + dir[dirPath][1]
print(x,y)
grid[x][y] = i
for i in range(N):
print(*grid[i])
N = int(input())
grid = [[0 for _ in range(N)] for j in range(N)]
grid[(N+1)//2-1][(N+1)//2-1] = "T"
dir=[[0,1],[1,0],[0,-1],[-1,0]]
dirPath = 0
x=y=0
grid[x][y] = 1
for i in range(2,N**2):
while x+dir[dirPath][0] < 0 or x+dir[dirPath][0] > N-1 or y+dir[dirPath][1] < 0 or y+dir[dirPath][1] > N-1 or grid[x+dir[dirPath][0]][y+dir[dirPath][1]] != 0 :
dirPath = (dirPath+1)%4
x = x + dir[dirPath][0]
y = y + dir[dirPath][1]
# print(x,y)
grid[x][y] = i
for i in range(N):
print(*grid[i])
|
ConDefects/ConDefects/Code/abc335_d/Python/53021579
|
condefects-python_data_2393
|
import sys
input=sys.stdin.readline
import heapq
N,M,L=map(int,input().split())
A=list(map(int,input().split()))
b=list(map(int,input().split()))
ban=set()
for i in range(L):
p,q=map(int,input().split())
ban.add(p*1000000+q)
B=[[b[i],i+1] for i in range(M)]
#A.sort(reverse=True)
B.sort(reverse=True)
cur=[0]*N
setmeal=[]
for i in range(N):
heapq.heappush(setmeal,(-A[i]-B[0][0],i))
while setmeal:
x,y=heapq.heappop(setmeal)
if (y+1)*1000000+B[cur[y]][1] not in ban:
print(-x)
exit()
else:
cur[y]+=1
if cur[y]<M:
heapq.heappush(setmeal,(-A[i]-B[cur[y]][0],y))
import sys
input=sys.stdin.readline
import heapq
N,M,L=map(int,input().split())
A=list(map(int,input().split()))
b=list(map(int,input().split()))
ban=set()
for i in range(L):
p,q=map(int,input().split())
ban.add(p*1000000+q)
B=[[b[i],i+1] for i in range(M)]
#A.sort(reverse=True)
B.sort(reverse=True)
cur=[0]*N
setmeal=[]
for i in range(N):
heapq.heappush(setmeal,(-A[i]-B[0][0],i))
while setmeal:
x,y=heapq.heappop(setmeal)
if (y+1)*1000000+B[cur[y]][1] not in ban:
print(-x)
exit()
else:
cur[y]+=1
if cur[y]<M:
heapq.heappush(setmeal,(-A[y]-B[cur[y]][0],y))
|
ConDefects/ConDefects/Code/abc331_e/Python/54003123
|
condefects-python_data_2394
|
from collections import defaultdict
def main():
N, M, L = mapint()
A = lint()
B = lint()
unCombSet = defaultdict(set)
is_reverse = False
if N > M:
N, M = M, N
A, B = B, A
is_reverse = True
for i in range(L):
x, y = mapint0()
if is_reverse:
x, y = y, x
unCombSet[x].add(y)
errprint(unCombSet)
a_sort = sorted(range(N), key=lambda x: A[x], reverse=True)
b_sort = sorted(range(M), key=lambda x: B[x], reverse=True)
ans = 0
for x, y in unCombSet.items():
min_index = M - 1
for i in range(M):
if b_sort[i] in y:
continue
min_index = i
break
ans = max(ans, A[x] + B[b_sort[min_index]])
for i in range(N):
if i in unCombSet:
continue
ans = max(ans, A[a_sort[i]] + B[b_sort[0]])
break
print(ans)
def ini(): return int(input())
def mapint(): return map(int, input().split())
def mapint0(): return map(lambda x: int(x)-1, input().split())
def mapstr(): return input().split()
def lint(): return list(map(int, input().split()))
def lint0(): return list(map(lambda x: int(x)-1, input().split()))
def lstr(): return list(input().rstrip())
def errprint(*x): return None if atcenv else print(*x, file=sys.stderr)
if __name__=="__main__":
import sys, os
input = sys.stdin.readline
atcenv = os.environ.get("ATCODER", 0)
main()
from collections import defaultdict
def main():
N, M, L = mapint()
A = lint()
B = lint()
unCombSet = defaultdict(set)
is_reverse = False
if N > M:
N, M = M, N
A, B = B, A
is_reverse = True
for i in range(L):
x, y = mapint0()
if is_reverse:
x, y = y, x
unCombSet[x].add(y)
errprint(unCombSet)
a_sort = sorted(range(N), key=lambda x: A[x], reverse=True)
b_sort = sorted(range(M), key=lambda x: B[x], reverse=True)
ans = 0
for x, y in unCombSet.items():
min_index = M - 1
for i in range(M):
if b_sort[i] in y:
continue
min_index = i
break
ans = max(ans, A[x] + B[b_sort[min_index]])
for i in range(N):
if a_sort[i] in unCombSet:
continue
ans = max(ans, A[a_sort[i]] + B[b_sort[0]])
break
print(ans)
def ini(): return int(input())
def mapint(): return map(int, input().split())
def mapint0(): return map(lambda x: int(x)-1, input().split())
def mapstr(): return input().split()
def lint(): return list(map(int, input().split()))
def lint0(): return list(map(lambda x: int(x)-1, input().split()))
def lstr(): return list(input().rstrip())
def errprint(*x): return None if atcenv else print(*x, file=sys.stderr)
if __name__=="__main__":
import sys, os
input = sys.stdin.readline
atcenv = os.environ.get("ATCODER", 0)
main()
|
ConDefects/ConDefects/Code/abc331_e/Python/52779261
|
condefects-python_data_2395
|
N, M, L = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pat = [list(map(lambda x:int(x)-1, input().split())) for _ in range(L)]
ng_set = set()
for i, j in pat:
ng_set.add((i, j))
#P:Bを価格の大きい順にソートしたものでindexも同時に保持している
P = sorted([(b, j) for j, b in enumerate(B)], reverse=True)
ans = -1
for i, a in enumerate(A):
for b, j in P:
if (i, j) in pat:
continue
ans = max(ans, a+b)
break
print(ans)
N, M, L = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pat = [list(map(lambda x:int(x)-1, input().split())) for _ in range(L)]
ng_set = set()
for i, j in pat:
ng_set.add((i, j))
#P:Bを価格の大きい順にソートしたものでindexも同時に保持している
P = sorted([(b, j) for j, b in enumerate(B)], reverse=True)
ans = -1
for i, a in enumerate(A):
for b, j in P:
if (i, j) in ng_set:
continue
ans = max(ans, a+b)
break
print(ans)
|
ConDefects/ConDefects/Code/abc331_e/Python/53576352
|
condefects-python_data_2396
|
# √(L+1)の範囲で全探索
N, M, L = map(int, input().split())
l_a = min(int(L**0.5)+1, N)
l_b = min(int(L**0.5)+1, M)
A = list(map(int, input().split()))
A_s = list([A[i], i] for i in range(N))
A.sort(reverse=True)
A_s.sort(reverse=True)
D_A = {A_s[i][1]:i for i in range(N)}
B = list(map(int, input().split()))
B_s = list([B[i], i] for i in range(M))
B.sort(reverse=True)
B_s.sort(reverse=True)
D_B = {B_s[i][1]:i for i in range(M)}
Q = dict()
for i in range(L):
c, d = map(int, input().split())
c -= 1
c = D_A[c]
d -= 1
d = D_B[d]
Q[c*10**6+d] = 1
ans = 0
for a in range(l_a):
for b in range(M):
if not a*10**6+b in Q:
ans = max(ans, A[a]+B[b])
for b in range(N):
for b in range(l_b):
if not a*10**6+b in Q:
ans = max(ans, A[a]+B[b])
print(ans)
# √(L+1)の範囲で全探索
N, M, L = map(int, input().split())
l_a = min(int(L**0.5)+1, N)
l_b = min(int(L**0.5)+1, M)
A = list(map(int, input().split()))
A_s = list([A[i], i] for i in range(N))
A.sort(reverse=True)
A_s.sort(reverse=True)
D_A = {A_s[i][1]:i for i in range(N)}
B = list(map(int, input().split()))
B_s = list([B[i], i] for i in range(M))
B.sort(reverse=True)
B_s.sort(reverse=True)
D_B = {B_s[i][1]:i for i in range(M)}
Q = dict()
for i in range(L):
c, d = map(int, input().split())
c -= 1
c = D_A[c]
d -= 1
d = D_B[d]
Q[c*10**6+d] = 1
ans = 0
for a in range(l_a):
for b in range(M):
if not a*10**6+b in Q:
ans = max(ans, A[a]+B[b])
for a in range(N):
for b in range(l_b):
if not a*10**6+b in Q:
ans = max(ans, A[a]+B[b])
print(ans)
|
ConDefects/ConDefects/Code/abc331_e/Python/54388604
|
condefects-python_data_2397
|
import sys, bisect, math
sys.setrecursionlimit(10**8)
sys.set_int_max_str_digits(0)
inf = 1<<60
# inf = float('INF')
from collections import deque, defaultdict, Counter
from itertools import product, combinations, permutations, accumulate
from heapq import heapify, heappop, heappush
from sortedcontainers import SortedList
def I(): return input()
def II(): return int(input())
def IS(): return input().split()
def MII(): return map(int, input().split())
def LI(): return list(input())
def TII(): return tuple(map(int, input().split()))
def LII(): return list(map(int, input().split()))
def LSI(): return list(map(str, input().split()))
N, M, L = MII()
A = LII()
B = LII()
ng = defaultdict(lambda: defaultdict(int))
for _ in range(L):
c, d = MII()
c -= 1
d -= 1
ng[c][d] = 1
A2 = []
for i, a in enumerate(A): # もともとのメニューidを保持した状態でsortする
A2.append((-a, i))
B2 = []
for i, b in enumerate(B):
B2.append((-b, i))
A2.sort()
B2.sort()
que = []
heappush(que, (A2[0][0] + B2[0][0], 0, 0, A2[0][1], B2[0][1]))
done = defaultdict(lambda: defaultdict(int))
# heapq に入れたら done にメモする
done[0][0] = 1
# L回回せば 食べ合わせが悪いもの以外がでる
for i in range(L):
# このループの中ででないのであれば ループ後にでてくる1個目が答えになるはず
value, apos, bpos, aind, bind = heappop(que)
# ng に該当かチェック
if ng[aind][bind] != 1:
exit(print(-value))
if apos + 1 <= N - 1:
if done[apos + 1][bpos] != 1:
heappush(que, (A2[apos + 1][0] + B2[bpos][0], apos + 1, bpos, A2[apos + 1][1], B2[bpos][1]))
if bpos + 1 <= M - 1:
if done[apos][bpos + 1] != 1:
heappush(que, (A2[apos][0] + B2[bpos + 1][0], apos, bpos + 1, A2[apos][1], B2[bpos + 1][1]))
else:
value, _, _, _, _ = heappop(que)
print(-value)
import sys, bisect, math
sys.setrecursionlimit(10**8)
sys.set_int_max_str_digits(0)
inf = 1<<60
# inf = float('INF')
from collections import deque, defaultdict, Counter
from itertools import product, combinations, permutations, accumulate
from heapq import heapify, heappop, heappush
from sortedcontainers import SortedList
def I(): return input()
def II(): return int(input())
def IS(): return input().split()
def MII(): return map(int, input().split())
def LI(): return list(input())
def TII(): return tuple(map(int, input().split()))
def LII(): return list(map(int, input().split()))
def LSI(): return list(map(str, input().split()))
N, M, L = MII()
A = LII()
B = LII()
ng = defaultdict(lambda: defaultdict(int))
for _ in range(L):
c, d = MII()
c -= 1
d -= 1
ng[c][d] = 1
A2 = []
for i, a in enumerate(A): # もともとのメニューidを保持した状態でsortする
A2.append((-a, i))
B2 = []
for i, b in enumerate(B):
B2.append((-b, i))
A2.sort()
B2.sort()
que = []
heappush(que, (A2[0][0] + B2[0][0], 0, 0, A2[0][1], B2[0][1]))
done = defaultdict(lambda: defaultdict(int))
# heapq に入れたら done にメモする
done[0][0] = 1
# L回回せば 食べ合わせが悪いもの以外がでる
for i in range(L):
# このループの中ででないのであれば ループ後にでてくる1個目が答えになるはず
value, apos, bpos, aind, bind = heappop(que)
# ng に該当かチェック
if ng[aind][bind] != 1:
exit(print(-value))
if apos + 1 <= N - 1:
if done[apos + 1][bpos] != 1:
heappush(que, (A2[apos + 1][0] + B2[bpos][0], apos + 1, bpos, A2[apos + 1][1], B2[bpos][1]))
done[apos + 1][bpos] = 1
if bpos + 1 <= M - 1:
if done[apos][bpos + 1] != 1:
heappush(que, (A2[apos][0] + B2[bpos + 1][0], apos, bpos + 1, A2[apos][1], B2[bpos + 1][1]))
done[apos][bpos + 1] = 1
else:
value, _, _, _, _ = heappop(que)
print(-value)
|
ConDefects/ConDefects/Code/abc331_e/Python/52731476
|
condefects-python_data_2398
|
from heapq import heappush, heappop, heapify
from collections import defaultdict, deque,Counter
from math import ceil, floor, sqrt, factorial,gcd,cos,sin,pi
from itertools import permutations, combinations,product
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import Fraction
from random import randint
import sys
from functools import cache,lru_cache #@lru_cache(maxsize=None)
from time import time
#from sortedcontainers import SortedList # type: ignore
#sys.setrecursionlimit(10**6)
vector1 = [[0, -1], [1, 0], [0, 1], [-1, 0]]
vector2 = [[0, 1], [1, 0], [-1, 0], [0, -1],
[1,-1], [-1, 1], [1, 1], [-1, -1]]
alphabet = "abcdefghijklmnopqrstuvwxyz"
def main():
N,M,L = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a = [(val,i+1) for i,val in enumerate(a)]
b = [(val,i+1) for i,val in enumerate(b)]
a.sort(reverse=True)
b.sort(reverse=True)
print(a)
print(b)
s = set()
for _ in range(L):
c,d = map(int,input().split())
s.add((c,d))
ans = 0
for i in range(N):
for j in range(M):
av,ai = a[i]
bv,bi = b[j]
if (ai,bi) in s:
continue
else:
ans = max(ans,av+bv)
if j == 0:
print(ans)
exit()
break
print(ans)
if __name__ == '__main__':
main()
from heapq import heappush, heappop, heapify
from collections import defaultdict, deque,Counter
from math import ceil, floor, sqrt, factorial,gcd,cos,sin,pi
from itertools import permutations, combinations,product
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import Fraction
from random import randint
import sys
from functools import cache,lru_cache #@lru_cache(maxsize=None)
from time import time
#from sortedcontainers import SortedList # type: ignore
#sys.setrecursionlimit(10**6)
vector1 = [[0, -1], [1, 0], [0, 1], [-1, 0]]
vector2 = [[0, 1], [1, 0], [-1, 0], [0, -1],
[1,-1], [-1, 1], [1, 1], [-1, -1]]
alphabet = "abcdefghijklmnopqrstuvwxyz"
def main():
N,M,L = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a = [(val,i+1) for i,val in enumerate(a)]
b = [(val,i+1) for i,val in enumerate(b)]
a.sort(reverse=True)
b.sort(reverse=True)
s = set()
for _ in range(L):
c,d = map(int,input().split())
s.add((c,d))
ans = 0
for i in range(N):
for j in range(M):
av,ai = a[i]
bv,bi = b[j]
if (ai,bi) in s:
continue
else:
ans = max(ans,av+bv)
if j == 0:
print(ans)
exit()
break
print(ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc331_e/Python/54054504
|
condefects-python_data_2399
|
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
from atcoder.lazysegtree import LazySegTree
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n, q = LL()
X = LLMI()
def _op(x1, x2):
return [x1[0] + x2[0], 1]
def _mapping(lz, x):
return [x[0] + x[1] * lz, x[1]]
def _composition(lz1, lz2):
return lz1 + lz2
seg = LazySegTree(
op=_op, e=[0, 0], mapping=_mapping, composition=_composition, id_=0, v=n
)
l = 0
for p in X:
v, u = seg.get(p)
l += 1 - 2 * u
seg.set(p, [v, u ^ 1])
seg.apply(0, n, l)
print([seg.get(i)[0] for i in range(n)])
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
from atcoder.lazysegtree import LazySegTree
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n, q = LL()
X = LLMI()
def _op(x1, x2):
return [x1[0] + x2[0], 1]
def _mapping(lz, x):
return [x[0] + x[1] * lz, x[1]]
def _composition(lz1, lz2):
return lz1 + lz2
seg = LazySegTree(
op=_op, e=[0, 0], mapping=_mapping, composition=_composition, id_=0, v=n
)
l = 0
for p in X:
v, u = seg.get(p)
l += 1 - 2 * u
seg.set(p, [v, u ^ 1])
seg.apply(0, n, l)
print(*[seg.get(i)[0] for i in range(n)])
|
ConDefects/ConDefects/Code/abc347_e/Python/55155569
|
condefects-python_data_2400
|
# INF = 1<<60 # 1152921504606846976 ~ 10^18
# def meguru_bisect(ng, ok):
# while ok - ng > 1:
# mid = (ng + ok) // 2
# if is_ok(mid): # 小さくできる
# ok = mid
# else:
# ng = mid # 大きくしないといけない
# return ok
import sys
def input():
return sys.stdin.readline()[:-1]
# sys.setrecursionlimit(10**6)
N, Q = map(int, input().split())
A = list(map(int, input().split()))
types = []
from collections import defaultdict
d = defaultdict(int)
for a in A:
if d[a]%2==0:
types.append(0)
else:
types.append(1)
d[a] += 1
cumsum = [0]*(Q+1)
l = 0
for i, t in enumerate(types):
if t==0:
l += 1
else:
l -= 1
if i < Q+2:
cumsum[i+1] = cumsum[i] + l
ans = [0]*(N+1)
pre = [-1]*(N+1)
for i, a in enumerate(A):
if pre[a] == -1:
pre[a] = i+1
else:
ans[a] += cumsum[i] - cumsum[pre[a]-1]
pre[a] = -1
for i, x in enumerate(pre):
if x != -1:
ans[i] += cumsum[-1] - cumsum[pre[i]-1]
print(f"{ans[1:]}")
# INF = 1<<60 # 1152921504606846976 ~ 10^18
# def meguru_bisect(ng, ok):
# while ok - ng > 1:
# mid = (ng + ok) // 2
# if is_ok(mid): # 小さくできる
# ok = mid
# else:
# ng = mid # 大きくしないといけない
# return ok
import sys
def input():
return sys.stdin.readline()[:-1]
# sys.setrecursionlimit(10**6)
N, Q = map(int, input().split())
A = list(map(int, input().split()))
types = []
from collections import defaultdict
d = defaultdict(int)
for a in A:
if d[a]%2==0:
types.append(0)
else:
types.append(1)
d[a] += 1
cumsum = [0]*(Q+1)
l = 0
for i, t in enumerate(types):
if t==0:
l += 1
else:
l -= 1
if i < Q+2:
cumsum[i+1] = cumsum[i] + l
ans = [0]*(N+1)
pre = [-1]*(N+1)
for i, a in enumerate(A):
if pre[a] == -1:
pre[a] = i+1
else:
ans[a] += cumsum[i] - cumsum[pre[a]-1]
pre[a] = -1
for i, x in enumerate(pre):
if x != -1:
ans[i] += cumsum[-1] - cumsum[pre[i]-1]
print(*ans[1:])
|
ConDefects/ConDefects/Code/abc347_e/Python/53797654
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.