id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_2101
|
S = list(input())
num = [0]*1000
for s in S:
num[S.count(s)] += 1
for n in num:
if n % 2 != 0:
print('No')
exit()
print('Yes')
S = list(input())
num = [0]*1000
for s in S:
num[S.count(s)] += 1
for n in num:
if 2 * num.index(n) != n:
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc349_b/Python/54751980
|
condefects-python_data_2102
|
S = input()
lst, element, rest, cnt_lst = [], [], [], []
now = ""
for a in S:
lst.append(a)
lst = sorted(lst)
for a in lst:
if now != a:
element.append(a)
now = a
for m in element:
rest.append(lst.count(m))
for n in range(len(S)):
cnt_element = rest.count(n)
if cnt_element == 0 or cnt_element == 2:
continue
else:
print("No")
exit()
print("Yes")
S = input()
lst, element, rest, cnt_lst = [], [], [], []
now = ""
for a in S:
lst.append(a)
lst = sorted(lst)
for a in lst:
if now != a:
element.append(a)
now = a
for m in element:
rest.append(lst.count(m))
for n in range(len(S)+1):
cnt_element = rest.count(n)
if cnt_element == 0 or cnt_element == 2:
continue
else:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc349_b/Python/54918141
|
condefects-python_data_2103
|
from collections import defaultdict
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return False
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
return True
def get_size(self, x):
return -self.table[self.root(x)]
def solve(n, aaa):
uft = UnionFind(n)
i, j = 0, 0
while i < n:
while j < aaa[i] + 1:
uft.unite(i - j, i + j)
j += 1
k = 1
while i - k >= 0 and i + k < n and k + aaa[i - k] + 1 < j:
if k + aaa[i - k] + 1 < j - 1 and aaa[i - k] != aaa[i + k]:
return None
k += 1
i += k
j -= k
banned = defaultdict(set)
for i, a in enumerate(aaa):
if i - a == 0 or i + a == n - 1:
continue
bl = i - a - 1
br = i + a + 1
rl = uft.root(bl)
rr = uft.root(br)
if rl == rr:
return None
banned[rl].add(rr)
banned[rr].add(rl)
ans = [0] * n
color = [-1] * n
for i in range(n):
rt = uft.root(i)
if color[rt] > 0:
ans[i] = color[rt]
continue
ban = {color[b] for b in banned[rt]}
for c in range(1, 10000):
if c not in ban:
break
color[rt] = c
ans[i] = c
return ans
n = int(input())
aaa = list(map(int, input().split()))
ans = solve(n, aaa)
if ans is None:
print('No')
else:
print('Yes')
print(*ans)
from collections import defaultdict
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return False
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
return True
def get_size(self, x):
return -self.table[self.root(x)]
def solve(n, aaa):
uft = UnionFind(n)
i, j = 0, 0
while i < n:
while j < aaa[i] + 1:
uft.unite(i - j, i + j)
j += 1
k = 1
while i - k >= 0 and i + k < n and k + aaa[i - k] + 1 < j:
if k + aaa[i - k] < j - 1 and aaa[i - k] != aaa[i + k]:
return None
k += 1
i += k
j -= k
banned = defaultdict(set)
for i, a in enumerate(aaa):
if i - a == 0 or i + a == n - 1:
continue
bl = i - a - 1
br = i + a + 1
rl = uft.root(bl)
rr = uft.root(br)
if rl == rr:
return None
banned[rl].add(rr)
banned[rr].add(rl)
ans = [0] * n
color = [-1] * n
for i in range(n):
rt = uft.root(i)
if color[rt] > 0:
ans[i] = color[rt]
continue
ban = {color[b] for b in banned[rt]}
for c in range(1, 10000):
if c not in ban:
break
color[rt] = c
ans[i] = c
return ans
n = int(input())
aaa = list(map(int, input().split()))
ans = solve(n, aaa)
if ans is None:
print('No')
else:
print('Yes')
print(*ans)
|
ConDefects/ConDefects/Code/abc349_g/Python/52509388
|
condefects-python_data_2104
|
from math import gcd
l, r = map(int, input().split())
x = r - l
for i in range(x):
for j in range(i + 1):
gcd(l + j, x - i) == 1 or exit(print(x - i))
from math import gcd
l, r = map(int, input().split())
x = r - l
for i in range(x):
for j in range(i + 1):
gcd(l + j, x - i) == 1 and exit(print(x - i))
|
ConDefects/ConDefects/Code/arc137_a/Python/44383228
|
condefects-python_data_2105
|
import math
l,r=map(int,input().split())
k=0
while True:
flag=False
for i in range(k):
r2=r-i
l2=l+k-i
if math.gcd(l2,r2)==1:
flag=True
if flag:
print (r-l-k)
exit()
k+=1
import math
l,r=map(int,input().split())
k=0
while True:
flag=False
for i in range(k+1):
r2=r-i
l2=l+k-i
if math.gcd(l2,r2)==1:
flag=True
if flag:
print (r-l-k)
exit()
k+=1
|
ConDefects/ConDefects/Code/arc137_a/Python/45348542
|
condefects-python_data_2106
|
N = int(input())
A,B=[],[]
for i in range(N):
A.append(input())
for i in range(N):
B.append(input())
for i in range(N):
if A[i] != B[i]:
for j in range(N):
if A[i][j] != B[i][j]:
print(i,j)
N = int(input())
A,B=[],[]
for i in range(N):
A.append(input())
for i in range(N):
B.append(input())
for i in range(N):
if A[i] != B[i]:
for j in range(N):
if A[i][j] != B[i][j]:
print(i+1,j+1)
|
ConDefects/ConDefects/Code/abc351_b/Python/54891565
|
condefects-python_data_2107
|
def find_differing_cell(N, A, B):
for i in range(N):
for j in range(N):
if A[i][j] != B[i][j]:
#print(i+1, j+1)
return (i + 1, j + 1)
N=int(input())
A = [['a' for x in range(N)] for y in range(N)]
B = [['a' for x in range(N)] for y in range(N)]
for i in range(N):
ch = str(input())
for j in range(N):
A[i][j] = ch[j]
for i in range(N):
ch = str(input())
for j in range(N):
B[i][j] = ch[j]
#print(N,A,B)
find_differing_cell(N, A, B)
def find_differing_cell(N, A, B):
for i in range(N):
for j in range(N):
if A[i][j] != B[i][j]:
print(i+1, j+1)
return (i + 1, j + 1)
N=int(input())
A = [['a' for x in range(N)] for y in range(N)]
B = [['a' for x in range(N)] for y in range(N)]
for i in range(N):
ch = str(input())
for j in range(N):
A[i][j] = ch[j]
for i in range(N):
ch = str(input())
for j in range(N):
B[i][j] = ch[j]
#print(N,A,B)
find_differing_cell(N, A, B)
|
ConDefects/ConDefects/Code/abc351_b/Python/54978591
|
condefects-python_data_2108
|
N, M = map(int, input().split())
if M == 0:
for i in range(N, 0, -1):
print(i)
exit()
from collections import defaultdict, deque
AB = [list(map(int, input().split())) for _ in range(M)]
for i in range(M):
AB[i] = sorted(AB[i], reverse=True)
AB.sort(key = lambda x: (x[1], x[0]), reverse=True)
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):
# x が属しているグループの要素数
return -self.parents[self.find(x)]
def same(self, x, y):
# 親が同じかどうか True or False
return self.find(x) == self.find(y)
def roots(self):
# 根の要素を出力
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
# 連結している要素の数
return len(self.roots())
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
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
ans = [0] * N
g = UnionFind(N)
visit = set(range(N))
now = N - 1
leng = M
count = 0
while True:
for i in range(count, leng):
if AB[i][0] >= now + 1 and AB[i][1] >= now + 1:
if now != N - 1 and not g.same(AB[i][0] - 1, AB[i][1] - 1):
result -= 1
g.union(AB[i][0] - 1, AB[i][1] - 1)
visit.discard(AB[i][0] - 1)
visit.discard(AB[i][1] - 1)
count += 1
else:
break
visit.discard(now)
if now == N - 1:
result = g.group_count()
ans[now - 1] = result - len(visit)
now -= 1
if now == 0:
break
for i in range(N):
print(ans[i])
N, M = map(int, input().split())
if M == 0:
for i in range(N - 1, -1, -1):
print(i)
exit()
from collections import defaultdict, deque
AB = [list(map(int, input().split())) for _ in range(M)]
for i in range(M):
AB[i] = sorted(AB[i], reverse=True)
AB.sort(key = lambda x: (x[1], x[0]), reverse=True)
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):
# x が属しているグループの要素数
return -self.parents[self.find(x)]
def same(self, x, y):
# 親が同じかどうか True or False
return self.find(x) == self.find(y)
def roots(self):
# 根の要素を出力
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
# 連結している要素の数
return len(self.roots())
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
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
ans = [0] * N
g = UnionFind(N)
visit = set(range(N))
now = N - 1
leng = M
count = 0
while True:
for i in range(count, leng):
if AB[i][0] >= now + 1 and AB[i][1] >= now + 1:
if now != N - 1 and not g.same(AB[i][0] - 1, AB[i][1] - 1):
result -= 1
g.union(AB[i][0] - 1, AB[i][1] - 1)
visit.discard(AB[i][0] - 1)
visit.discard(AB[i][1] - 1)
count += 1
else:
break
visit.discard(now)
if now == N - 1:
result = g.group_count()
ans[now - 1] = result - len(visit)
now -= 1
if now == 0:
break
for i in range(N):
print(ans[i])
|
ConDefects/ConDefects/Code/abc229_e/Python/44646979
|
condefects-python_data_2109
|
def main():
n, m = map(int,input().split())
h = list(map(int,input().split()))
hand = 0
for i in range(len(h)):
hand = hand + h[i]
if hand > m:
print(i)
break
elif hand == m:
print(i+1)
break
if __name__ == "__main__":
main()
def main():
n, m = map(int,input().split())
h = list(map(int,input().split()))
hand = 0
for i in range(len(h)):
hand = hand + h[i]
if hand > m:
print(i)
break
elif hand == m:
print(i+1)
break
if hand < m:
print(len(h))
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc357_a/Python/55021619
|
condefects-python_data_2110
|
N, M = map(int, input().split())
H = list(map(int, input().split()))
ans = 0
sum = 0
i = 0
while i < N:
sum += H[i]
if sum > M:
print(i)
break
i += 1
N, M = map(int, input().split())
H = list(map(int, input().split()))
ans = 0
sum = 0
i = 0
while i < N:
sum += H[i]
if sum > M:
break
i += 1
print(i)
|
ConDefects/ConDefects/Code/abc357_a/Python/55033452
|
condefects-python_data_2111
|
N,M=map(int,input().split())
H = list(map(int,input().split()))
cnt=0
for i in range(len(H)):
if M-H[i] <= 0:
break
M = M - H[i]
cnt += 1
print(cnt)
N,M=map(int,input().split())
H = list(map(int,input().split()))
cnt=0
for i in range(len(H)):
if M-H[i] < 0:
break
M = M - H[i]
cnt += 1
print(cnt)
|
ConDefects/ConDefects/Code/abc357_a/Python/55135395
|
condefects-python_data_2112
|
N,M = map(int,input().split())
H = list(map(int,input().split()))
s = 0
for i in range(N):
if H[i] > M:
break
else:
M -= (i + 1)
s += 1
print(s)
N,M = map(int,input().split())
H = list(map(int,input().split()))
s = 0
for i in range(N):
if H[i] > M:
break
else:
M -= H[i]
s += 1
print(s)
|
ConDefects/ConDefects/Code/abc357_a/Python/55022235
|
condefects-python_data_2113
|
N, M = map(int, input().split())
H = list(map(int, input().split()))
total = M
for i in range(N):
total -= H[i]
if total < 0:
print(i + 1)
break
else:
print(N)
N, M = map(int, input().split())
H = list(map(int, input().split()))
total = M
for i in range(N):
total -= H[i]
if total < 0:
print(i)
break
else:
print(N)
|
ConDefects/ConDefects/Code/abc357_a/Python/54997913
|
condefects-python_data_2114
|
N,M = map(int, input().split())
H = list(map(int, input().split()))
for i in range(N):
M = M-H[i]
if M == 0:
print(i+1)
break
if M < H[i]:
print(i)
break
if M > 0:
print(N)
N,M = map(int, input().split())
H = list(map(int, input().split()))
for i in range(N):
M = M-H[i]
if M == 0:
print(i+1)
break
if M < 0:
print(i)
break
if M > 0:
print(N)
|
ConDefects/ConDefects/Code/abc357_a/Python/55131574
|
condefects-python_data_2115
|
n = list(map(int, input().split()))
a = list(map(int, input().split()))
c = 0
b = 0
for i in range(n[0]):
c = c + a[i]
b = b + 1
if c >= n[1]:
break
if c == n[1]:
print(b)
elif c < n[1]:
print(1)
else:
print(b - 1)
n = list(map(int, input().split()))
a = list(map(int, input().split()))
c = 0
b = 0
for i in range(n[0]):
c = c + a[i]
b = b + 1
if c >= n[1]:
break
if c == n[1]:
print(b)
elif c < n[1]:
print(n[0])
else:
print(b - 1)
|
ConDefects/ConDefects/Code/abc357_a/Python/54987751
|
condefects-python_data_2116
|
' %s'%[*open(0)][1].find('ABC')
print(f' {[*open(0)][1]}'.find('ABC'))
|
ConDefects/ConDefects/Code/abc322_a/Python/46216926
|
condefects-python_data_2117
|
N,S=[*open(0)];print(S.find('ABC'))
N,S=[*open(0)];print(('a'+S).find('ABC'))
|
ConDefects/ConDefects/Code/abc322_a/Python/46216512
|
condefects-python_data_2118
|
(' '+list(open(0))[1]).find('ABC')
print((' '+[*open(0)][1]).find('ABC'))
|
ConDefects/ConDefects/Code/abc322_a/Python/46216252
|
condefects-python_data_2119
|
N = int(input())
S = input()
for i in range(N-3):
if S[i] == "A" and S[i+1] == "B" and S[i+2] == "C":
print(i+1)
exit()
else:
print(-1)
N = int(input())
S = input()
for i in range(N-2):
if S[i] == "A" and S[i+1] == "B" and S[i+2] == "C":
print(i+1)
exit()
else:
print(-1)
|
ConDefects/ConDefects/Code/abc322_a/Python/54895050
|
condefects-python_data_2120
|
s = input()
ret = -1
for i in range(0, len(s)-2):
if s[i:i + 3] == 'ABC':
ret = i + 1
break
n = input()
s = input()
ret = -1
for i in range(0, len(s)-2):
if s[i:i + 3] == 'ABC':
ret = i + 1
break
print(ret)
|
ConDefects/ConDefects/Code/abc322_a/Python/46196055
|
condefects-python_data_2121
|
n = int(input())
s = input()
if "ABC" in s:
print(s.find("ABC"))
else:
print(-1)
n = int(input())
s = input()
if "ABC" in s:
print(s.find("ABC") + 1)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc322_a/Python/54685843
|
condefects-python_data_2122
|
N, S = open(0)
print(S.find("ABC") if "ABC" in S else -1)
N, S = open(0)
print(S.find("ABC") + 1 if "ABC" in S else -1)
|
ConDefects/ConDefects/Code/abc322_a/Python/46192605
|
condefects-python_data_2123
|
print([*open(0)][1].find('ABC')+1)
print(('x'+[*open(0)][1]).find('ABC'))
|
ConDefects/ConDefects/Code/abc322_a/Python/46216132
|
condefects-python_data_2124
|
input()
idx = input().find('ABC')
print(idx + 1 if idx > 0 else idx)
input()
idx = input().find('ABC')
print(idx + 1 if idx >= 0 else idx)
|
ConDefects/ConDefects/Code/abc322_a/Python/46209873
|
condefects-python_data_2125
|
N = int(input())
S = input()
def check():
for i in range(N-3):
if S[i] + S[i+1] + S[i+2] == "ABC":
return i+1
return -1
print(check())
N = int(input())
S = input()
def check():
for i in range(N-2):
if S[i] + S[i+1] + S[i+2] == "ABC":
return i+1
return -1
print(check())
|
ConDefects/ConDefects/Code/abc322_a/Python/55169673
|
condefects-python_data_2126
|
N = int(input())
S = input()
ans = S.find("ABC")
if ans > 0:
print(ans+1)
else:
print(ans)
N = int(input())
S = input()
ans = S.find("ABC")
if ans >= 0:
print(ans+1)
else:
print(ans)
|
ConDefects/ConDefects/Code/abc322_a/Python/46206505
|
condefects-python_data_2127
|
n,s = input(),'k'+input()
a = s.find('ABC') + 1
print(a)
n,s = input(),'k'+input()
a = s.find('ABC')
print(a)
|
ConDefects/ConDefects/Code/abc322_a/Python/46197070
|
condefects-python_data_2128
|
N = int(input())
S = list(input())
count = 0
check = False
for i in range(len(S)-2):
count += 1
if S[i] == "A" and S[i+1] == "B" and S[i+2] == "C":
check == True
break
if check == True:
print(count)
else:
print(-1)
N = int(input())
S = list(input())
count = 0
check = False
for i in range(len(S)-2):
count += 1
if S[i] == "A" and S[i+1] == "B" and S[i+2] == "C":
check = True
break
if check == True:
print(count)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc322_a/Python/46206584
|
condefects-python_data_2129
|
c = "atcorder"
x, y = map(int, input().split())
print(c[x-1:y])
c = "atcoder"
x, y = map(int, input().split())
print(c[x-1:y])
|
ConDefects/ConDefects/Code/abc264_a/Python/46142360
|
condefects-python_data_2130
|
st, en = map(int, input().split())
print("atcoder"[st+1: en])
st, en = map(int, input().split())
print("atcoder"[st-1: en])
|
ConDefects/ConDefects/Code/abc264_a/Python/46014113
|
condefects-python_data_2131
|
def func():
# 入力を取得
L, R = list(map(int, input().split()))
s = "atcoder"
print(s[L+1:R+1])
if __name__ == '__main__':
func()
def func():
# 入力を取得
L, R = list(map(int, input().split()))
s = "atcoder"
print(s[L-1:R])
if __name__ == '__main__':
func()
|
ConDefects/ConDefects/Code/abc264_a/Python/45803747
|
condefects-python_data_2132
|
S = input()
T = input()
k = ord(S[0]) - ord(T[0])
for i in range(1, len(S)):
if chr(ord(S[i]) - k) != T[i]:
print('No')
exit()
print('Yes')
S = input()
T = input()
k = ord(S[0]) - ord(T[0])
for i in range(1, len(S)):
if ((ord(S[i]) - k) - ord('a')) % 26 != ord(T[i]) - ord('a'):
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc232_b/Python/44895571
|
condefects-python_data_2133
|
S=input()
T=input()
W='abcdefghijklmnopqrstuvwxyz'
ans=True
N=W.find(T[0])-W.find(S[0])
for i in range(len(S)):
n=W.find(T[i])-W.find(S[i])
if n!=N:
if abs(n)!=26+N:
ans=False
if ans==True:
print('Yes')
else:
print('No')
S=input()
T=input()
W='abcdefghijklmnopqrstuvwxyz'
ans=True
N=W.find(T[0])-W.find(S[0])
for i in range(len(S)):
n=W.find(T[i])-W.find(S[i])
if n!=N:
if abs(n-N)!=26:
ans=False
if ans==True:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc232_b/Python/45532739
|
condefects-python_data_2134
|
S = input()
T = input()
k = ord(T[0]) - ord(S[0]) if ord(T[0]) - ord(S[0]) >= 0 else ord(T[0]) - ord(S[0])+26
print(ord(S[0]))
print(ord(T[0]))
for i in range(len(S)-1):
l = ord(T[i+1]) - ord(S[i+1]) if ord(T[i+1]) - ord(S[i+1]) >= 0 else ord(T[i+1]) - ord(S[i+1])+26
if not (k==l):
print('No')
exit()
print('Yes')
S = input()
T = input()
k = ord(T[0]) - ord(S[0]) if ord(T[0]) - ord(S[0]) >= 0 else ord(T[0]) - ord(S[0])+26
for i in range(len(S)-1):
l = ord(T[i+1]) - ord(S[i+1]) if ord(T[i+1]) - ord(S[i+1]) >= 0 else ord(T[i+1]) - ord(S[i+1])+26
if not (k==l):
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc232_b/Python/45719934
|
condefects-python_data_2135
|
S=input()
T=input()
cnt=set()
N=len(S)
for i in range(N):
cnt.add(ord(S[i])-ord(T[i]))
if len(cnt)==1:
print("Yes")
else:
print("No")
S=input()
T=input()
cnt=set()
N=len(S)
for i in range(N):
cnt.add((ord(S[i])-ord(T[i]))%26)
if len(cnt)==1:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc232_b/Python/45920866
|
condefects-python_data_2136
|
from collections import deque
import sys
N, M = map(int, input().split())
relations = [[] for _ in range(N)]
color = ["u"] * N
for _ in range(M):
u, v = map(int, input().split())
relations[u-1].append(v-1)
relations[v-1].append(u-1)
K = int(input())
infos = [None] * K
for i in range(K):
infos[i] = list(map(int, input().split()))
infos = sorted(infos, key=lambda x:x[1], reverse=True)
for p, d in infos:
queue = deque([(p-1, d)])
arrived = set()
while queue:
crt_p, crt_d = queue.popleft()
arrived.add(crt_p)
if crt_d >= 1:
color[crt_p] = "w"
for next_p in relations[crt_p]:
if next_p not in arrived:
queue.append((next_p, crt_d-1))
for p, d in infos:
queue = deque([(p-1, d)])
arrived = set()
tmp_ans = False
while queue:
crt_p, crt_d = queue.popleft()
arrived.add(crt_p)
if crt_d > 0:
for next_p in relations[crt_p]:
if next_p not in arrived:
queue.append((next_p, crt_d-1))
elif crt_d == 0:
if color[crt_d] == "u":
tmp_ans = True
if not tmp_ans:
print("No")
sys.exit()
print("Yes")
ans = []
for c in color:
if c == "u":
ans.append("1")
else:
ans.append("0")
ans = "".join(ans)
print(ans)
from collections import deque
import sys
N, M = map(int, input().split())
relations = [[] for _ in range(N)]
color = ["u"] * N
for _ in range(M):
u, v = map(int, input().split())
relations[u-1].append(v-1)
relations[v-1].append(u-1)
K = int(input())
infos = [None] * K
for i in range(K):
infos[i] = list(map(int, input().split()))
infos = sorted(infos, key=lambda x:x[1], reverse=True)
for p, d in infos:
queue = deque([(p-1, d)])
arrived = set()
while queue:
crt_p, crt_d = queue.popleft()
arrived.add(crt_p)
if crt_d >= 1:
color[crt_p] = "w"
for next_p in relations[crt_p]:
if next_p not in arrived:
queue.append((next_p, crt_d-1))
for p, d in infos:
queue = deque([(p-1, d)])
arrived = set()
tmp_ans = False
while queue:
crt_p, crt_d = queue.popleft()
arrived.add(crt_p)
if crt_d > 0:
for next_p in relations[crt_p]:
if next_p not in arrived:
queue.append((next_p, crt_d-1))
elif crt_d == 0:
if color[crt_p] == "u":
tmp_ans = True
if not tmp_ans:
print("No")
sys.exit()
print("Yes")
ans = []
for c in color:
if c == "u":
ans.append("1")
else:
ans.append("0")
ans = "".join(ans)
print(ans)
|
ConDefects/ConDefects/Code/abc299_e/Python/45347612
|
condefects-python_data_2137
|
standard_input, packages, output_together = 1, 1, 1
dfs, hashing, read_from_file = 1, 1, 0
de = 1
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load]
for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._min_s = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists)
for value in reversed(_list))
def __repr__(self):
"""Return strings representation of sorted list."""
return 'SortedList({0})'.format(list(self))
if 1:
if standard_input:
import io, os, sys
#sys.setrecursionlimit(200001)
input = lambda: sys.stdin.readline().strip()
inf = float('inf')
def I():
return input()
def II():
return int(input())
def MI():
return map(int, input().split())
def LI():
return list(input().split())
def LII():
return list(map(int, input().split()))
def LFI():
return list(map(float, input().split()))
def GMI():
return map(lambda x: int(x) - 1, input().split())
def LGMI():
return list(map(lambda x: int(x) - 1, input().split()))
if packages:
from io import BytesIO, IOBase
import math
import random
import os
import heapq
import bisect
import typing
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import cmp_to_key, lru_cache, reduce
from heapq import merge, heapify, heappop, heappush, heappushpop, nlargest, nsmallest
from itertools import accumulate, combinations, permutations, count, product
from operator import add, iand, ior, itemgetter, mul, xor
from string import ascii_lowercase, ascii_uppercase, ascii_letters
from typing import *
BUFSIZE = 4096
if output_together:
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdout = IOWrapper(sys.stdout)
if dfs:
from types import GeneratorType
sys.setrecursionlimit(2005)
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
if hashing:
RANDOM = random.getrandbits(20)
class Wrapper(int):
def __init__(self, x):
int.__init__(x)
def __hash__(self):
return super(Wrapper, self).__hash__() ^ RANDOM
if read_from_file:
file = open("input.txt", "r").readline().strip()[1:-1]
fin = open(file, 'r')
input = lambda: fin.readline().strip()
output_file = open("output.txt", "w")
def fprint(*args, **kwargs):
print(*args, **kwargs, file=output_file)
if de:
def debug(*args, **kwargs):
print('\033[92m', end='')
print(*args, **kwargs)
print('\033[0m', end='')
M=998244353
def abs(x):
return max(x,-x)
def prefix_function(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j > 0 and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def find_occurrences(t, s):
cur = s + '#' + t
sz1, sz2 = len(t), len(s)
ret = []
lps = prefix_function(cur)
for i in range(sz2 + 1, sz1 + sz2 + 1):
if lps[i] == sz2:
ret.append(i - 2 * sz2)
return ret
mod=998244353
class Factorial:
def __init__(self, N, mod) -> None:
N += 1
self.mod = mod
self.f = [1 for _ in range(N)]
self.g = [1 for _ in range(N)]
for i in range(1, N):
self.f[i] = self.f[i - 1] * i % self.mod
self.g[-1] = pow(self.f[-1], mod - 2, mod)
for i in range(N - 2, -1, -1):
self.g[i] = self.g[i + 1] * (i + 1) % self.mod
def fac(self, n):
return self.f[n]
def fac_inv(self, n):
return self.g[n]
def combi(self, n, m):
if n < m or m < 0 or n < 0: return 0
return self.f[n] * self.g[m] % self.mod * self.g[n - m] % self.mod
def permu(self, n, m):
if n < m or m < 0 or n < 0: return 0
return self.f[n] * self.g[n - m] % self.mod
def catalan(self, n):
return (self.combi(2 * n, n) - self.combi(2 * n, n - 1)) % self.mod
def inv(self, n):
return self.f[n-1] * self.g[n] % self.mod
def abs(x):
return max(x,-x)
def whowin(a,b):
if a==b:
return 0
elif (a,b)==(1,2) or (a,b)==(2,3) or (a,b)==(3,1):
return 2
else:
return 1
mod=998244353
def main():
n,m=MI()
lst1=LII()
lst2=LII()
idx=0
ans=0
for i in range(n):
if idx==m:
return ans
if lst1[i]>=lst2[idx]:
ans+=lst1[i]
idx+=1
if idx<m:
return -1
return ans
#t=II()
t=1
for _ in range(t):
print(main())
standard_input, packages, output_together = 1, 1, 1
dfs, hashing, read_from_file = 1, 1, 0
de = 1
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load]
for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._min_s = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists)
for value in reversed(_list))
def __repr__(self):
"""Return strings representation of sorted list."""
return 'SortedList({0})'.format(list(self))
if 1:
if standard_input:
import io, os, sys
#sys.setrecursionlimit(200001)
input = lambda: sys.stdin.readline().strip()
inf = float('inf')
def I():
return input()
def II():
return int(input())
def MI():
return map(int, input().split())
def LI():
return list(input().split())
def LII():
return list(map(int, input().split()))
def LFI():
return list(map(float, input().split()))
def GMI():
return map(lambda x: int(x) - 1, input().split())
def LGMI():
return list(map(lambda x: int(x) - 1, input().split()))
if packages:
from io import BytesIO, IOBase
import math
import random
import os
import heapq
import bisect
import typing
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import cmp_to_key, lru_cache, reduce
from heapq import merge, heapify, heappop, heappush, heappushpop, nlargest, nsmallest
from itertools import accumulate, combinations, permutations, count, product
from operator import add, iand, ior, itemgetter, mul, xor
from string import ascii_lowercase, ascii_uppercase, ascii_letters
from typing import *
BUFSIZE = 4096
if output_together:
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdout = IOWrapper(sys.stdout)
if dfs:
from types import GeneratorType
sys.setrecursionlimit(2005)
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
if hashing:
RANDOM = random.getrandbits(20)
class Wrapper(int):
def __init__(self, x):
int.__init__(x)
def __hash__(self):
return super(Wrapper, self).__hash__() ^ RANDOM
if read_from_file:
file = open("input.txt", "r").readline().strip()[1:-1]
fin = open(file, 'r')
input = lambda: fin.readline().strip()
output_file = open("output.txt", "w")
def fprint(*args, **kwargs):
print(*args, **kwargs, file=output_file)
if de:
def debug(*args, **kwargs):
print('\033[92m', end='')
print(*args, **kwargs)
print('\033[0m', end='')
M=998244353
def abs(x):
return max(x,-x)
def prefix_function(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j > 0 and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def find_occurrences(t, s):
cur = s + '#' + t
sz1, sz2 = len(t), len(s)
ret = []
lps = prefix_function(cur)
for i in range(sz2 + 1, sz1 + sz2 + 1):
if lps[i] == sz2:
ret.append(i - 2 * sz2)
return ret
mod=998244353
class Factorial:
def __init__(self, N, mod) -> None:
N += 1
self.mod = mod
self.f = [1 for _ in range(N)]
self.g = [1 for _ in range(N)]
for i in range(1, N):
self.f[i] = self.f[i - 1] * i % self.mod
self.g[-1] = pow(self.f[-1], mod - 2, mod)
for i in range(N - 2, -1, -1):
self.g[i] = self.g[i + 1] * (i + 1) % self.mod
def fac(self, n):
return self.f[n]
def fac_inv(self, n):
return self.g[n]
def combi(self, n, m):
if n < m or m < 0 or n < 0: return 0
return self.f[n] * self.g[m] % self.mod * self.g[n - m] % self.mod
def permu(self, n, m):
if n < m or m < 0 or n < 0: return 0
return self.f[n] * self.g[n - m] % self.mod
def catalan(self, n):
return (self.combi(2 * n, n) - self.combi(2 * n, n - 1)) % self.mod
def inv(self, n):
return self.f[n-1] * self.g[n] % self.mod
def abs(x):
return max(x,-x)
def whowin(a,b):
if a==b:
return 0
elif (a,b)==(1,2) or (a,b)==(2,3) or (a,b)==(3,1):
return 2
else:
return 1
mod=998244353
def main():
n,m=MI()
lst1=LII()
lst2=LII()
idx=0
ans=0
lst1.sort()
lst2.sort()
for i in range(n):
if idx==m:
return ans
if lst1[i]>=lst2[idx]:
ans+=lst1[i]
idx+=1
if idx<m:
return -1
return ans
#t=II()
t=1
for _ in range(t):
print(main())
|
ConDefects/ConDefects/Code/abc358_d/Python/54977408
|
condefects-python_data_2138
|
# 入力
num_item, num_friend = input().split()
num_item, num_friend = int(num_item), int(num_friend)
item_data = sorted(list(map(int, input().split())))
friend_data = sorted(list(map(int, input().split())))
cost = 0
buy_flg = True
item_idx = 0
friend_idx=0
if item_data[-1] < friend_data[-1]:
buy_flg=False
while friend_idx < num_friend:
if item_data[item_idx] >= friend_data[friend_idx]:
cost += item_data[item_idx]
friend_idx +=1
item_idx +=1
if item_idx >= num_item:
buy_flg=False
break
if buy_flg:
print(cost)
else:
print(-1)
# 入力
num_item, num_friend = input().split()
num_item, num_friend = int(num_item), int(num_friend)
item_data = sorted(list(map(int, input().split())))
friend_data = sorted(list(map(int, input().split())))
cost = 0
buy_flg = True
item_idx = 0
friend_idx=0
if item_data[-1] < friend_data[-1]:
buy_flg=False
while friend_idx < num_friend:
if item_data[item_idx] >= friend_data[friend_idx]:
cost += item_data[item_idx]
friend_idx +=1
item_idx +=1
if item_idx >= num_item and friend_idx < num_friend:
buy_flg=False
break
if buy_flg:
print(cost)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc358_d/Python/55035534
|
condefects-python_data_2139
|
N = int(input())
while N % 2 == 0:
N //= 2
print(N)
while N % 3 == 0:
N //= 3
print(N)
print("Yes" if N == 1 else "No")
N = int(input())
while N % 2 == 0:
N //= 2
while N % 3 == 0:
N //= 3
print("Yes" if N == 1 else "No")
|
ConDefects/ConDefects/Code/abc324_b/Python/54985902
|
condefects-python_data_2140
|
import sympy
N = int(input())
A = set(sympy.factorint(N).keys())
print("Yes" if A == set([2, 3]) or A == set([2]) or A == set([3]) else "No")
import sympy
N = int(input())
A = set(sympy.factorint(N).keys())
print("Yes" if A == set([2, 3]) or A == set([2]) or A == set([3]) or A == set() else "No")
|
ConDefects/ConDefects/Code/abc324_b/Python/54981446
|
condefects-python_data_2141
|
n = int(input())
while n % 3 == 0:
n //= 3
while n % 2 == 0:
n //= 2
print("Yes" if n == 0 else "No")
n = int(input())
while n % 3 == 0:
n //= 3
while n % 2 == 0:
n //= 2
print("Yes" if n == 1 else "No")
|
ConDefects/ConDefects/Code/abc324_b/Python/54903435
|
condefects-python_data_2142
|
from sys import setrecursionlimit, exit, stdin
from math import ceil, floor, sqrt, pi, factorial, gcd, log
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from bisect import bisect, bisect_left, bisect_right
def iinput(): return int(input())
def imap(): return map(int, input().split())
def ilist(): return list(imap())
def sinput(): return input()
def smap(): return input().split()
def slist(): return list(smap())
MOD = 10 ** 9 + 7
#MOD = 998244353
INF = 10 ** 18
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 unite(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
n,m,q = imap()
edge = [list() for _ in range(m)]
query = [list() for _ in range(q)]
uf = UnionFind(n)
for i in range(m):
a,b,c = imap()
a,b = a-1, b-1
edge[i] = [c,a,b]
for i in range(q):
u,v,w = imap()
u,v = u-1, v-1
query[i] = [w,u,v,i]
edge.sort()
query.sort()
epos = 0
qpos = 0
ans = [False] * (q)
while True:
if epos == m and qpos == q:
break
elif epos == m:
w,u,v,i = query[qpos]
if not uf.same(u,v):
ans[i] = True
uf.unite(u,v)
qpos += 1
elif qpos == q:
break
else:
if edge[epos][0] < query[qpos][0]:
c,a,b = edge[epos]
if not uf.same(a,b):
uf.unite(a,b)
epos += 1
else:
w,u,v,i = query[qpos]
if not uf.same(u,v):
ans[i] = True
uf.unite(u,v)
qpos += 1
for i in range(q):
if ans[i]:
print('Yes')
else:
print('No')
from sys import setrecursionlimit, exit, stdin
from math import ceil, floor, sqrt, pi, factorial, gcd, log
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from bisect import bisect, bisect_left, bisect_right
def iinput(): return int(input())
def imap(): return map(int, input().split())
def ilist(): return list(imap())
def sinput(): return input()
def smap(): return input().split()
def slist(): return list(smap())
MOD = 10 ** 9 + 7
#MOD = 998244353
INF = 10 ** 18
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 unite(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
n,m,q = imap()
edge = [list() for _ in range(m)]
query = [list() for _ in range(q)]
uf = UnionFind(n)
for i in range(m):
a,b,c = imap()
a,b = a-1, b-1
edge[i] = [c,a,b]
for i in range(q):
u,v,w = imap()
u,v = u-1, v-1
query[i] = [w,u,v,i]
edge.sort()
query.sort()
epos = 0
qpos = 0
ans = [False] * (q)
while True:
if epos == m and qpos == q:
break
elif epos == m:
w,u,v,i = query[qpos]
if not uf.same(u,v):
ans[i] = True
qpos += 1
elif qpos == q:
break
else:
if edge[epos][0] < query[qpos][0]:
c,a,b = edge[epos]
if not uf.same(a,b):
uf.unite(a,b)
epos += 1
else:
w,u,v,i = query[qpos]
if not uf.same(u,v):
ans[i] = True
qpos += 1
for i in range(q):
if ans[i]:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc235_e/Python/44788391
|
condefects-python_data_2143
|
import sys, math, bisect, heapq, copy, decimal, random, fractions
from itertools import permutations, combinations, product, accumulate, groupby
from collections import defaultdict, deque, Counter
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 8)
"""
n = int(input())
n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
s = input()
s = list(input())
s = [input() for _ in range(n)]
"""
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())
##########################
n, m, q = map(int, input().split())
E = [list(map(int, input().split())) for _ in range(m)]
Q = [list(map(int, input().split())) for _ in range(q)]
for i in range(m):
E[i][0] -= 1
E[i][1] -= 1
for i in range(q):
Q[i][0] -= 1
Q[i][1] -= 1
Q[i].append(i) #index(3)
uf = UnionFind(n)
E.sort(key=lambda x: x[2])
Q.sort(key=lambda x: x[2])
que = deque(Q)
res = [""] * q
for v, w, c in E:
while len(que) > 0 and que[0][2] <= c:
V, W, C, I = que.popleft()
if uf.same(V, W):
res[I] = "No"
else:
res[I] = "Yes"
uf.union(v, w)
while len(que) > 0:
V, W, C, I = que.popleft()
if uf.same(V, W):
res[I] = "No"
else:
res[I] = "Yes"
print(res)
exit()
for i in res: print(i)
import sys, math, bisect, heapq, copy, decimal, random, fractions
from itertools import permutations, combinations, product, accumulate, groupby
from collections import defaultdict, deque, Counter
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 8)
"""
n = int(input())
n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
s = input()
s = list(input())
s = [input() for _ in range(n)]
"""
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())
##########################
n, m, q = map(int, input().split())
E = [list(map(int, input().split())) for _ in range(m)]
Q = [list(map(int, input().split())) for _ in range(q)]
for i in range(m):
E[i][0] -= 1
E[i][1] -= 1
for i in range(q):
Q[i][0] -= 1
Q[i][1] -= 1
Q[i].append(i) #index(3)
uf = UnionFind(n)
E.sort(key=lambda x: x[2])
Q.sort(key=lambda x: x[2])
que = deque(Q)
res = [""] * q
for v, w, c in E:
while len(que) > 0 and que[0][2] <= c:
V, W, C, I = que.popleft()
if uf.same(V, W):
res[I] = "No"
else:
res[I] = "Yes"
uf.union(v, w)
while len(que) > 0:
V, W, C, I = que.popleft()
if uf.same(V, W):
res[I] = "No"
else:
res[I] = "Yes"
for i in res: print(i)
|
ConDefects/ConDefects/Code/abc235_e/Python/45321024
|
condefects-python_data_2144
|
# import系 ---
from heapq import heappush, heappop
from math import factorial
# 入力用 ---
INT = lambda: int(input())
MI = lambda: map(int, input().split())
MI_DEC = lambda: map(lambda x: int(x) - 1, input().split())
LI = lambda: list(map(int, input().split()))
LI_DEC = lambda: list(map(lambda x: int(x) - 1, input().split()))
LS = lambda: list(input())
LSS = lambda: input().split()
INF = 1 << 60
MOD = 998244353
# コード ---
N = INT()
X = sorted(LI())
print(sum(X[N:4*N]) / 3*N)
# import系 ---
from heapq import heappush, heappop
from math import factorial
# 入力用 ---
INT = lambda: int(input())
MI = lambda: map(int, input().split())
MI_DEC = lambda: map(lambda x: int(x) - 1, input().split())
LI = lambda: list(map(int, input().split()))
LI_DEC = lambda: list(map(lambda x: int(x) - 1, input().split()))
LS = lambda: list(input())
LSS = lambda: input().split()
INF = 1 << 60
MOD = 998244353
# コード ---
N = INT()
X = sorted(LI())
print(sum(X[N:4*N]) / (3*N))
|
ConDefects/ConDefects/Code/abc291_b/Python/45669598
|
condefects-python_data_2145
|
n, l, r = map(int, input().split())
start_lis = [i for i in range(1, l)]
middle_lis = list(reversed([i for i in range(l, r+1)]))
final_lis = [i for i in range(r+1, n + 1)]
# 各リストをフラット化して1つのリストに結合
combined_lis = start_lis + middle_lis + final_lis
print(tuple(combined_lis))
n, l, r = map(int, input().split())
start_lis = [i for i in range(1, l)]
middle_lis = list(reversed([i for i in range(l, r+1)]))
final_lis = [i for i in range(r+1, n + 1)]
# 各リストをフラット化して1つのリストに結合
combined_lis = start_lis + middle_lis + final_lis
print(*combined_lis)
|
ConDefects/ConDefects/Code/abc356_a/Python/55030560
|
condefects-python_data_2146
|
N, L, R = list(map(int, input().split()))
A = list(range(1, N+1))
L-=1
A[L:R] = A[L:R][::-1]
print(A)
N, L, R = list(map(int, input().split()))
A = list(range(1, N+1))
L-=1
A[L:R] = A[L:R][::-1]
print(" ".join(map(str, A)))
|
ConDefects/ConDefects/Code/abc356_a/Python/55140373
|
condefects-python_data_2147
|
N,L,R=map(int,input().split())
num=[]
for x in range(1,N+1):
if x<L:
num.append(x)
elif x>=L:
for y in range(R,L-1,-1):
num.append(y)
break
for z in range(R+1,N+1):
num.append(z)
print(num)
N,L,R=map(int,input().split())
num=[]
for x in range(1,N+1):
if x<L:
num.append(x)
elif x>=L:
for y in range(R,L-1,-1):
num.append(y)
break
for z in range(R+1,N+1):
num.append(z)
print(*num)
|
ConDefects/ConDefects/Code/abc356_a/Python/54990500
|
condefects-python_data_2148
|
N,L,R = map(int,input().split())
L-=1
A=list(range(1,N+1))
A[L:R] = reversed(A[L:R])
result = ' '.join(map(str, A))
print(f"A' = ({result})")
N,L,R = map(int,input().split())
L-=1
A=list(range(1,N+1))
A[L:R] = reversed(A[L:R])
result = ' '.join(map(str, A))
print(result)
|
ConDefects/ConDefects/Code/abc356_a/Python/54989904
|
condefects-python_data_2149
|
n,l,r=map(int,input().split())
a=[]
for k in range(1,l):
a.append(k+1)
for R in range(r,l-1,-1):
a.append(R)
for x in range(r+1,n+1):
a.append(x)
print(*a)
n,l,r=map(int,input().split())
a=[]
for k in range(1,l):
a.append(k)
for R in range(r,l-1,-1):
a.append(R)
for x in range(r+1,n+1):
a.append(x)
print(*a)
|
ConDefects/ConDefects/Code/abc356_a/Python/54976789
|
condefects-python_data_2150
|
N, L, R = map(int, input().split())
A = [0] + [i for i in range(1, N+1)]
Larr = A[:L]
center = reversed(A[L:R+1])
Rarr = A[R+1:]
ans = Larr + list(center) + Rarr
ans = ans[1:]
print(ans)
N, L, R = map(int, input().split())
A = [0] + [i for i in range(1, N+1)]
Larr = A[:L]
center = reversed(A[L:R+1])
Rarr = A[R+1:]
ans = Larr + list(center) + Rarr
ans = ans[1:]
print(*ans)
|
ConDefects/ConDefects/Code/abc356_a/Python/55107232
|
condefects-python_data_2151
|
n, l , r = map(int, input().split())
result = []
for i in range(1, l):
result.append(i)
for i in range(r, l - 1, -1):
result.append(i)
for i in range(r + 1, n + 1):
result.append(i)
print(result)
n, l , r = map(int, input().split())
result = []
for i in range(1, l):
result.append(i)
for i in range(r, l - 1, -1):
result.append(i)
for i in range(r + 1, n + 1):
result.append(i)
print(*result)
|
ConDefects/ConDefects/Code/abc356_a/Python/55041853
|
condefects-python_data_2152
|
import sys
from collections import defaultdict
ipt = sys.stdin.readline
MOD = 998244353
def iin():
return int(ipt())
def lmin():
return list(map(int,ipt().split()))
def floor_sum_unsigned(n, m, a, b):
mod = MOD # 必要なら
ans = 0
while True:
# 領域①
if a >= m:
ans += n * (n - 1) * (a // m) // 2
a %= m
# 領域②
if b >= m:
ans += n * (b // m)
b %= m
if ans >= mod: ans %= mod # 必要なら
y_max = a * n + b
if y_max < m: break
# 領域③
n, b, m, a, = y_max // m, y_max % m, a, m
return ans
N = iin()
A = lmin()
A.sort()
b = N*A[0]
ans = A[0]+1
#print(b,ans)
for i in range(1,N):
n = A[i]-A[i-1]
a = N-i
m = N
ans += floor_sum_unsigned(n+1,m,a,b)-floor_sum_unsigned(1,m,a,b)+n
ans %= MOD
#print(ans)
b += n*a
#print(b,ans)
print(ans)
#print(floor_sum_unsigned(3,3,2,3)-floor_sum_unsigned(1,3,2,3))
import sys
from collections import defaultdict
ipt = sys.stdin.readline
MOD = 998244353
def iin():
return int(ipt())
def lmin():
return list(map(int,ipt().split()))
def floor_sum_unsigned(n, m, a, b):
mod = MOD # 必要なら
ans = 0
while True:
# 領域①
if a >= m:
ans += n * (n - 1) * (a // m) // 2
a %= m
# 領域②
if b >= m:
ans += n * (b // m)
b %= m
if ans >= mod: ans %= mod # 必要なら
y_max = a * n + b
if y_max < m: break
# 領域③
n, b, m, a, = y_max // m, y_max % m, a, m
return ans
N = iin()
A = lmin()
A.sort()
b = N*A[0]
ans = A[0]+1
#print(b,ans)
for i in range(1,N):
n = A[i]-A[i-1]
a = N-i
m = N
ans += floor_sum_unsigned(n+1,m,a,b)-floor_sum_unsigned(1,m,a,b)+n
ans %= MOD
#print(ans)
b += n*a
#print(b,ans)
print(ans%MOD)
#print(floor_sum_unsigned(3,3,2,3)-floor_sum_unsigned(1,3,2,3))
|
ConDefects/ConDefects/Code/abc313_g/Python/46134579
|
condefects-python_data_2153
|
print(int(input())%100)
print(input()[1:])
|
ConDefects/ConDefects/Code/abc254_a/Python/45547154
|
condefects-python_data_2154
|
print(int(input()) % 100)
print('%02d' % (int(input()) % 100))
|
ConDefects/ConDefects/Code/abc254_a/Python/45462198
|
condefects-python_data_2155
|
# import sys
# sys.setrecursionlimit(10**6)
import re
import copy
import bisect
import math
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().split()))
def gs():
return list(input().split())
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def rmwh(a):
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
def cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = copy.deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
n, m = gl()
g = [set() for i in range(n+1)]
for i in range(m):
a, b = gl()
a -= 1
b -= 1
if a != -1:
g[a].add(b)
g[b].add(a)
else:
g[n].add(b)
g[b].add(n)
# print(g)
dis0 = [inf for i in range(n+1)]
q = deque()
q.append((0, 0))
vi = set()
vi.add(0)
while len(q) != 0:
st, dis = q.popleft()
dis0[st] = dis
for to in g[st]:
if not to in vi:
q.append((to, dis + 1))
vi.add(to)
dis1 = [inf for i in range(n+1)]
q = deque()
q.append((n-1, 0))
vi = set()
vi.add(n-1)
while len(q) != 0:
st, dis = q.popleft()
dis1[st] = dis
for to in g[st]:
if not to in vi:
q.append((to, dis + 1))
vi.add(to)
ans = []
for i in range(n):
res = min(dis0[n-1], dis0[n] + dis1[i])
if res == inf:
ans.append(-1)
else:
ans.append(res)
print(*ans)
# import sys
# sys.setrecursionlimit(10**6)
import re
import copy
import bisect
import math
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().split()))
def gs():
return list(input().split())
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def rmwh(a):
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
def cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = copy.deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
n, m = gl()
g = [set() for i in range(n+1)]
for i in range(m):
a, b = gl()
a -= 1
b -= 1
if a != -1:
g[a].add(b)
g[b].add(a)
else:
g[n].add(b)
g[b].add(n)
# print(g)
dis0 = [inf for i in range(n+1)]
q = deque()
q.append((0, 0))
vi = set()
vi.add(0)
while len(q) != 0:
st, dis = q.popleft()
dis0[st] = dis
for to in g[st]:
if not to in vi:
q.append((to, dis + 1))
vi.add(to)
dis1 = [inf for i in range(n+1)]
q = deque()
q.append((n-1, 0))
vi = set()
vi.add(n-1)
while len(q) != 0:
st, dis = q.popleft()
dis1[st] = dis
for to in g[st]:
if not to in vi:
q.append((to, dis + 1))
vi.add(to)
ans = []
for i in range(n):
res = min(dis0[n-1], dis0[n] + dis1[i], dis0[i] + dis1[n])
if res == inf:
ans.append(-1)
else:
ans.append(res)
print(*ans)
|
ConDefects/ConDefects/Code/abc257_f/Python/45055612
|
condefects-python_data_2156
|
import collections
N, M = map(int, input().split())
links = [[] for _ in range(N+1)]
for _ in range(M):
u, v = map(int, input().split())
links[u].append(v)
links[v].append(u)
inf = float("inf")
def bfs(s):
visited = [inf] * (N+1)
visited[s] = 0
que = collections.deque([s])
while que:
x = que.popleft()
for nx in links[x]:
if visited[nx] != inf:
continue
visited[nx] = visited[x] + 1
que.append(nx)
return visited
A = bfs(1)
B = bfs(N)
ans = []
for i in range(1, N+1):
a = min(A[0] + B[i], A[N])
if a == inf:
a = -1
ans.append(a)
print(*ans)
import collections
N, M = map(int, input().split())
links = [[] for _ in range(N+1)]
for _ in range(M):
u, v = map(int, input().split())
links[u].append(v)
links[v].append(u)
inf = float("inf")
def bfs(s):
visited = [inf] * (N+1)
visited[s] = 0
que = collections.deque([s])
while que:
x = que.popleft()
for nx in links[x]:
if visited[nx] != inf:
continue
visited[nx] = visited[x] + 1
que.append(nx)
return visited
A = bfs(1)
B = bfs(N)
ans = []
for i in range(1, N+1):
a = min(A[0] + B[i], A[N], A[i] + B[0])
if a == inf:
a = -1
ans.append(a)
print(*ans)
|
ConDefects/ConDefects/Code/abc257_f/Python/45331235
|
condefects-python_data_2157
|
n,m = map(int, input().split())
from collections import deque
tele = []
g = [[] for _ in range(n)]
for _ in range(m):
u,v = map(int, input().split())
u-=1
v-=1
if u == -1:
tele.append(v)
else:
g[u].append(v)
g[v].append(u)
inf = 10**18
#０からn-1への最短距離
d = deque()
d.append(0)
dist1 = [inf]*n
dist1[0] = 0
while d:
v = d.popleft()
for x in g[v]:
if dist1[x] == inf:
dist1[x] = dist1[v]+1
d.append(x)
M = dist1[-1]
m1 = inf
for x in tele:
m1 = min(m1, dist1[x])
#逆方向の最短距離
d = deque()
d.append(n-1)
dist2 = [inf]*n
dist2[n-1] = 0
while d:
v = d.popleft()
for x in g[v]:
if dist2[x] == inf:
dist2[x] = dist2[v]+1
d.append(x)
m2 = inf
for x in tele:
m2 = min(m2, dist2[x])
ans = []
for i in range(n):
tmp = min(M, dist1[i]+1+m2, m1+1+dist2[i])
if tmp >= inf:
tmp = -1
ans.append(tmp)
print(*ans)
n,m = map(int, input().split())
from collections import deque
tele = []
g = [[] for _ in range(n)]
for _ in range(m):
u,v = map(int, input().split())
u-=1
v-=1
if u == -1:
tele.append(v)
else:
g[u].append(v)
g[v].append(u)
inf = 10**18
#０からn-1への最短距離
d = deque()
d.append(0)
dist1 = [inf]*n
dist1[0] = 0
while d:
v = d.popleft()
for x in g[v]:
if dist1[x] == inf:
dist1[x] = dist1[v]+1
d.append(x)
M = dist1[-1]
m1 = inf
for x in tele:
m1 = min(m1, dist1[x])
#逆方向の最短距離
d = deque()
d.append(n-1)
dist2 = [inf]*n
dist2[n-1] = 0
while d:
v = d.popleft()
for x in g[v]:
if dist2[x] == inf:
dist2[x] = dist2[v]+1
d.append(x)
m2 = inf
for x in tele:
m2 = min(m2, dist2[x])
ans = []
for i in range(n):
tmp = min(M, dist1[i]+1+m2, m1+1+dist2[i], m1+2+m2)
if tmp >= inf:
tmp = -1
ans.append(tmp)
print(*ans)
|
ConDefects/ConDefects/Code/abc257_f/Python/45698858
|
condefects-python_data_2158
|
# 0を超頂点として持つ
# 考えられる経路としては、
# 0を経由しない状態での経路、0経由する経路の2つ
# 0を経由しない場合は、1を始点としてBFSすれば良い
# 0を経由する場合を考える
# any -> 0へ行く場合をコスト1として、0->anyをコスト0と考える
# 0 -> iを考える。
# iが最短経路上に行くときは、1 -> 0 -> iのときのコストと1 -> iのときのコストを比べる
# このときにcost(1 -> i) > cost(1 -> 0 -> i)だったらcost(1->0->i->N)にすればいい
# そうでなければcost(1 -> i)を採用する
# 1 -> Nへいけない場合
# この場合は、頂点0を経由しないと無理
# 1->0->i->Nよりi->Nまでの最短経路が必要
# 1からの最短距離をNからの最短距離が必要
# 1->i->0->Nもあった(指摘を受けた)
# 1->N, 1->0->i->N, 1->i->0->N
# 1->i->N
from collections import deque
def BFS(start):
deq = deque([(start, 0)])
dist = [INF] * (N+1)
while deq:
node, cost = deq.popleft()
if dist[node] != INF:
continue
dist[node] = cost
for nx in town[node]:
deq.append((nx, cost + 1))
return dist
N, M = map(int, input().split())
town = [[] for i in range(N+1)]
INF = 1 << 60
for i in range(M):
u, v = map(int, input().split())
town[v].append(u)
if u != 0:
town[u].append(v)
dist1 = BFS(1)
distN = BFS(N)
ans = []
# to := 頂点0の向かう先
for to in range(1, N+1):
tmp = min(dist1[N], dist1[0] + distN[to], dist1[to] + distN[0], dist1[to] + distN[to])
ans.append(tmp if tmp != INF else -1)
print(*ans)
# 0を超頂点として持つ
# 考えられる経路としては、
# 0を経由しない状態での経路、0経由する経路の2つ
# 0を経由しない場合は、1を始点としてBFSすれば良い
# 0を経由する場合を考える
# any -> 0へ行く場合をコスト1として、0->anyをコスト0と考える
# 0 -> iを考える。
# iが最短経路上に行くときは、1 -> 0 -> iのときのコストと1 -> iのときのコストを比べる
# このときにcost(1 -> i) > cost(1 -> 0 -> i)だったらcost(1->0->i->N)にすればいい
# そうでなければcost(1 -> i)を採用する
# 1 -> Nへいけない場合
# この場合は、頂点0を経由しないと無理
# 1->0->i->Nよりi->Nまでの最短経路が必要
# 1からの最短距離をNからの最短距離が必要
# 1->i->0->Nもあった(指摘を受けた)
# 1->N, 1->0->i->N, 1->i->0->N
# 1->i->N
from collections import deque
def BFS(start):
deq = deque([(start, 0)])
dist = [INF] * (N+1)
while deq:
node, cost = deq.popleft()
if dist[node] != INF:
continue
dist[node] = cost
for nx in town[node]:
deq.append((nx, cost + 1))
return dist
N, M = map(int, input().split())
town = [[] for i in range(N+1)]
INF = 1 << 60
for i in range(M):
u, v = map(int, input().split())
town[v].append(u)
if u != 0:
town[u].append(v)
dist1 = BFS(1)
distN = BFS(N)
ans = []
# to := 頂点0の向かう先
for to in range(1, N+1):
tmp = min(dist1[N], dist1[0] + distN[to], dist1[to] + distN[0], dist1[0] + distN[0])
ans.append(tmp if tmp != INF else -1)
print(*ans)
|
ConDefects/ConDefects/Code/abc257_f/Python/45897088
|
condefects-python_data_2159
|
from collections import deque
import sys
INF = 10**9
def main():
input = sys.stdin.readline
N, M = map(int, input().split())
G = [[] for _ in range(N + 1)]
T = []
for _ in range(M):
u, v = map(int, input().split())
u = u - 1 if u > 0 else N
v = v - 1
G[u].append(v)
G[v].append(u)
if u == N:
T.append(v)
D1 = bfs(G, 0)
D2 = bfs(G, N - 1)
minT = min(D2[t] for t in T) if T else INF
A = []
for i in range(N):
ans = INF
ans = min(ans, D1[N - 1])
ans = min(ans, D1[N] + D2[i])
ans = min(ans, D1[i] + 2 + minT)
ans = min(ans, D1[N] + 1 + minT)
A.append(ans if ans < INF else -1)
print(*A)
def bfs(G, start=0):
D = [INF] * len(G)
D[start] = 0
q = deque([start])
while q:
v = q.popleft()
nd = D[v] + 1
for nv in G[v]:
if D[nv] < INF: continue
D[nv] = nd
q.append(nv)
return D
if __name__ == '__main__':
main()
from collections import deque
import sys
INF = 10**9
def main():
input = sys.stdin.readline
N, M = map(int, input().split())
G = [[] for _ in range(N + 1)]
T = []
for _ in range(M):
u, v = map(int, input().split())
u = u - 1 if u > 0 else N
v = v - 1
G[u].append(v)
G[v].append(u)
if u == N:
T.append(v)
D1 = bfs(G, 0)
D2 = bfs(G, N - 1)
minT = min(D2[t] for t in T) if T else INF
A = []
for i in range(N):
ans = INF
ans = min(ans, D1[N - 1])
ans = min(ans, D1[N] + D2[i])
ans = min(ans, D1[i] + 1 + minT)
ans = min(ans, D1[N] + 1 + minT)
A.append(ans if ans < INF else -1)
print(*A)
def bfs(G, start=0):
D = [INF] * len(G)
D[start] = 0
q = deque([start])
while q:
v = q.popleft()
nd = D[v] + 1
for nv in G[v]:
if D[nv] < INF: continue
D[nv] = nd
q.append(nv)
return D
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc257_f/Python/45053747
|
condefects-python_data_2160
|
a,b,c,d=map(int,input().split())
print((a+b)*(c-d))
print('takahashi')# coding: utf-8
# Your code here!
a,b,c,d=map(int,input().split())
print((a+b)*(c-d))
print('Takahashi')# coding: utf-8
# Your code here!
|
ConDefects/ConDefects/Code/abc269_a/Python/45960652
|
condefects-python_data_2161
|
a,b,c,d = input().split()
a = int(a)
b = int(b)
c = int(c)
d = int(d)
print((a+b)*(c-d))
print('takahashi')
a,b,c,d = input().split()
a = int(a)
b = int(b)
c = int(c)
d = int(d)
print((a+b)*(c-d))
print('Takahashi')
|
ConDefects/ConDefects/Code/abc269_a/Python/45960382
|
condefects-python_data_2162
|
a, b, c, d = map(int, input().split())
print(((a + b) * (a - d)))
print("Takahashi")
a, b, c, d = map(int, input().split())
print(((a + b) * (c - d)))
print("Takahashi")
|
ConDefects/ConDefects/Code/abc269_a/Python/45960449
|
condefects-python_data_2163
|
import bisect, collections, copy, heapq, itertools, math, string
import random
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
from collections import deque
from collections import Counter
from collections import defaultdict
import bisect
from functools import reduce
def main():
N,M = MI()
imos_grid = [[0 for _ in range(max(N + M + 3, N + 3))] for _ in range(max(N + 2 * M + 3, 3 * N + 3))]
look_cnt_dic = defaultdict(int)
def imos_dist(x,y):
imos_grid[y][x] += 1
imos_grid[y + 2][x - 1] -= 1
imos_grid[y + 2 * M + 2][x - 1] += 1
imos_grid[y + 2 * M + 2][x] -= 1
imos_grid[y + 2][x + M] += 1
imos_grid[y][x + M] -= 1
for i in range(N):
T = S()
for j,t in enumerate(T):
if t == 'O':
imos_dist(i + 1, j + 1)
# for grid in imos_grid:
# print(grid)
for i in range(3 * N + 3):
for j in range(N + 3):
if i - 2 >= 0 and j + 1 <= N + M + 2:
imos_grid[i][j] += imos_grid[i - 2][j + 1]
#print('a')
for j in range(N + 3):
for i in range(1, 3 * N + 3):
imos_grid[i][j] += imos_grid[i - 1][j]
for i in range(3 * N + 3):
for j in range(1, N + 3):
imos_grid[i][j] += imos_grid[i][j - 1]
# for grid in imos_grid:
# print(grid)
Q = I()
for i in range(Q):
x, y = MI()
print(imos_grid[y][x])
if __name__ == "__main__":
main()
import bisect, collections, copy, heapq, itertools, math, string
import random
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
from collections import deque
from collections import Counter
from collections import defaultdict
import bisect
from functools import reduce
def main():
N,M = MI()
imos_grid = [[0 for _ in range(max(N + M + 3, N + 3))] for _ in range(max(N + 2 * M + 3, 3 * N + 3))]
look_cnt_dic = defaultdict(int)
def imos_dist(x,y):
imos_grid[y][x] += 1
imos_grid[y + 2][x - 1] -= 1
imos_grid[y + 2 * M + 2][x - 1] += 1
imos_grid[y + 2 * M + 2][x] -= 1
imos_grid[y + 2][x + M] += 1
imos_grid[y][x + M] -= 1
for i in range(N):
T = S()
for j,t in enumerate(T):
if t == 'O':
imos_dist(i + 1, j + 1)
# for grid in imos_grid:
# print(grid)
for i in range(3 * N + 3):
for j in range(2 * N + 3):
if i - 2 >= 0 and j + 1 <= N + M + 2:
imos_grid[i][j] += imos_grid[i - 2][j + 1]
#print('a')
for j in range(N + 3):
for i in range(1, 3 * N + 3):
imos_grid[i][j] += imos_grid[i - 1][j]
for i in range(3 * N + 3):
for j in range(1, N + 3):
imos_grid[i][j] += imos_grid[i][j - 1]
# for grid in imos_grid:
# print(grid)
Q = I()
for i in range(Q):
x, y = MI()
print(imos_grid[y][x])
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc260_g/Python/33361937
|
condefects-python_data_2164
|
def main():
N = int(input())
*A, = map(int, input().split())
*B, = map(int, input().split())
X = sorted(A)
Y = sorted(B)
if X != Y:
print("No")
return
if len(set(A)) == len(A):
print("Yes")
return
ct = 0
for b in B:
x = A.index(b)
ct += x
A.pop(x)
if ct%2 == 0:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
def main():
N = int(input())
*A, = map(int, input().split())
*B, = map(int, input().split())
X = sorted(A)
Y = sorted(B)
if X != Y:
print("No")
return
if len(set(A)) != len(A):
print("Yes")
return
ct = 0
for b in B:
x = A.index(b)
ct += x
A.pop(x)
if ct%2 == 0:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/arc136_b/Python/35227817
|
condefects-python_data_2165
|
def update(index, val):
# val 是增量, 如果是修改值记得计算增量
# val = val - query_lr(index,index)
while index <= n:
tree[index] += val
index += index & (-index)
def query(r):
res = 0
while r > 0:
res += tree[r]
r -= r & (-r)
return res
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = Counter(a)
if c != Counter(b):
print('No')
exit()
if any(i > 1 for i in c.values()):
print('Yes')
exit()
tree = [0]*5001
res = 0
for i in range(n):
res += i - query(a[i])
update(a[i],1)
tree = [0]*5001
for i in range(n):
res += i - query(b[i])
update(b[i],1)
if res%2 == 0:
print('Yes')
else:
print('No')
def update(index, val):
# val 是增量, 如果是修改值记得计算增量
# val = val - query_lr(index,index)
while index <= 5000:
tree[index] += val
index += index & (-index)
def query(r):
res = 0
while r > 0:
res += tree[r]
r -= r & (-r)
return res
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = Counter(a)
if c != Counter(b):
print('No')
exit()
if any(i > 1 for i in c.values()):
print('Yes')
exit()
tree = [0]*5001
res = 0
for i in range(n):
res += i - query(a[i])
update(a[i],1)
tree = [0]*5001
for i in range(n):
res += i - query(b[i])
update(b[i],1)
if res%2 == 0:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/arc136_b/Python/36890038
|
condefects-python_data_2166
|
INF = 1 << 64
mod1 = 10**9 + 7
mod2 = 998244353
dir = [(1, 0), (0, 1), (-1, 0), (0, -1)]
import sys
from collections import defaultdict, deque
#from functools import lru_cache
#@lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def ni(): return int(input())
def na(): return map(int, input().split())
def nl(): return list(map(int, input().split()))
def ns(): return input().strip()
def nsl(): return list(input().strip())
d = defaultdict(list)
N = ni()
A = nl()
B = nl()
if sorted(A) != sorted(B):
print("No")
exit()
for i, a in enumerate(A):
d[a].append(i)
B_rev = [None] * N
for i, b in enumerate(B):
B[i] = d[b].pop()
B_rev[B[i]] = i
#print(B)
#print(B_rev)
for i in range(N-2):
ini = B_rev[i]
while i != ini:
dif = ini - i
if dif >= 2:
a, b, c = B[ini], B[ini-1], B[ini-2]
B_rev[a], B_rev[b], B_rev[c] = ini-2, ini, ini-1
B[ini], B[ini-1], B[ini-2] = B[ini-1], B[ini-2], B[ini]
ini -= 2
elif dif == 1:
a, b, c = B[ini-1], B[ini], B[ini+1]
B_rev[a], B_rev[b], B_rev[c] = ini+1, ini-1, ini
B[ini-1], B[ini], B[ini+1] = B[ini], B[ini+1], B[ini-1]
ini -= 1
if B != list(range(N)):
print("No")
else:
print("Yes")
INF = 1 << 64
mod1 = 10**9 + 7
mod2 = 998244353
dir = [(1, 0), (0, 1), (-1, 0), (0, -1)]
import sys
from collections import defaultdict, deque
#from functools import lru_cache
#@lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def ni(): return int(input())
def na(): return map(int, input().split())
def nl(): return list(map(int, input().split()))
def ns(): return input().strip()
def nsl(): return list(input().strip())
d = defaultdict(list)
N = ni()
A = nl()
B = nl()
if sorted(A) != sorted(B):
print("No")
exit()
for i, a in enumerate(A):
d[a].append(i)
B_rev = [None] * N
for i, b in enumerate(B):
B[i] = d[b].pop()
B_rev[B[i]] = i
#print(B)
#print(B_rev)
for i in range(N-2):
ini = B_rev[i]
while i != ini:
dif = ini - i
if dif >= 2:
a, b, c = B[ini], B[ini-1], B[ini-2]
B_rev[a], B_rev[b], B_rev[c] = ini-2, ini, ini-1
B[ini], B[ini-1], B[ini-2] = B[ini-1], B[ini-2], B[ini]
ini -= 2
elif dif == 1:
a, b, c = B[ini-1], B[ini], B[ini+1]
B_rev[a], B_rev[b], B_rev[c] = ini+1, ini-1, ini
B[ini-1], B[ini], B[ini+1] = B[ini], B[ini+1], B[ini-1]
ini -= 1
if B != list(range(N)) and A[B[-1]] != A[B[-2]]:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/arc136_b/Python/37078962
|
condefects-python_data_2167
|
# import sys
# sys.setrecursionlimit(10**7)
import re
import copy
import bisect
import math
import itertools
import more_itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().split()))
def gs():
return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input().split())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def rmwh(a):
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
# from decimal import *
# def myround(x, k):
# if k < 0:
# return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
# else:
# return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = copy.deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
def dijkstra(g, st):
vi = set()
res = [inf for i in range(len(g))]
res[st] = 0
s = SortedSet([])
s.add((0, st))
while len(s) != 0:
dis, now = s.pop(0)
vi.add(now)
# print(s, res, now, dis)
for to in g[now].keys():
if to in vi:
continue
w = g[now][to]
if dis + w <= res[to]:
if res[to] == inf:
s.add((dis + w, to))
res[to] = dis + w
else:
r = s.discard((res[to], to))
if r == False:
print('discard error')
print(s)
print(res[to], to)
s.add((dis + w, to))
res[to] = dis + w
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
n, m = gl()
a = gl()
dp = [[-inf for i in range(n)] for j in range(m)]
for i in range(n):
dp[0][i] = a[i]
for i in range(1, m):
b = [-inf for j in range(n)]
for j in range(n):
if j == 0:
b[j] = dp[i-1][0]
else:
b[j] = max(b[j-1], dp[i-1][j])
for j in range(i, n):
dp[i][j] = max(dp[i][j], b[j-1] + a[j] * (i+1))
print(max(dp)[-1])
# import sys
# sys.setrecursionlimit(10**7)
import re
import copy
import bisect
import math
import itertools
import more_itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().split()))
def gs():
return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input().split())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def rmwh(a):
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
# from decimal import *
# def myround(x, k):
# if k < 0:
# return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
# else:
# return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = copy.deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
def dijkstra(g, st):
vi = set()
res = [inf for i in range(len(g))]
res[st] = 0
s = SortedSet([])
s.add((0, st))
while len(s) != 0:
dis, now = s.pop(0)
vi.add(now)
# print(s, res, now, dis)
for to in g[now].keys():
if to in vi:
continue
w = g[now][to]
if dis + w <= res[to]:
if res[to] == inf:
s.add((dis + w, to))
res[to] = dis + w
else:
r = s.discard((res[to], to))
if r == False:
print('discard error')
print(s)
print(res[to], to)
s.add((dis + w, to))
res[to] = dis + w
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
n, m = gl()
a = gl()
dp = [[-inf for i in range(n)] for j in range(m)]
for i in range(n):
dp[0][i] = a[i]
for i in range(1, m):
b = [-inf for j in range(n)]
for j in range(n):
if j == 0:
b[j] = dp[i-1][0]
else:
b[j] = max(b[j-1], dp[i-1][j])
for j in range(i, n):
dp[i][j] = max(dp[i][j], b[j-1] + a[j] * (i+1))
print(max(dp[-1]))
|
ConDefects/ConDefects/Code/abc267_d/Python/45812454
|
condefects-python_data_2168
|
N,M = map(int,input().split())
A = list(map(int,input().split()))
dp = [[0]*N for i in range(M)]
dp[0][0]=A[0]
for i in range(1,N):
dp[0][i]=max(A[i],dp[0][i-1])
for i in range(1,M):
for j in range(i,N):
dp[i][j]=max(dp[i-1][j-1]+A[j]*(i+1),dp[i][j-1])
print(dp[-1][-1])
N,M = map(int,input().split())
A = list(map(int,input().split()))
dp = [[-(10**18)]*N for i in range(M)]
dp[0][0]=A[0]
for i in range(1,N):
dp[0][i]=max(A[i],dp[0][i-1])
for i in range(1,M):
for j in range(i,N):
dp[i][j]=max(dp[i-1][j-1]+A[j]*(i+1),dp[i][j-1])
print(dp[-1][-1])
|
ConDefects/ConDefects/Code/abc267_d/Python/45231504
|
condefects-python_data_2169
|
N, M = map(int, input().split())
A_L = list(map(int, input().split()))
inf = -10**18
dp = [[inf] * (M + 10) for i in range(N + 10)]
dp[0][0] = 0
for i in range(N):
for j in range(M):
if dp[i][j] == inf:
continue
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + (j + 1) * A_L[i])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
ans = 0
for i in range(N+1):
ans = max(ans, dp[i][M])
print(ans)
N, M = map(int, input().split())
A_L = list(map(int, input().split()))
inf = -10**18
dp = [[inf] * (M + 10) for i in range(N + 10)]
dp[0][0] = 0
for i in range(N):
for j in range(M):
if dp[i][j] == inf:
continue
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + (j + 1) * A_L[i])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
ans = inf
for i in range(N+1):
ans = max(ans, dp[i][M])
print(ans)
|
ConDefects/ConDefects/Code/abc267_d/Python/45469454
|
condefects-python_data_2170
|
N,M = map(int,input().split())
a = [*map(int,input().split())]
dp = [[None]*(M+1) for n in range(N+1)]
dp[0][0]=0
for n in range(N):
for m in range(M+1):
if dp[n][m] is not None:
dp[n+1][m] = max(dp[n+1][m],dp[n][m]) if dp[n+1][m] is not None else dp[n][m]
if m<M : dp[n+1][m+1] = max(dp[n+1][m+1],dp[n][m] + a[n]*(m+1)) if dp[n+1][m+1] is not None else dp[n][m] + a[n]*(m+1)
print(max(dp[N]))
N,M = map(int,input().split())
a = [*map(int,input().split())]
dp = [[None]*(M+1) for n in range(N+1)]
dp[0][0]=0
for n in range(N):
for m in range(M+1):
if dp[n][m] is not None:
dp[n+1][m] = max(dp[n+1][m],dp[n][m]) if dp[n+1][m] is not None else dp[n][m]
if m<M : dp[n+1][m+1] = max(dp[n+1][m+1],dp[n][m] + a[n]*(m+1)) if dp[n+1][m+1] is not None else dp[n][m] + a[n]*(m+1)
print(dp[N][M])
|
ConDefects/ConDefects/Code/abc267_d/Python/45515271
|
condefects-python_data_2171
|
n,m=map(int,input().split())
A=list(map(int,input().split()))
dp=[[-(10**10) for i in range(m+1)]for j in range(n+1)]
nowmax=2
for i in range(1,n+1):
a=A[i-1]
before=dp[i-1]
for j in range(1,nowmax):
if j==1:
if before[j]<a:
dp[i][j]=a
else:
dp[i][j]=before[j]
else:
if before[j]<before[j-1]+a*j:
dp[i][j]=before[j-1]+a*j
else:
dp[i][j]=before[j]
if nowmax<m+1:
nowmax+=1
print(dp[-1][-1])
n,m=map(int,input().split())
A=list(map(int,input().split()))
dp=[[-(10**13) for i in range(m+1)]for j in range(n+1)]
nowmax=2
for i in range(1,n+1):
a=A[i-1]
before=dp[i-1]
for j in range(1,nowmax):
if j==1:
if before[j]<a:
dp[i][j]=a
else:
dp[i][j]=before[j]
else:
if before[j]<before[j-1]+a*j:
dp[i][j]=before[j-1]+a*j
else:
dp[i][j]=before[j]
if nowmax<m+1:
nowmax+=1
print(dp[-1][-1])
|
ConDefects/ConDefects/Code/abc267_d/Python/45019438
|
condefects-python_data_2172
|
INT = lambda : int(input())
MI = lambda : map(int, input().split())
MI_DEC = lambda : map(lambda x : int(x)-1, input().split())
LI = lambda : list(map(int, input().split()))
LI_DEC = lambda : list(map(lambda x : int(x)-1, input().split()))
N, M = MI()
A = LI()
dp = [[-float('inf')]*(M+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(M+1):
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
if j + 1 > M:
continue
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + (j+1)*A[i])
ans = -1
for i in range(N+1):
ans = max(ans, dp[i][M])
print(ans)
INT = lambda : int(input())
MI = lambda : map(int, input().split())
MI_DEC = lambda : map(lambda x : int(x)-1, input().split())
LI = lambda : list(map(int, input().split()))
LI_DEC = lambda : list(map(lambda x : int(x)-1, input().split()))
N, M = MI()
A = LI()
dp = [[-float('inf')]*(M+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(M+1):
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
if j + 1 > M:
continue
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + (j+1)*A[i])
ans = -float('inf')
for i in range(N+1):
ans = max(ans, dp[i][M])
print(ans)
|
ConDefects/ConDefects/Code/abc267_d/Python/45550363
|
condefects-python_data_2173
|
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
inf = 10**18
dp = [ [-inf] * (M + 1) for _ in range(N + 1) ]
for i in range(N + 1):
dp[i][0] = 0
for j in range(M + 1):
dp[0][j] = 0
for i in range(1, N + 1):
a = A[i - 1]
maxm = min(M, i)
for j in range(1, maxm + 1):
dp[i][j] = max(dp[i][j], j * a + dp[i - 1][j - 1])
dp[i][j] = max(dp[i][j], dp[i - 1][j])
print(dp[N][M])
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
inf = 10**18
dp = [ [-inf] * (M + 1) for _ in range(N + 1) ]
for i in range(N + 1):
dp[i][0] = 0
for i in range(1, N + 1):
a = A[i - 1]
maxm = min(M, i)
for j in range(1, maxm + 1):
dp[i][j] = max(dp[i][j], j * a + dp[i - 1][j - 1])
dp[i][j] = max(dp[i][j], dp[i - 1][j])
print(dp[N][M])
|
ConDefects/ConDefects/Code/abc267_d/Python/45032308
|
condefects-python_data_2174
|
a,b = map(int, input().split())
print(a**3)
a,b = map(int, input().split())
print(a**b)
|
ConDefects/ConDefects/Code/abc283_a/Python/44590701
|
condefects-python_data_2175
|
A, B = map(int, input().split())
print(A^B)
A, B = map(int, input().split())
print(A**B)
|
ConDefects/ConDefects/Code/abc283_a/Python/44656811
|
condefects-python_data_2176
|
def getIntMap():
return map(int, input().split())
def main():
a, b = getIntMap()
print(a*b)
main()
def getIntMap():
return map(int, input().split())
def main():
a, b = getIntMap()
print(a**b)
main()
|
ConDefects/ConDefects/Code/abc283_a/Python/44652899
|
condefects-python_data_2177
|
n, q = map(int, input().split())
idx = list(range(n+1))
num = list(range(n+1))
for i in range(q):
x = int(input())
y = idx[x]
if y == n:
y = n-1
num[y], num[y+1] = num[y+1], num[y]
idx[num[y]] = y
idx[num[y+1]] = y+1
print(*idx[1:])
n, q = map(int, input().split())
idx = list(range(n+1))
num = list(range(n+1))
for i in range(q):
x = int(input())
y = idx[x]
if y == n:
y = n-1
num[y], num[y+1] = num[y+1], num[y]
idx[num[y]] = y
idx[num[y+1]] = y+1
print(*num[1:])
|
ConDefects/ConDefects/Code/abc250_c/Python/44890242
|
condefects-python_data_2178
|
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def main():
N,Q = mi()
tbl = [i for i in range(N)] #tbl[i] := ボールiのindex
index = [i for i in range(N)] #index[i] := index i のボール
for _ in range(Q):
x = ii()-1
if tbl[x] == N-1:
y = index[tbl[x]-1]
i,j = tbl[x],tbl[x]-1
tbl[x],tbl[y] = j,i
index[j],index[i] = x,y
else:
y = index[tbl[x]+1]
i,j = tbl[x],tbl[x]+1
tbl[x],tbl[y] = j,i
index[j],index[i] = x,y
print(*map(lambda x:x+1,tbl),sep=" ")
if __name__=="__main__":
main()
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def main():
N,Q = mi()
tbl = [i for i in range(N)] #tbl[i] := ボールiのindex
index = [i for i in range(N)] #index[i] := index i のボール
for _ in range(Q):
x = ii()-1
if tbl[x] == N-1:
y = index[tbl[x]-1]
i,j = tbl[x],tbl[x]-1
tbl[x],tbl[y] = j,i
index[j],index[i] = x,y
else:
y = index[tbl[x]+1]
i,j = tbl[x],tbl[x]+1
tbl[x],tbl[y] = j,i
index[j],index[i] = x,y
print(*map(lambda x:x+1,index),sep=" ")
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/abc250_c/Python/45205318
|
condefects-python_data_2179
|
N, Q = map(int, input().split())
X = []
for i in range(Q):
x = int(input())
X.append(x)
pos = [i for i in range(N + 1)] #pos[i] := i番目の要素の値
val = [i for i in range(N + 1)] #val[i] := iは何番目 - 1にあるか
for i in range(Q):
p0 = pos[X[i]]
p1 = p0
if p0 != N:
p1 += 1
else:
p1 -= 1
v0 = val[p0]
v1 = val[p1]
val[p0], val[p1] = val[p1], val[p0]
pos[v0], pos[v1] = pos[v1], pos[v0]
print(*pos[1:])
N, Q = map(int, input().split())
X = []
for i in range(Q):
x = int(input())
X.append(x)
pos = [i for i in range(N + 1)] #pos[i] := i番目の要素の値
val = [i for i in range(N + 1)] #val[i] := iは何番目 - 1にあるか
for i in range(Q):
p0 = pos[X[i]]
p1 = p0
if p0 != N:
p1 += 1
else:
p1 -= 1
v0 = val[p0]
v1 = val[p1]
val[p0], val[p1] = val[p1], val[p0]
pos[v0], pos[v1] = pos[v1], pos[v0]
print(*val[1:])
|
ConDefects/ConDefects/Code/abc250_c/Python/44899033
|
condefects-python_data_2180
|
N,Q = map(int,input().split())
li = [i for i in range(N+1)]
ind = [i for i in range(N+1)]
for i in range(Q):
A = int(input())
B = ind[A]
if B != N:
temp = li[B]
li[B] = li[B+1]
li[B+1] = temp
ind[A] = B+1
ind[li[B]] = B
else:
temp = li[B]
li[B] = li[B-1]
li[B-1] = temp
ind[A] = B-1
ind[li[B]] = B
print(*li)
N,Q = map(int,input().split())
li = [i for i in range(N+1)]
ind = [i for i in range(N+1)]
for i in range(Q):
A = int(input())
B = ind[A]
if B != N:
temp = li[B]
li[B] = li[B+1]
li[B+1] = temp
ind[A] = B+1
ind[li[B]] = B
else:
temp = li[B]
li[B] = li[B-1]
li[B-1] = temp
ind[A] = B-1
ind[li[B]] = B
print(*li[1:])
|
ConDefects/ConDefects/Code/abc250_c/Python/44862385
|
condefects-python_data_2181
|
n,m=map(int,input().split())
for _ in range(n):
a=list(input())
for i in range(m-1):
if a[i]=='T' and a[i+1]=='T':
a[i],a[i+1]='P','T'
print(''.join(a))
n,m=map(int,input().split())
for _ in range(n):
a=list(input())
for i in range(m-1):
if a[i]=='T' and a[i+1]=='T':
a[i],a[i+1]='P','C'
print(''.join(a))
|
ConDefects/ConDefects/Code/abc297_c/Python/46194170
|
condefects-python_data_2182
|
n=int(input())
s=input()
if "ab" or "ba" in s:
print("Yes")
else:
print("No")
n=int(input())
s=input()
if "ab" in s or "ba" in s:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_a/Python/54966208
|
condefects-python_data_2183
|
N = int(input())
S = input()
if "a" in S and "b" in S:
print("Yes")
else:
print("No")
N = int(input())
S = input()
if "ab" in S or "ba" in S:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_a/Python/54982866
|
condefects-python_data_2184
|
N = int(input())
S = input()
ok = ["a", "b"]
for i in range(N-1):
if S[i] in ok and S[i+1] in ok:
print("Yes")
exit()
print("No")
N = int(input())
S = input()
ok = ["a", "b"]
for i in range(N-1):
if S[i] in ok and S[i+1] in ok and S[i] != S[i+1]:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc327_a/Python/54666524
|
condefects-python_data_2185
|
N = int(input())
S = input()
f = False
for i in range(N - 1):
if S[i] == "a" and S[i + 1] == "b":
f = True
if f:
print("Yes")
else:
print("No")
N = int(input())
S = input()
f = False
for i in range(N - 1):
if (S[i] == "a" and S[i + 1] == "b") or (S[i] == "b" and S[i + 1] == "a"):
f = True
if f:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_a/Python/54677762
|
condefects-python_data_2186
|
n = int(input())
s = input()
for i in range(n-1):
if s[i]+s[i+1] == "ab":
print("Yes")
break
else:
print("No")
n = int(input())
s = input()
for i in range(n-1):
if s[i]+s[i+1] == "ab" or s[i]+s[i+1] == "ba":
print("Yes")
break
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_a/Python/54767724
|
condefects-python_data_2187
|
s = input()
t = input()
ls = []
lt = []
c = 1
for i in range(len(s)):
if i != len(s)-1 and s[i] == s[i+1]:
c += 1
else:
ls.append([s[i],c])
c = 1
c = 1
for i in range(len(t)):
if i != len(t)-1 and t[i] == t[i+1]:
c += 1
else:
lt.append([t[i],c])
c = 1
if len(ls) != len(lt):
print("No")
else:
for i in range(len(ls)):
if ls[i][0] != lt[i][0] or (ls[i][1] == 1 and lt[i][1] > 1):
print("No")
break
else:
print("Yes")
s = input()
t = input()
ls = []
lt = []
c = 1
for i in range(len(s)):
if i != len(s)-1 and s[i] == s[i+1]:
c += 1
else:
ls.append([s[i],c])
c = 1
c = 1
for i in range(len(t)):
if i != len(t)-1 and t[i] == t[i+1]:
c += 1
else:
lt.append([t[i],c])
c = 1
if len(ls) != len(lt):
print("No")
else:
for i in range(len(ls)):
if ls[i][0] != lt[i][0] or (ls[i][1] == 1 and lt[i][1] > 1) or (ls[i][1] > lt[i][1]):
print("No")
break
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc259_c/Python/46054515
|
condefects-python_data_2188
|
import itertools
S = list(input())
T = list(input())
s = [[key , len(list(group))] for key , group in itertools.groupby(S)]
t = [[key , len(list(group))] for key , group in itertools.groupby(T)]
if len(s) != len(s) :
print('No')
exit()
for i in range(len(s)) :
if s[i][0] != t[i][0] :
print('No')
exit()
if s[i][1] > t[i][1] :
print('No')
exit()
if s[i][1] < t[i][1] :
if s[i][1] < 2 :
print('No')
exit()
print('Yes')
import itertools
S = list(input())
T = list(input())
s = [[key , len(list(group))] for key , group in itertools.groupby(S)]
t = [[key , len(list(group))] for key , group in itertools.groupby(T)]
if len(s) != len(t) :
print('No')
exit()
for i in range(len(s)) :
if s[i][0] != t[i][0] :
print('No')
exit()
if s[i][1] > t[i][1] :
print('No')
exit()
if s[i][1] < t[i][1] :
if s[i][1] < 2 :
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc259_c/Python/45537510
|
condefects-python_data_2189
|
from itertools import groupby
S = input()
T = input()
def runLengthEncode(S: str) -> "list[tuple(str, int)]":
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
SS = runLengthEncode(S)
TT = runLengthEncode(T)
if len(SS) != len(TT):
print('No')
exit()
else:
for i in range(len(SS)):
if SS[i][0] != TT[i][0]:
print('No')
exit()
else:
if SS[i][1] == 1 and TT[i][1] > 1:
print('No')
exit()
print('Yes')
from itertools import groupby
S = input()
T = input()
def runLengthEncode(S: str) -> "list[tuple(str, int)]":
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
SS = runLengthEncode(S)
TT = runLengthEncode(T)
if len(SS) != len(TT):
print('No')
exit()
else:
for i in range(len(SS)):
if SS[i][0] != TT[i][0]:
print('No')
exit()
else:
if (SS[i][1] == 1 and TT[i][1] > 1) or (SS[i][1] > TT[i][1]):
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc259_c/Python/44929141
|
condefects-python_data_2190
|
S=input()
T=input()
lis=[]
lit=[]
i=0
kari="A"
cnt=0
while i<=len(S)-1:
if i==0:
kari=S[i]
cnt+=1
else:
if S[i-1]==S[i]:
cnt+=1
else:
lis.append((kari,cnt))
kari=S[i]
cnt=1
i+=1
lis.append((kari,cnt))
i=0
kari="A"
cnt=0
while i<=len(T)-1:
if i==0:
kari=T[i]
cnt+=1
else:
if T[i-1]==T[i]:
cnt+=1
else:
lit.append((kari,cnt))
kari=T[i]
cnt=1
i+=1
lit.append((kari,cnt))
if len(lis)!=len(lit):
print("No")
exit()
for i in range(len(lis)):
if lis[i][0]!=lit[i][0]:
print("No")
exit()
else:
if lis[i][1]!=lit[i][1]:
if lis[i][1]==1 or lit[i][1]==1:
print("No")
exit()
print("Yes")
S=input()
T=input()
lis=[]
lit=[]
i=0
kari="A"
cnt=0
while i<=len(S)-1:
if i==0:
kari=S[i]
cnt+=1
else:
if S[i-1]==S[i]:
cnt+=1
else:
lis.append((kari,cnt))
kari=S[i]
cnt=1
i+=1
lis.append((kari,cnt))
i=0
kari="A"
cnt=0
while i<=len(T)-1:
if i==0:
kari=T[i]
cnt+=1
else:
if T[i-1]==T[i]:
cnt+=1
else:
lit.append((kari,cnt))
kari=T[i]
cnt=1
i+=1
lit.append((kari,cnt))
if len(lis)!=len(lit):
print("No")
exit()
for i in range(len(lis)):
if lis[i][0]!=lit[i][0]:
print("No")
exit()
else:
if lis[i][1]!=lit[i][1]:
if lis[i][1]==1 or lis[i][1]>lit[i][1]:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc259_c/Python/45103556
|
condefects-python_data_2191
|
def f(s):
n = len(s)
ans = []
l = 0
while l < n:
r = l + 1
while r < n and s[l] == s[r]:
r += 1
ans.append((s[l], r - l))
l = r
return ans
s = input()
t = input()
s_l = f(s)
t_l = f(t)
if len(s_l) != len(t_l):
exit(print('No'))
flg = 1
for i in range(len(s_l)):
if s_l[i][0] != t_l[i][0]:
flg = 0
if s_l[i][1] == 1 and t_l[i][1] > 1:
flg = 0
print('Yes' if flg else 'No')
def f(s):
n = len(s)
ans = []
l = 0
while l < n:
r = l + 1
while r < n and s[l] == s[r]:
r += 1
ans.append((s[l], r - l))
l = r
return ans
s = input()
t = input()
s_l = f(s)
t_l = f(t)
if len(s_l) != len(t_l):
exit(print('No'))
flg = 1
for i in range(len(s_l)):
if s_l[i][0] != t_l[i][0]:
flg = 0
if s_l[i][1] == 1 and t_l[i][1] > 1:
flg = 0
if s_l[i][1] > t_l[i][1] > 1:
flg = 0
print('Yes' if flg else 'No')
|
ConDefects/ConDefects/Code/abc259_c/Python/44774986
|
condefects-python_data_2192
|
S = list(input())
T = list(input())
S_count = []
T_count = []
sf = S[0]
S_count.append([sf, 1])
for i in range(1, len(S)):
if sf == S[i]:
S_count[-1][1] += 1
else:
sf = S[i]
S_count.append([sf, 1])
tf = T[0]
T_count.append([tf, 1])
for i in range(1, len(T)):
if tf == T[i]:
T_count[-1][1] += 1
else:
tf = T[i]
T_count.append([tf, 1])
tf = True
if len(S_count) != len(T_count):
tf = False
else:
for i in range(len(S_count)):
if S_count[i][1] > T_count[i][1]:
tf = False
if S_count[i][1] == 1 and T_count[i][1] >= 2:
tf = False
if tf:
print("Yes")
else:
print("No")
S = list(input())
T = list(input())
S_count = []
T_count = []
sf = S[0]
S_count.append([sf, 1])
for i in range(1, len(S)):
if sf == S[i]:
S_count[-1][1] += 1
else:
sf = S[i]
S_count.append([sf, 1])
tf = T[0]
T_count.append([tf, 1])
for i in range(1, len(T)):
if tf == T[i]:
T_count[-1][1] += 1
else:
tf = T[i]
T_count.append([tf, 1])
tf = True
if len(S_count) != len(T_count):
tf = False
else:
for i in range(len(S_count)):
if S_count[i][1] > T_count[i][1]:
tf = False
if S_count[i][1] == 1 and T_count[i][1] >= 2:
tf = False
if S_count[i][0] != T_count[i][0]:
tf = False
if tf:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc259_c/Python/44859677
|
condefects-python_data_2193
|
S = input()
T = input()
A = list()
B = list()
cnt = 0
c = ''
for s in S:
if (cnt == 0):
c = s
cnt += 1
elif (s == c):
cnt += 1
else:
A.append((c,str(cnt)))
c = s
cnt = 1
A.append((c,str(cnt)))
cnt = 0
c = ''
for t in T:
if (cnt == 0):
c = t
cnt += 1
elif (t == c):
cnt += 1
else:
B.append((c,str(cnt)))
c = t
cnt = 1
B.append((t,str(cnt)))
if (len(A) != len(B)):
print('NO')
exit()
for i in range(len(A)):
c1 = A[i][0]
c2 = B[i][0]
n1 = int(A[i][1])
n2 = int(B[i][1])
if (c1 != c2 or n1 > n2):
print('No')
exit()
if (n2 > 1 and n1 == 1):
print('No')
exit()
print('Yes')
S = input()
T = input()
A = list()
B = list()
cnt = 0
c = ''
for s in S:
if (cnt == 0):
c = s
cnt += 1
elif (s == c):
cnt += 1
else:
A.append((c,str(cnt)))
c = s
cnt = 1
A.append((c,str(cnt)))
cnt = 0
c = ''
for t in T:
if (cnt == 0):
c = t
cnt += 1
elif (t == c):
cnt += 1
else:
B.append((c,str(cnt)))
c = t
cnt = 1
B.append((t,str(cnt)))
if (len(A) != len(B)):
print('No')
exit()
for i in range(len(A)):
c1 = A[i][0]
c2 = B[i][0]
n1 = int(A[i][1])
n2 = int(B[i][1])
if (c1 != c2 or n1 > n2):
print('No')
exit()
if (n2 > 1 and n1 == 1):
print('No')
exit()
print('Yes')
|
ConDefects/ConDefects/Code/abc259_c/Python/44826067
|
condefects-python_data_2194
|
s = input()
t = input()
k = 0
l = []
m = []
for i in range(1,len(s)):
if s[i-1]!=s[i]:
l.append(s[k:i])
k = i
l.append(s[k:])
k = 0
for j in range(1,len(t)):
if t[j-1]!=t[j]:
m.append(t[k:j])
k = j
m.append(t[k:])
if len(m)!=len(l):
print("No")
exit()
for o in range(len(l)):
if l[o]==m[o]:
continue
elif list(l[o])<list(m[o]) and len(l[o])>=2:
continue
else:
print("No")
exit()
print("Yes")
s = input()
t = input()
k = 0
l = []
m = []
for i in range(1,len(s)):
if s[i-1]!=s[i]:
l.append(s[k:i])
k = i
l.append(s[k:])
k = 0
for j in range(1,len(t)):
if t[j-1]!=t[j]:
m.append(t[k:j])
k = j
m.append(t[k:])
if len(m)!=len(l):
print("No")
exit()
for o in range(len(l)):
if l[o]==m[o]:
continue
elif l[o][0]==m[o][0] and l[o]<m[o] and len(l[o])>=2:
continue
else:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc259_c/Python/45350488
|
condefects-python_data_2195
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
if K % 2 != 0:
now = 0
for i in range(1, K-1, 2):
now += A[i+1] - A[i]
ans = now
for i in range(2, K-1, 2):
now += A[i-1] - A[i-2]
now -= A[i] - A[i-1]
ans = min(ans, now)
print(ans)
exit()
ans = 0
for i in range(0, K-1, 2):
ans += A[i+1] - A[i]
print(ans)
N, K = map(int, input().split())
A = list(map(int, input().split()))
if K % 2 != 0:
now = 0
for i in range(1, K-1, 2):
now += A[i+1] - A[i]
ans = now
for i in range(2, K, 2):
now += A[i-1] - A[i-2]
now -= A[i] - A[i-1]
ans = min(ans, now)
print(ans)
exit()
ans = 0
for i in range(0, K-1, 2):
ans += A[i+1] - A[i]
print(ans)
|
ConDefects/ConDefects/Code/abc334_c/Python/54507811
|
condefects-python_data_2196
|
import math
import sys
import random
from collections import deque
from itertools import product
debug = lambda name, value, *args, **kwargs: print( f"{name}: {value}", *args, file=sys.stderr, **kwargs)
mod = 1000000007
m = random.randint(1,1000000)
iinf = 100000000000000005 #1e18 + 5
input = lambda: sys.stdin.readline().strip()
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
dr = [1,-1,0,0]
dc = [0,0,1,-1]
def main():
n,k = map(int,input().split())
*v, = map(int,input().split())
dp = [[iinf]*2 for _ in range(k+1)]
dp[0][0] = 0
for i in range(k):
if i+2 <= k:
for j in range(2):
dp[i+2][j] = min(dp[i+1][j], dp[i][j] + v[i+1] - v[i])
dp[i+1][1] = min(dp[i+1][1], dp[i][0])
print(min(dp[k][0], dp[k][1]))
t=1
#t = int(input())
for _ in range(t):
main()
import math
import sys
import random
from collections import deque
from itertools import product
debug = lambda name, value, *args, **kwargs: print( f"{name}: {value}", *args, file=sys.stderr, **kwargs)
mod = 1000000007
m = random.randint(1,1000000)
iinf = 100000000000000005 #1e18 + 5
input = lambda: sys.stdin.readline().strip()
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
dr = [1,-1,0,0]
dc = [0,0,1,-1]
def main():
n,k = map(int,input().split())
*v, = map(int,input().split())
dp = [[iinf]*2 for _ in range(k+1)]
dp[0][0] = 0
for i in range(k):
if i+2 <= k:
for j in range(2):
dp[i+2][j] = min(dp[i+2][j], dp[i][j] + v[i+1] - v[i])
dp[i+1][1] = min(dp[i+1][1], dp[i][0])
print(min(dp[k][0], dp[k][1]))
t=1
#t = int(input())
for _ in range(t):
main()
|
ConDefects/ConDefects/Code/abc334_c/Python/54724339
|
condefects-python_data_2197
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
if(k%2==0):
ans=0
for i in range(1,k,2):
ans+=(a[i]-a[i-1])
print(ans)
else:
pre=[0]*(k+1)
after=[0]*(k+1)
for i in range(1,k+1):
pre[i]=pre[i-1]
if(i%2==0):
pre[i]+=a[i]-a[i-1]
for i in range(k-2,-1,-1):
after[i]=after[i+1]
if((k-i)%2==0):
after[i]+=a[i+1]-a[i]
answer=2*10**5+1
for i in range(k):
answer=min(answer,pre[i]+after[i])
print(answer)
n,k=map(int,input().split())
a=list(map(int,input().split()))
if(k%2==0):
ans=0
for i in range(1,k,2):
ans+=(a[i]-a[i-1])
print(ans)
else:
pre=[0]*(k+1)
after=[0]*(k+1)
for i in range(1,k+1):
pre[i]=pre[i-1]
if(i%2==0):
pre[i]+=a[i-1]-a[i-2]
for i in range(k-2,-1,-1):
after[i]=after[i+1]
if((k-i)%2==0):
after[i]+=a[i+1]-a[i]
answer=2*10**5+1
for i in range(k):
answer=min(answer,pre[i]+after[i])
print(answer)
|
ConDefects/ConDefects/Code/abc334_c/Python/55003175
|
condefects-python_data_2198
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
l = [a[i + 1] - a[i] for i in range(0, k - 1, 2)]
if k % 2 == 0:
print(sum(l))
exit()
r = [a[i + 1] - a[i] for i in reversed(range(1, k - 1, 2))]
l = [0] + l
r = [0] + r
for i in reversed(range(k // 2)):
l[i + 1] += l[i]
r[i + 1] += r[i]
for i in range(k // 2 + 1):
l[i] += r[-(i + 1)]
print(min(l))
n, k = map(int, input().split())
a = list(map(int, input().split()))
l = [a[i + 1] - a[i] for i in range(0, k - 1, 2)]
if k % 2 == 0:
print(sum(l))
exit()
r = [a[i + 1] - a[i] for i in reversed(range(1, k - 1, 2))]
l = [0] + l
r = [0] + r
for i in range(k // 2):
l[i + 1] += l[i]
r[i + 1] += r[i]
for i in range(k // 2 + 1):
l[i] += r[-(i + 1)]
print(min(l))
|
ConDefects/ConDefects/Code/abc334_c/Python/54936414
|
condefects-python_data_2199
|
N, X = map(int, input().split())
P = list(map(int, input().split()))
for i in range(N):
if P[i] == X:
print(i)
break
N, X = map(int, input().split())
P = list(map(int, input().split()))
for i in range(N):
if P[i] == X:
print(i+1)
break
|
ConDefects/ConDefects/Code/abc277_a/Python/45949578
|
condefects-python_data_2200
|
n, x = map(int, input().split())
p = list(map(int, input().split()))
print(p.index(x))
n, x = map(int, input().split())
p = list(map(int, input().split()))
print(p.index(x)+1)
|
ConDefects/ConDefects/Code/abc277_a/Python/45114990
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.