input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import math
K=int(eval(input()))
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
for c in range(1,K+1):
ans+=math.gcd(math.gcd(a,b),c)
print(ans) | from math import gcd
K=int(eval(input()))
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
for c in range(1,K+1):
ans+=gcd(gcd(a,b),c)
print(ans) | p02713 |
import math
from functools import reduce
N = int(eval(input()))
def gcd(*numbers):
return reduce(math.gcd, numbers)
sum_N = 0
for i in range(1, N + 1):
for j in range(1, N + 1):
for k in range(1, N + 1):
sum_N += gcd(i, j, k)
print(sum_N)
| from functools import reduce
N = int(eval(input()))
def u_gcd(a, b):
x = a
y = b
while True:
tmp = x % y
if tmp == 0:
return y
else:
x = y
y = tmp
def gcd(*numbers):
return reduce(u_gcd, numbers)
sum_N = 0
for i in range(1, N + 1):
for j in range(1, N + 1):
for k in range(1, N + 1):
sum_N += gcd(i, j, k)
print(sum_N) | p02713 |
import math
import itertools
k = int(eval(input()))
k_list = []
for i in range(1, k+1):
k_list.append(i)
total = 0
for i in list(itertools.product(k_list,repeat=3)):
total += math.gcd(i[0],math.gcd(i[1],i[2]))
print(total) | import math
k = int(eval(input()))
total = 0
for a in range(1, k+1):
for b in range(1, k+1):
if math.gcd(a,b) == 1:
total += k
else:
for c in range(1, k+1):
total += math.gcd(a,math.gcd(b,c))
print(total) | p02713 |
import math
from functools import reduce
s=0
K=int(eval(input()))
for a in range(K):
for b in range(K):
for c in range(K):
x=reduce(math.gcd,(a+1,b+1,c+1))
s+=x
print(s) | import math
from functools import reduce
s=0
K=int(eval(input()))+1
for a in range(1,K):
for b in range(a,K):
for c in range(b,K):
if a==b==c:
s+=a
continue
x=reduce(math.gcd,(a,b,c))
if a==b or b==c or c==a:
s+=x*3
else:
s+=x*6
print(s) | p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
K = int(eval(input()))
sum = 0
for i in range(1, K+1):
for j in range(1, K+1):
for k in range(1, K+1):
sum += gcd(i,j,k)
print(sum) | import math
K=int(eval(input()))
ans=0
for i in range(1,K+1):
for j in range(1,K+1):
tmp=math.gcd(i,j)
for k in range(1,K+1):
ans+=math.gcd(tmp,k)
print(ans) | p02713 |
from functools import reduce
import math
num = int(eval(input()))
sum = 0
def gcd(*numbers):
return reduce(math.gcd, numbers)
for a in range(1, num + 1):
for b in range(1, num + 1):
for c in range(1, num + 1):
sum += gcd(a, b, c)
print(sum) | import math
num = int(eval(input()))
sum = 0
for a in range(1, num + 1):
for b in range(1, num + 1):
gcd_ab = math.gcd(a, b)
for c in range(1, num + 1):
sum += math.gcd(gcd_ab, c)
print(sum) | p02713 |
import math
N = int(eval(input()))
sum = 0
for i in range(1, N+1):
for j in range(1, N+1):
for k in range(1, N + 1):
sum+= math.gcd(i,math.gcd(j,k))
print(sum)
| from math import gcd
N = int(eval(input()))
sum = 0
for i in range(1, N+1):
for j in range(1, N + 1):
x=gcd(i,j)
for k in range(1, N + 1):
hoge = gcd(x,k)
sum+=hoge
print(sum)
| p02713 |
import math
from functools import reduce
k = int(eval(input()))
ans = 0
def gcd(*numbers):
return reduce(math.gcd, numbers)
for a in range(1, k+1):
for b in range(1, k+1):
for c in range(1, k+1):
ans += gcd(a, b, c)
print(ans) | import math
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
tmp = math.gcd(a, b)
for c in range(1, k+1):
ans += math.gcd(tmp, c)
print(ans) | p02713 |
import math
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
for c in range(1, k+1):
ans += math.gcd(a, math.gcd(b, c))
print(ans) | import math
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
tmp = math.gcd(a, b)
for c in range(1, k+1):
ans += math.gcd(tmp, c)
print(ans) | p02713 |
import math
import itertools
from functools import reduce
from itertools import product
def gcd(*numbers):
return reduce(math.gcd, numbers)
def gcd_list(numbers):
return reduce(math.gcd, numbers)
l = int(eval(input()))
s = 0
li = list(range(1,l+1))
for i,j,k in product(li, repeat = 3):
s += gcd(i,j,k)
print(s) | import math
l = int(eval(input()))
s = 0
for i in range(1, l+1):
for j in range(1, l+1):
tmp = math.gcd(i,j)
for j in range(1, l+1):
s += math.gcd(tmp,j)
print(s) | p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
def main():
K = int(eval(input()))
ans = 0
for i in range(1, K+1):
for j in range(1, K+1):
for k in range(1, K+1):
ans += gcd(i, j, k)
print(ans)
if __name__ == "__main__":
main() | from math import gcd
def main():
K = int(eval(input()))
ans = 0
for i in range(1, K+1):
for j in range(1, K+1):
g = gcd(i, j)
for k in range(1, K+1):
ans += gcd(g, k)
print(ans)
if __name__ == "__main__":
main() | p02713 |
import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
import sys
sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7
si = lambda: input().strip()
ii = lambda: int(eval(input()))
mii = lambda: list(map(int, input().split()))
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))
K = ii()
ans = 0
for i in range(1, K+1):
for j in range(1, K+1):
for k in range(1, K+1):
ans += gcd(gcd(i, j), k)
print(ans) | import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
import sys
import bisect
sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7
si = lambda: input().strip()
ii = lambda: int(eval(input()))
mii = lambda: list(map(int, input().split()))
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))
K = ii()
ans = 0
for i in range(1, K+1):
for j in range(1, K+1):
g = gcd(i, j)
for k in range(1, K+1):
ans += gcd(g, k)
print(ans) | p02713 |
import math
#from functools import reduce
k = int(eval(input()))
lis = [(0)] * (250*250)
ans = 0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
x = math.gcd(b,c)
lis[b + (250*c)] = (x)
ans += lis[a + (250*x)]
print(ans)
| from math import gcd
#from functools import reduce
k = int(eval(input()))
ans = 0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
ans += gcd(gcd(b,c),a)
print(ans) | p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
x = 0
n = int(eval(input()))+1
for i in range(1,n):
for j in range(1, n):
for k in range(1, n):
x += int(gcd(i,j,k))
print(x) | from math import gcd
x = 0
n = int(eval(input()))+1
for i in range(1,n):
for j in range(1, n):
for k in range(1, n):
x += gcd(gcd(i,j), k)
print(x) | p02713 |
K = int(eval(input()))
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
temp = []
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
temp.append(gcd(i,j,k))
print((sum(temp))) | K = int(eval(input()))
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
ans = 0
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
ans += (gcd(i,j,k))
print(ans) | p02713 |
K = int(eval(input()))
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
ans = 0
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
ans += (gcd(i,j,k))
print(ans) | from math import gcd
k = int(eval(input()))
ans = 0
for x in range(1,k+1):
for y in range(1,k+1):
for z in range(1,k+1):
ans += gcd(gcd(x,y),z)
print(ans)
| p02713 |
import math
k = int(eval(input()))
ans = 0
for i in range(1,k+1):
for j in range(1,k+1):
for k in range(1,k+1):
value = math.gcd(i,j)
ans += math.gcd(value,k)
print(ans) | import math
k = int(eval(input()))
ans = 0
for i in range(1, k+1):
for j in range(1, k+1):
num = math.gcd(i, j)
for l in range(1, k+1):
ans += math.gcd(num, l)
print(ans) | p02713 |
from math import gcd
k = int(eval(input()))
ans = 0
for i in range(k):
for j in range(k):
for l in range(k):
ans += gcd(gcd(i+1, j+1),l+1)
print(ans) | from math import gcd
k = int(eval(input())) + 1
ans = 0
for i in range(1,k):
for j in range(1,k):
for l in range(1,k):
ans += gcd(gcd(i, j),l)
print(ans) | p02713 |
import math
K = int(eval(input()))+1
ans = 0
for i in range(1,K):
for j in range(1,K):
for k in range(1,K):
ans += math.gcd(math.gcd(i, j),k)
print(ans) | from math import gcd
K = int(eval(input()))+1
ans = 0
for i in range(1,K):
for j in range(1,K):
for k in range(1,K):
ans += gcd(gcd(i, j),k)
print(ans) | p02713 |
import math
def main():
K = int(eval(input()))
sum = 0
for a in range(K):
for b in range(K):
for c in range(K):
sum += math.gcd(math.gcd(a+1,b+1),c+1)
print(("{}".format(sum)))
if __name__=="__main__":
main() | import math
def main():
K = int(eval(input()))
total = 0
for a in range(1,K+1):
if a==1:
total += 1*K*K
else:
for b in range(1,K+1):
if b==1:
total += 1*K
else:
for c in range(1,K+1):
total += math.gcd(math.gcd(a,b),c)
print(("{}".format(total)))
if __name__=="__main__":
main() | p02713 |
from math import gcd
k = int(eval(input())) + 1
ans = 0
for s in range(1, k):
for t in range(s, k):
for u in range(t, k):
if (v := len(set([s, t, u]))) == 1:
ans += gcd(gcd(s, t), u)
elif v == 2:
ans += gcd(gcd(s, t), u) * 3
else:
ans += gcd(gcd(s, t), u) * 6
print(ans)
| from math import gcd
k = int(eval(input())) + 1
ans = 0
for s in range(1, k):
for t in range(s, k):
first = gcd(s, t)
for u in range(t, k):
if (v := len(set([s, t, u]))) == 1:
ans += gcd(first, u)
elif v == 2:
ans += gcd(first, u) * 3
else:
ans += gcd(first, u) * 6
print(ans)
| p02713 |
k = int(eval(input()))
gcd_dict = {}
ans = 0
for n in range(k, 0, -1):
for a in range(n, k + 1, n):
for b in range(n, k + 1, n):
for c in range(n, k + 1, n):
if (a, b, c) not in list(gcd_dict.keys()):
gcd_dict[(a, b, c)] = n
ans += n
print(ans)
|
k = int(eval(input()))
gcd_cnt = {}
for n in range(k, 0, -1):
div_all = (k // n) ** 3
div_dup = 0
for m in range(n * 2, k + 1, n):
div_dup += gcd_cnt[m]
gcd_cnt[n] = div_all - div_dup
ans = 0
for gcd in list(gcd_cnt.keys()):
ans += gcd * gcd_cnt[gcd]
print(ans)
| p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
sum = 0
for x in range(1, k + 1):
for y in range(1, k + 1):
for z in range(1, k + 1):
sum += gcd(x, y, z)
print(sum) | import math
k = int(eval(input()))
two = []
total = 0
for x in range(1, k + 1):
for y in range(1, k + 1):
two.append(math.gcd(x, y))
for z in range(1, k + 1):
for i in two:
total += math.gcd(z, i)
print(total)
| p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
def gcd_list(numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
s = 0
l = []
for i in range(k):
for j in range(k):
l.append(gcd(i+1,j+1))
for h in range(k):
for n in l:
s += gcd(h+1, n)
print(s)
| import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
def gcd_list(numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
s = 0
l = []
for i in range(k):
for j in range(k):
l.append(math.gcd(i+1,j+1))
for h in range(k):
for n in l:
s += math.gcd(h+1, n)
print(s)
| p02713 |
K = int(eval(input()))
def gcd(x, y):
a, b = x, y
while b != 0:
a, b = b, a % b
return a
gcds = [[0 for j in range(K)] for i in range(K)]
for i in range(K):
for j in range(K):
gcds[i][j] = gcd(i+1, j+1)
S = 0
for i in range(K):
for j in range(K):
for k in range(K):
S += gcds[gcds[j][k]-1][i]
print(S) | K = int(eval(input()))
mod = int(1e9) + 7
X = [0 for _ in range(K)]
def doubling(n, m):
y = 1
base = n
while m != 0:
if m % 2 == 1:
y *= base
y %= mod
base *= base
base %= mod
m //= 2
return y
SS = 0
for i in range(K, 0, -1):
d = K // i
S = doubling(d, 3)
if d > 1:
for j in range(2, d+1):
S -= X[j*i-1]
S %= mod
X[i-1] = S
SS += i * S
SS %= mod
print(SS) | p02713 |
import math
from functools import reduce
def gcd_list(numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
ans = 0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1, k+1):
ans += gcd_list([a,b,c])
print(ans) | import math
from functools import reduce
def gcd_list(numbers):
return reduce(math.gcd, numbers)
def calc_same_num(s):
if s[0]==s[1] and s[1]==s[2]:
return 1
elif s[0]==s[1] or s[1]==s[2]:
return 3
else:
return 6
k = int(eval(input()))
sum_check = 0
a,b,c = 1,1,1
ans = 0
while a<=k and b<=k and c<=k:
gcd = gcd_list([a,b,c])
ans += gcd*calc_same_num([a,b,c])
if c<k:
c += 1
elif b<k:
b += 1
c = b
else:
a += 1
b = a
c = a
print(ans) | p02713 |
import math
k = int(eval(input()))
total = 0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
if a == b == c:
total += a
continue
if a == 1:
total += a
continue
if b == 1:
total += b
continue
if c == 1:
total += c
continue
if a % b == 0:
total += math.gcd(b,c)
continue
if b % a == 0:
total += math.gcd(a,c)
continue
total += math.gcd(math.gcd(a,b),c)
print(total) | import math
k = int(eval(input()))
k_arr = list(range(1,k+1))
a_arr = list()
b_arr = list()
for k in k_arr:
for a in k_arr:
a_arr.append(a)
for b in k_arr:
for k in k_arr:
b_arr.append(b)
gcds = list(map(math.gcd,a_arr,b_arr))
total = 0
for c in k_arr:
c_arr = [c] * k * k
total += sum(map(math.gcd,gcds,c_arr))
print(total) | p02713 |
def gcd2(a, b):
if b == 0:
return a
return gcd2(b, a % b)
def gcd3(a, b, c):
return gcd2(gcd2(a, b), c)
if __name__ == "__main__":
k = int(eval(input()))
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
for c in range(1, k + 1):
ans += gcd3(a, b, c)
print(ans) | def gcd2(a, b):
if b == 0:
return a
return gcd2(b, a % b)
def gcd3(a, b, c):
return gcd2(gcd2(a, b), c)
if __name__ == "__main__":
k = int(eval(input()))
ans = 0
for a in range(1, k + 1):
for b in range(1, a + 1):
for c in range(1, b + 1):
if a == b and b == c and c == a:
ans += gcd3(a, b, c)
elif a == b or b == c or c == a:
ans += gcd3(a, b, c) * 3
else:
ans += gcd3(a, b, c) * 6
print(ans) | p02713 |
import math
import itertools
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
ans = 0
for a,b,c in itertools.product(list(range(1,k + 1)), repeat=3):
s = gcd(a,b,c)
ans += s
print(ans) | import math
k = int(eval(input())) + 1
ans = 0
for a in range(1, k):
for b in range(1, k):
d = math.gcd(a, b)
for c in range(1, k):
ans += math.gcd(d, c)
print(ans) | p02713 |
import math
n=int(eval(input()))
def gcd2(a,b,c):
d=math.gcd(a,b)
e=math.gcd(c,d)
return e
s=0
for i1 in range(1,n+1):
for i2 in range(1,n+1):
for i3 in range(1,n+1):
s+=gcd2(i1,i2,i3)
print(s)
| import math
n=int(eval(input()))
def gcd2(a,b,c):
d=math.gcd(a,b)
e=math.gcd(c,d)
return e
s=0
s1=0
s2=0
s3=0
for i in range(1,n+1):
s1+=i
for i2 in range(i+1,n+1):
s2+=math.gcd(i,i2)
for i3 in range(i2+1,n+1):
s3+=gcd2(i,i2,i3)
s=s1+6*s2+6*s3
print(s)
| p02713 |
import math
from functools import reduce
k=int(eval(input()))
ans=0
def gcd(*numbers):
return reduce(math.gcd, numbers)
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
ans+=(gcd(a,b,c))
print(ans) | import itertools
import math
from functools import reduce
k=int(eval(input()))
l=list(range(1,k+1))
ans=0
def gcd(*numbers):
return reduce(math.gcd, numbers)
for i in itertools.product(l,repeat=3):
ans+=(gcd(i[0],i[1],i[2]))
print(ans) | p02713 |
import math
K = int(eval(input()))
ans = 0
for i in range(K):
for j in range(K):
for k in range(K):
ans += math.gcd(i+1, math.gcd(j+1, k+1))
print(ans)
| import math
K = int(eval(input()))
ans = 0
for i in range(1, K+1):
for j in range(i, K+1):
for k in range(j, K+1):
if (i == j) and (j == k):
ans += math.gcd(i, math.gcd(j, k))
elif (i == j) or (j == k):
ans += 3 * math.gcd(i, math.gcd(j, k))
else:
ans += 6 * math.gcd(i, math.gcd(j, k))
print(ans)
| p02713 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
for c in range(1, k+1):
ans += gcd(a,b,c)
print(ans) | import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(a, k+1):
for c in range(b, k+1):
t = len({a,b,c})
if t == 3:
ans += gcd(a,b,c) * 6
elif t == 2:
ans += gcd(a,b,c) * 3
else:
ans += gcd(a,b,c)
print(ans) | p02713 |
import math
n=int(eval(input()))
s=0
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
s += math.gcd(i,math.gcd(j,k))
print(s)
| import math
def main():
k=int(eval(input()))
cur=0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
cur+=math.gcd(math.gcd(a,b),c)
return cur
print((main()))
| p02713 |
import math
from functools import reduce
n = int(eval(input()))
ans = 0
li = []
buf = n
for i in range(1,n+1):
for j in range(1,n+1):
tmp = math.gcd(i,j)
li.append(tmp)
for i in range(len(li)):
for j in range(1,n+1):
ans += math.gcd(li[i],j)
print(ans)
| import math
from functools import reduce
n = int(eval(input()))
ans = 0
li = []
buf = n
def gcd(*numbers):
return reduce(math.gcd,numbers)
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
ans += gcd(i,j,k)
print(ans)
| p02713 |
#!/usr/bin/env python3
import math
MOD = 10**9
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
K = int(eval(input()))
ans = 0
for i in range(1, K+1):
for j in range(i, K+1):
for k in range(j, K+1):
if i==j and i==k: g = i
elif (i==j and i!=k):
g = math.gcd(i,math.gcd(j,k))*3
elif (i==k and i!=j):
g = math.gcd(i,math.gcd(j,k))*3
elif (j==k and i!=j):
g = math.gcd(i,math.gcd(j,k))*3
else : g = math.gcd(i,math.gcd(j,k))*6
ans += g
print(ans)
| import math
K = int(eval(input()))
ans = 0
for i in range(1, K+1):
for j in range(i, K+1):
for k in range(j, K+1):
if i==j and i==k: g = i
elif (i==j and i!=k):
g = math.gcd(i,math.gcd(j,k))*3
elif (i==k and i!=j):
g = math.gcd(i,math.gcd(j,k))*3
elif (j==k and i!=j):
g = math.gcd(i,math.gcd(j,k))*3
else : g = math.gcd(i,math.gcd(j,k))*6
ans += g
print(ans)
| p02713 |
from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1,n+1):
for b in range(1,n+1):
for c in range(1,n+1):
ans += gcd(a,gcd(b,c))
print(ans) | from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1,n+1):
for b in range(1,n+1):
for c in range(1,n+1):
ans += gcd(c,gcd(a,b))
print(ans) | p02713 |
tableA,tableB = {},{}
def main():
make_table()
while True:
try:
s = "".join([tableA[c] for c in input()])
except:
break
tmp,ans = "",""
for c in s:
tmp += c
if tmp in tableB:
ans += tableB[tmp]
tmp = ""
print(ans)
def make_table():
global tableA,tableB
tableA={
"A":"00000",
"B":"00001",
"C":"00010",
"D":"00011",
"E":"00100",
"F":"00101",
"G":"00110",
"H":"00111",
"I":"01000",
"J":"01001",
"K":"01010",
"L":"01011",
"M":"01100",
"N":"01101",
"O":"01110",
"P":"01111",
"Q":"10000",
"R":"10001",
"S":"10010",
"T":"10011",
"U":"10100",
"V":"10101",
"W":"10110",
"X":"10111",
"Y":"11000",
"Z":"11001",
" ":"11010",
".":"11011",
",":"11100",
"-":"11101",
"'":"11110",
"?":"11111"}
tableB ={
"101":" ",
"000000":"'",
"000011":",",
"10010001":"-",
"010001":".",
"000001":"?",
"100101":"A",
"10011010":"B",
"0101":"C",
"0001":"D",
"110":"E",
"01001":"F",
"10011011":"G",
"010000":"H",
"0111":"I",
"10011000":"J",
"0110":"K",
"00100":"L",
"10011001":"M",
"10011110":"N",
"00101":"O",
"111":"P",
"10011111":"Q",
"1000":"R",
"00110":"S",
"00111":"T",
"10011100":"U",
"10011101":"V",
"000010":"W",
"10010010":"X",
"10010011":"Y",
"10010000":"Z"}
if __name__ == "__main__":
main() | def main():
tableA,tableB = make_table()
while True:
try:
s = "".join([tableA[c] for c in input()])
except:
break
tmp,ans = "",""
for c in s:
tmp += c
if tmp in tableB:
ans += tableB[tmp]
tmp = ""
print(ans)
def make_table():
tableA={
"A":"00000",
"B":"00001",
"C":"00010",
"D":"00011",
"E":"00100",
"F":"00101",
"G":"00110",
"H":"00111",
"I":"01000",
"J":"01001",
"K":"01010",
"L":"01011",
"M":"01100",
"N":"01101",
"O":"01110",
"P":"01111",
"Q":"10000",
"R":"10001",
"S":"10010",
"T":"10011",
"U":"10100",
"V":"10101",
"W":"10110",
"X":"10111",
"Y":"11000",
"Z":"11001",
" ":"11010",
".":"11011",
",":"11100",
"-":"11101",
"'":"11110",
"?":"11111"}
tableB ={
"101":" ",
"000000":"'",
"000011":",",
"10010001":"-",
"010001":".",
"000001":"?",
"100101":"A",
"10011010":"B",
"0101":"C",
"0001":"D",
"110":"E",
"01001":"F",
"10011011":"G",
"010000":"H",
"0111":"I",
"10011000":"J",
"0110":"K",
"00100":"L",
"10011001":"M",
"10011110":"N",
"00101":"O",
"111":"P",
"10011111":"Q",
"1000":"R",
"00110":"S",
"00111":"T",
"10011100":"U",
"10011101":"V",
"000010":"W",
"10010010":"X",
"10010011":"Y",
"10010000":"Z"}
return tableA,tableB
if __name__ == "__main__":
main() | p00111 |
#!/usr/bin/env python
from sys import stdin, exit
code_table = {chr(65+i): '{:05b}'.format(i) for i in range(26)}
code_table.update({' ': '11010', '.': '11011', ',': '11100', '-': '11101',
"'": '11110', '?': '11111'})
def decrypt(it):
if int(next(it)):
if int(next(it)):
if int(next(it)):
return 'P'
else:
return 'E'
else:
if int(next(it)):
return ' '
else:
if int(next(it)):
if int(next(it)):
if int(next(it)):
if int(next(it)):
if int(next(it)):
return 'Q'
else:
return 'N'
else:
if int(next(it)):
return 'V'
else:
return 'U'
else:
if int(next(it)):
if int(next(it)):
return 'G'
else:
return 'B'
else:
if int(next(it)):
return 'M'
else:
return 'J'
else:
if int(next(it)):
return 'A'
else:
if int(next(it)):
if int(next(it)):
return 'Y'
else:
return 'X'
else:
if int(next(it)):
return '-'
else:
return 'Z'
else:
return 'R'
else:
if int(next(it)):
if int(next(it)):
if int(next(it)):
return 'I'
else:
return 'K'
else:
if int(next(it)):
return 'C'
else:
if int(next(it)):
return 'F'
else:
if int(next(it)):
return '.'
else:
return 'H'
else:
if int(next(it)):
if int(next(it)):
if int(next(it)):
return 'T'
else:
return 'S'
else:
if int(next(it)):
return 'O'
else:
return 'L'
else:
if int(next(it)):
return 'D'
else:
if int(next(it)):
if int(next(it)):
return ','
else:
return 'W'
else:
if int(next(it)):
return '?'
else:
return "'"
def main():
for line in stdin:
it = iter(''.join(code_table[c] for c in line.rstrip('\r\n')))
try:
while 1:
print(decrypt(it), end='')
except StopIteration:
print()
exit()
if __name__ == '__main__':
main() | #!/usr/bin/env python
from sys import stdin, exit
code_table = {chr(65+i): '{:05b}'.format(i) for i in range(26)}
code_table.update({' ': '11010', '.': '11011', ',': '11100', '-': '11101',
"'": '11110', '?': '11111'})
decrypt = {
'101': ' ', '000000': "'", '000011': ',', '10010001': '-',
'010001': '.', '000001': '?', '100101': 'A', '10011010': 'B',
'0101': 'C', '0001': 'D', '110': 'E', '01001': 'F',
'10011011': 'G', '010000': 'H', '0111': 'I', '10011000': 'J',
'0110': 'K', '00100': 'L', '10011001': 'M', '10011110': 'N',
'00101': 'O', '111': 'P', '10011111': 'Q', '1000': 'R',
'00110': 'S', '00111': 'T', '10011100': 'U', '10011101': 'V',
'000010': 'W', '10010010': 'X', '10010011': 'Y', '10010000': 'Z'}
def main():
for line in stdin:
buf = ''
for c in ''.join(code_table[c] for c in line.rstrip('\r\n')):
buf += c
plain = decrypt.get(buf)
if plain:
print(plain, end='')
buf = ''
print()
exit()
if __name__ == '__main__':
main() | p00111 |
import sys
CharToSign = {
"A": "00000", "B": "00001", "C": "00010", "D": "00011",
"E": "00100", "F": "00101", "G": "00110", "H": "00111",
"I": "01000", "J": "01001", "K": "01010", "L": "01011",
"M": "01100", "N": "01101", "O": "01110", "P": "01111",
"Q": "10000", "R": "10001", "S": "10010", "T": "10011",
"U": "10100", "V": "10101", "W": "10110", "X": "10111",
"Y": "11000", "Z": "11001", " ": "11010", ".": "11011",
",": "11100", "-": "11101", "'": "11110", "?": "11111",
}
SignToChar = {
"101": " ", "000000": "'", "000011": ",", "10010001": "-",
"010001": ".", "000001": "?", "100101": "A", "10011010": "B",
"0101": "C", "0001": "D", "110": "E", "01001": "F",
"10011011": "G", "010000": "H", "0111": "I", "10011000": "J",
"0110": "K", "00100": "L", "10011001": "M", "10011110": "N",
"00101": "O", "111": "P", "10011111": "Q", "1000": "R",
"00110": "S", "00111": "T", "10011100": "U", "10011101": "V",
"000010": "W", "10010010": "X", "10010011": "Y", "10010000": "Z",
}
for line in sys.stdin:
line = line[:-1]
sign = []
for char in line:
convert = CharToSign[char]
sign.append(convert)
sign = "".join(sign)
startIndex = 0
endIndex = 3
string = []
length = len(sign)
while endIndex <= length:
part = sign[startIndex:endIndex]
if part in SignToChar:
convert = SignToChar[part]
string.append(convert)
startIndex = endIndex
endIndex += 3
else:
endIndex += 1
string = "".join(string)
print(string)
| import sys
CharToSign = {
"A": "00000", "B": "00001", "C": "00010", "D": "00011",
"E": "00100", "F": "00101", "G": "00110", "H": "00111",
"I": "01000", "J": "01001", "K": "01010", "L": "01011",
"M": "01100", "N": "01101", "O": "01110", "P": "01111",
"Q": "10000", "R": "10001", "S": "10010", "T": "10011",
"U": "10100", "V": "10101", "W": "10110", "X": "10111",
"Y": "11000", "Z": "11001", " ": "11010", ".": "11011",
",": "11100", "-": "11101", "'": "11110", "?": "11111",
}
SignToChar = {
"101": " ", "000000": "'", "000011": ",", "10010001": "-",
"010001": ".", "000001": "?", "100101": "A", "10011010": "B",
"0101": "C", "0001": "D", "110": "E", "01001": "F",
"10011011": "G", "010000": "H", "0111": "I", "10011000": "J",
"0110": "K", "00100": "L", "10011001": "M", "10011110": "N",
"00101": "O", "111": "P", "10011111": "Q", "1000": "R",
"00110": "S", "00111": "T", "10011100": "U", "10011101": "V",
"000010": "W", "10010010": "X", "10010011": "Y", "10010000": "Z",
}
for line in sys.stdin:
line = line[:-1]
sign = ""
for char in line:
sign += CharToSign[char]
string = ""
part = ""
for item in sign:
part += item
if part in SignToChar:
string += SignToChar[part]
part = ""
print(string)
| p00111 |
N = eval(input())
if int(N) == 1:
print("Hello World")
else:
A = int(eval(input()))
B = int(eval(input()))
print((A + B))
| N = int(eval(input()))
if N == 1:
print("Hello World")
else:
A = int(eval(input()))
B = int(eval(input()))
print((A + B))
| p03238 |
n = int(eval(input()))
if n==1:
print('Hello World')
else:
a = int(eval(input()))
b = int(eval(input()))
print((a+b))
| n = int(eval(input()))
if n==1:
print('Hello World')
exit()
a = int(eval(input()))
b = int(eval(input()))
print((a+b)) | p03238 |
import math
def ip():return int(eval(input()))
def imp():return list(map(int,input().split()))
n=ip()
if n==1:print("Hello World")
else:
a=ip()
b=ip()
print((a+b)) | n=int(eval(input()))
if n==1:print("Hello World")
else:print((int(eval(input()))+int(eval(input())))) | p03238 |
N = int(eval(input()))
if N == 1:
print("Hello World")
else:
A = int(eval(input()))
B = int(eval(input()))
print((A+B)) | #coding: utf-8
N = int(eval(input()))
if N == 1:
print("Hello World")
else:
a = int(eval(input()))
b = int(eval(input()))
print((a+b)) | p03238 |
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
if n == 1:
print("Hello World")
else:
a = int(eval(input()))
b = int(eval(input()))
print((a+b))
| def main():
n = int(eval(input()))
# h, w, k = map(int, input().split())
# a = list(map(int, input().split()))
# s = input()
if n == 1:
print("Hello World")
else:
a = int(eval(input()))
b = int(eval(input()))
print((a+b))
if __name__ == '__main__':
main()
| p03238 |
print(eval(input())+eval(input())if eval(input())-1else'Hello World') | print(eval(input())+eval(input())if~-eval(input())else'Hello World') | p03238 |
i=lambda:int(eval(input()));print((i()+i()if~-i()else'Hello World')) | print('Hello World'*-~-~-eval(input())or eval(input())+eval(input())) | p03238 |
def toInteger(string):
integer = int(string)
return integer
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString('Hello World')
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
a = myInput()
solve(a) | def toInteger(string):
try:
integer = int(string)
return integer
except:
print('Number Format Exception')
exit()
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString('Hello World')
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
def main():
a = myInput()
solve(a)
main() | p03238 |
n = int(input())
if n == 1: print('Hello World')
elif n == 2: print(int(input())+int(input())) | print('Hello World' if int(input()) == 1 else (int(input())+int(input()))) | p03238 |
N = int(eval(input()))
if(N == 1):
print("Hello World")
else:
print((int(eval(input())) + int(eval(input())))) | def ans():
N = int(eval(input()))
if(N == 1):
print("Hello World")
else:
A = int(eval(input()))
B = int(eval(input()))
print((A+B))
ans() | p03238 |
age = int(eval(input()))
if age == 1:
print('Hello World')
elif age == 2:
a = int(eval(input()))
b = int(eval(input()))
print((a + b)) | n = int(eval(input()))
if n == 1:
print('Hello World')
else:
a = int(eval(input()))
b = int(eval(input()))
print((a + b))
| p03238 |
*a,=list(map(int,open(0).read().split()))
print((a[1]+a[2]if a[0]>1else'Hello World')) | i=input;print((eval(i()+'+'+i())if'1'<i()else'Hello World')) | p03238 |
if int(eval(input())) == 1:
print('Hello World')
else:
print((int(eval(input()))+int(eval(input())))) | n = int(eval(input()))
if n == 1:
print('Hello World')
else:
a = int(eval(input()))
b = int(eval(input()))
print((a + b)) | p03238 |
n = int(eval(input()))
tree = [[] for _ in range(n)]
for i in range(n-1):
v, w = list(map(int, input().split()))
if v > w:
v, w = w, v
tree[w-1].append(v-1)
ans = 0
count = 0
for i in range(n):
count += i+1
for v in tree[i]:
count -= v+1
ans += count
print(ans) | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
tree = [[] for _ in range(n)]
for i in range(n-1):
v, w = list(map(int, input().split()))
if v > w:
v, w = w, v
tree[w-1].append(v-1)
ans = 0
count = 0
for i in range(n):
count += i+1
for v in tree[i]:
count -= v+1
ans += count
print(ans)
if __name__ == "__main__":
main()
| p02617 |
# coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
from heapq import heappop, heappush
#from collections import OrderedDict, defaultdict
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
#import numba
def sum_between(a, b):
if a > b:a, b = b, a
return (b-a+1) * (b+a) // 2
def run():
N = int(eval(input()))
n_dots = 0
for i in range(1, N+1):
n_dots += (1+i) * i // 2
#print(n_dots)
ans = (N-1) * (N+1) * N // 2
#print(ans)
for i in range(N-1):
u, v = list(map(int, input().split()))
l, r = min(u, v), max(u, v)
tmp = 0
if l > 1: tmp += sum_between(r-1, r-l+1)
tmp += r-l
tmp += sum_between(N-l, 1)
#print(tmp)
ans -= tmp
print((n_dots - ans))
ans = (N-1) * N * N
if __name__ == "__main__":
run() | # coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
from heapq import heappop, heappush
#from collections import OrderedDict, defaultdict
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
#import numba
def sum_between(a, b):
if a > b:a, b = b, a
return (b-a+1) * (b+a) // 2
def run():
N = int(eval(input()))
n_dots = 0
for i in range(1, N+1):
n_dots += (1+i) * i // 2
#print(n_dots)
ans = (N-1) * (N+1) * N // 2
#print(ans)
for i in range(N-1):
l, r = list(map(int, input().split()))
if l > r: l,r = r,l
tmp = 0
if l > 1: tmp += sum_between(r-1, r-l+1)
tmp += r-l
tmp += sum_between(N-l, 1)
#print(tmp)
ans -= tmp
print((n_dots - ans))
ans = (N-1) * N * N
if __name__ == "__main__":
run() | p02617 |
n = int(eval(input()))
a = [i+1 for i in range(n)]
b = [1]
for i in range(1,n):
b.append(b[-1] + a[i])
c = [0]
for i in range(n-1):
c.append(c[-1]+b[i])
#print(a)
#print(b)
#print(c)
ans = b[-1] + c[-1]
for _ in range(n-1):
xy = list(map(int,input().split()))
xy.sort()
x,y = xy
ans -= x * (n+1-y)
print(ans) | n = int(eval(input()))
ans = n*(n+1)*(n+2)//6
for i in range(n-1):
xy = list(map(int,input().split()))
ans -= min(xy) * (n+1-max(xy))
print(ans) | p02617 |
n=int(eval(input()))
a=0
for i in range(n):
a+=(i+1)*(n-i)
for _ in range(n-1):
u,v=list(map(int,input().split()))
if u>v: u,v=v,u
a-=u*(n-v+1)
print(a) | n=int(eval(input()))
a=sum(-~i*(n-i) for i in range(n))
for _ in range(n-1):
u,v=list(map(int,input().split()))
if u>v: u,v=v,u
a-=u*(n-v+1)
print(a) | p02617 |
n=int(eval(input()))+1
a=(n**3-n)//6
for _ in range(n-2):
u,v=list(map(int,input().split()))
a-=min(u,v)*(n-max(u,v))
print(a) | n,*l=list(map(int,open(0).read().split()));n+=1;i=iter(l);print(((n**3-n)//6-sum(min(u,v)*(n-max(u,v))for u,v in zip(i,i)))) | p02617 |
N = int(eval(input()))
ans = 0
for i in range(1, N + 1):
ans += i * (N + 1 - i)
for i in range(N - 1):
u, v = list(map(int, input().split()))
u, v = min(u, v), max(u, v)
ans -= (N - v + 1) * u
print(ans)
| N,*t=list(map(int,open(0).read().split()))
t=iter(t)
print((N*(N+1)*(N+2)//6+sum([-min(a,b)*(N-max(a,b)+1) for a,b in zip(t,t)]))) | p02617 |
n=int(eval(input()))
if n==1:
print((1))
else:
g=[list(map(int,input().split())) for i in range(n-1)]
edge_sum=0
for l in range(1,n+1):
for r in range(l,n+1):
edge_num=0
edge_num += r-l+1
for k in range(n-1):
if l<=g[k][0]<=r and l<=g[k][1]<=r:
edge_num -= 1
edge_sum +=edge_num
print(edge_sum) | n=int(eval(input()))
ans=0
for i in range(1,n+1):
ans += i*(i+1)/2
for i in range(n-1):
u,v=list(map(int,input().split()))
if u > v:
u,v=v,u
ans -= u*(n-v+1)
print((int(ans))) | p02617 |
# Union Find
class edge:
def __init__(self, u, v):
self.u = u
self.v = v
def min(self):
return min(self.u, self.v)
def max(self):
return max(self.u, self.v)
# xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
# xとyの属する集合の併合
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return False
else:
# sizeの大きいほうがx
if par[x] > par[y]:
x, y = y, x
par[x] += par[y]
par[y] = x
return True
# xとyが同じ集合に属するかの判定
def same(x, y):
return find(x) == find(y)
# xが属する集合の個数
def size(x):
return -par[find(x)]
# 初期化
# 根なら-size,子なら親の頂点
N = int(eval(input()))
edge_list = []
for i in range(N - 1):
u, v = list(map(int, input().split()))
edge_list.append(edge(u - 1, v - 1))
ans_sum = 0
edge_list.append(edge(N, N))
upper_l_edge_list = sorted(edge_list, key=lambda e: -e.max())
for l in range(N):
par = [-1] * N
num_cc = 0
upper_l_edge_list_copy = [e for e in upper_l_edge_list if e.min() >= l]
### upper_l_edge_list_copy.append(edge(N, N))
### upper_l_edge_list = sorted(upper_l_edge_list_copy, key=lambda e: -e.max()) ###
for r in range(l, N):
size = 0
# print([(e.u, e.v) for e in upper_l_edge_list])
while upper_l_edge_list_copy[-1].max() <= r:
e = upper_l_edge_list_copy.pop()
if not same(e.u, e.v):
size += 1
unite(e.u, e.v)
num_cc = num_cc - size + 1
# print(l, r, num_cc, "size_r", size)
ans_sum += num_cc
print(ans_sum)
| class edge:
def __init__(self, u, v):
self.u = u
self.v = v
def min(self):
return min(self.u, self.v)
def max(self):
return max(self.u, self.v)
N = int(eval(input()))
edge_list = []
for i in range(N - 1):
u, v = list(map(int, input().split()))
edge_list.append(edge(u - 1, v - 1))
ver_num = int(N * (N + 1) * (N + 2) / 6)
edge_num = 0
for e in edge_list:
edge_num += (N + 1 - (e.max() + 1)) * (e.min() + 1)
print((ver_num - edge_num))
| p02617 |
n = int(eval(input()))
V = E = 0
for d in range(1,n+1): V += d * (d + 1) // 2
for _ in range(n-1):
a, b = list(map(int, input().split()))
if a > b: a, b = b, a
E += a * (n - b + 1)
print((V - E))
| n = int(eval(input()))
V = n*(n+1)*(n+2)//6; E = 0
for _ in range(n-1):
u, v = list(map(int, input().split()))
if u > v: u, v = v, u
E += u * (n - v + 1)
print((V - E))
| p02617 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
parents = [-1] * N
stack = [0]
while stack:
v = stack.pop()
for e in G[v]:
if e == 0 or parents[e] >= 0:
continue
parents[e] = v
stack.append(e)
ans = N
for i in range(1,N):
if parents[i] > i:
ans += (parents[i] - i) * (i + 1)
else:
ans += (i - parents[i]) * (N - i)
print(ans)
if __name__ == '__main__':
main() | import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
N = int(eval(input()))
ans = 0
for i in range(N):
ans += (i + 1)*(N - i)
for _ in range(N - 1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
if a > b:
a,b = b,a
ans -= (N - b) * (a + 1)
print(ans)
if __name__ == '__main__':
main() | p02617 |
N=int(eval(input()))
l = [list(map(int, input().split())) for l in range(N-1)]
c=0
for i in range(N-1):c+=min(l[i])*(N+1-max(l[i]))
print((N*(N+1)*(N+2)//6-c)) | N=int(eval(input()))
l = [sorted(list(map(int, input().split()))) for l in range(N-1)]
c=0
for i in range(N-1):c+=l[i][0]*(N+1-l[i][1])
print((N*(N+1)*(N+2)//6-c)) | p02617 |
N = int(eval(input()))
count = [1 for _ in range(N+2)]
count[-1] = 0
count[0] = 0
nextpoint = [[] for _ in range(N+1)]
for _ in range(N-1):
u, v = list(map(int, input().split()))
if u > v:
nextpoint[v].append(u)
else:
nextpoint[u].append(v)
#print(nextpoint)
for k in range(N+1):
if len(nextpoint[k]) > 0:
nextpoint[k].sort()
#print(nextpoint)
for k in range(1, N):
for item in nextpoint[k]:
count[item] -= 1
#print(count)
ans = 0
for k in range(1, N):
count[k+1] += count[k]
#print(count)
ans = sum(count) #L=1
#print(ans)
before = ans
for k in range(1, N):#L=2~N
before -= N-k+1
for item in nextpoint[k]:
before += N+1-item
ans += before
print(ans)
| N = int(eval(input()))
count = [1 for _ in range(N+2)]
count[-1] = 0
count[0] = 0
nextpoint = [[] for _ in range(N+1)]
for _ in range(N-1):
u, v = list(map(int, input().split()))
if u > v:
nextpoint[v].append(u)
else:
nextpoint[u].append(v)
#print(nextpoint)
for k in range(1, N):
for item in nextpoint[k]:
count[item] -= 1
#print(count)
ans = 0
for k in range(1, N):
count[k+1] += count[k]
#print(count)
ans = sum(count) #L=1
#print(ans)
before = ans
for k in range(1, N):#L=2~N
before -= N-k+1
for item in nextpoint[k]:
before += N+1-item
ans += before
print(ans)
| p02617 |
def examA():
N = I()
ans = (10000 - N)%1000
print(ans)
return
def examB():
T = ["AC","WA","TLE","RE"]
N = I()
S = [SI()for _ in range(N)]
ans = [0]*4
for s in S:
for i in range(4):
if s==T[i]:
ans[i] += 1
break
for i in range(4):
print((T[i]+" x "+str(ans[i])))
return
def examC():
H, W, K = LI()
C = [[""]*W for _ in range(H)]
for h in range(H):
S = SI()
for w in range(W):
C[h][w] = S[w]
ans = 0
#print(C)
for hi in range(1<<H):
nowC = deepcopy(C)
for h in range(H):
if hi&(1<<h):
for i in range(W):
nowC[h][i] = "R"
for wi in range(1 << W):
nowCC = deepcopy(nowC)
for w in range(W):
if wi & (1 << w):
for i in range(H):
nowCC[i][w] = "R"
cnt = 0
for h in range(H):
for w in range(W):
if nowCC[h][w] == "#":
cnt += 1
if cnt == K:
#print(hi, wi, nowCC)
ans += 1
print(ans)
return
def examD():
N = I()
A = LI()
A.sort(reverse=True)
ans = 0
ans += A[0]
cur = 0
for i in range(2,N):
if i%2==0:
cur += 1
ans += A[cur]
print(ans)
return
def examE():
N, K = LI()
A = LI()
A_neg = []; neg = 0
A_0 = []; num_0 = 0
A_pos = []; pos = 0
for a in A:
if a<0:
A_neg.append(-a)
neg += 1
elif a==0:
A_0.append(a)
num_0 += 1
else:
A_pos.append(a)
pos += 1
if N-num_0<K:
print((0))
return
A_neg.sort()
A_pos.sort()
if pos==0:
ans = 1
if K%2==0:
ans = 1
for i in range(neg-K,neg):
ans *= A_neg[i]
ans %= mod
else:
for i in range(K):
ans *= A_neg[i]
ans %= mod
ans = mod - ans
if num_0>0:
ans = 0
print(ans)
return
if neg==0:
ans = 1
for i in range(pos - K, pos):
ans *= A_pos[i]
ans %= mod
print(ans)
return
A_neg.sort(reverse=True)
A_pos.sort(reverse=True)
now_p = 0
now_n = 0
ans = 1
if pos+neg==K:
for i in range(pos):
ans *= A_pos[i]
ans %= mod
for i in range(neg):
ans *= A_neg[i]
ans %= mod
if neg%2==1:
ans = mod-ans
print(ans)
return
if K%2==1:
ans *= A_pos[now_p]
now_p += 1
while (now_n + now_p < K):
if now_n + 1 >= neg:
ans *= A_pos[now_p] * A_pos[now_p + 1]
ans %= mod
now_p += 2
continue
if now_p + 1 >= pos:
ans *= A_neg[now_n] * A_neg[now_n + 1]
ans %= mod
now_n += 2
continue
if A_pos[now_p] * A_pos[now_p + 1] >= A_neg[now_n] * A_neg[now_n + 1]:
ans *= A_pos[now_p] * A_pos[now_p + 1]
ans %= mod
now_p += 2
else:
ans *= A_neg[now_n] * A_neg[now_n + 1]
ans %= mod
now_n += 2
print(ans)
return
def examF():
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
u, v = LI()
u -= 1; v -= 1
V[v].append(u)
V[u].append(v)
ans = 0
for i in range(N):
ans += (i+1)*(N-i)
def dfs(s,p):
cur = 0
for v in V[s]:
if v==p:
continue
cur += dfs(v,s)
if v<s:
cur += (v+1)*(N-s)
else:
cur += (s+1)*(N-v)
return cur
cnt = dfs(0,-1)
ans -= cnt
print(ans)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examF()
"""
6
8 7 6 5 4 3
5 5
-1 -2 3 4 5
""" | def examA():
N = I()
ans = (10000 - N)%1000
print(ans)
return
def examB():
T = ["AC","WA","TLE","RE"]
N = I()
S = [SI()for _ in range(N)]
ans = [0]*4
for s in S:
for i in range(4):
if s==T[i]:
ans[i] += 1
break
for i in range(4):
print((T[i]+" x "+str(ans[i])))
return
def examC():
H, W, K = LI()
C = [[""]*W for _ in range(H)]
for h in range(H):
S = SI()
for w in range(W):
C[h][w] = S[w]
ans = 0
#print(C)
for hi in range(1<<H):
nowC = deepcopy(C)
for h in range(H):
if hi&(1<<h):
for i in range(W):
nowC[h][i] = "R"
for wi in range(1 << W):
nowCC = deepcopy(nowC)
for w in range(W):
if wi & (1 << w):
for i in range(H):
nowCC[i][w] = "R"
cnt = 0
for h in range(H):
for w in range(W):
if nowCC[h][w] == "#":
cnt += 1
if cnt == K:
#print(hi, wi, nowCC)
ans += 1
print(ans)
return
def examD():
N = I()
A = LI()
A.sort(reverse=True)
ans = 0
ans += A[0]
cur = 0
for i in range(2,N):
if i%2==0:
cur += 1
ans += A[cur]
print(ans)
return
def examE():
N, K = LI()
A = LI()
A_neg = []; neg = 0
A_0 = []; num_0 = 0
A_pos = []; pos = 0
for a in A:
if a<0:
A_neg.append(-a)
neg += 1
elif a==0:
A_0.append(a)
num_0 += 1
else:
A_pos.append(a)
pos += 1
if N-num_0<K:
print((0))
return
A_neg.sort()
A_pos.sort()
if pos==0:
ans = 1
if K%2==0:
ans = 1
for i in range(neg-K,neg):
ans *= A_neg[i]
ans %= mod
else:
for i in range(K):
ans *= A_neg[i]
ans %= mod
ans = mod - ans
if num_0>0:
ans = 0
print(ans)
return
if neg==0:
ans = 1
for i in range(pos - K, pos):
ans *= A_pos[i]
ans %= mod
print(ans)
return
A_neg.sort(reverse=True)
A_pos.sort(reverse=True)
now_p = 0
now_n = 0
ans = 1
if pos+neg==K:
for i in range(pos):
ans *= A_pos[i]
ans %= mod
for i in range(neg):
ans *= A_neg[i]
ans %= mod
if neg%2==1:
ans = mod-ans
print(ans)
return
if K%2==1:
ans *= A_pos[now_p]
now_p += 1
while (now_n + now_p < K):
if now_n + 1 >= neg:
ans *= A_pos[now_p] * A_pos[now_p + 1]
ans %= mod
now_p += 2
continue
if now_p + 1 >= pos:
ans *= A_neg[now_n] * A_neg[now_n + 1]
ans %= mod
now_n += 2
continue
if A_pos[now_p] * A_pos[now_p + 1] >= A_neg[now_n] * A_neg[now_n + 1]:
ans *= A_pos[now_p] * A_pos[now_p + 1]
ans %= mod
now_p += 2
else:
ans *= A_neg[now_n] * A_neg[now_n + 1]
ans %= mod
now_n += 2
print(ans)
return
def examF():
N = I()
V = [[]for _ in range(N)]
for _ in range(N-1):
u, v = LI()
u -= 1; v -= 1
V[v].append(u)
V[u].append(v)
ans = 0
for i in range(N):
ans += (i+1)*(N-i)
def dfs(s,p):
cur = 0
for v in V[s]:
if v==p:
continue
cur += dfs(v,s)
if v<s:
cur += (v+1)*(N-s)
else:
cur += (s+1)*(N-v)
return cur
cnt = dfs(0,-1)
ans -= cnt
print(ans)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
examF()
"""
6
8 7 6 5 4 3
5 5
-1 -2 3 4 5
""" | p02617 |
N = 0
graphs = []
try:
N = int(eval(input()))
nodes = [[abs(i - j) + 1 for i in range(N)] for j in range(N)]
for i in range(N - 1):
line = input().split()
u = min(int(line[0]), int(line[1])) - 1
v = max(int(line[0]), int(line[1])) - 1
for u2 in range(0, u + 1):
for v2 in range(v, N):
if u2 < v2:
nodes[u2][v2] -= 1
except:
pass
a = 0
for i in range(N):
a += sum(nodes[i][i:])
print(a) | N = 0
a = 0
try:
N = int(eval(input()))
for i in range(N + 1):
a += i * (i + 1) // 2
for i in range(N - 1):
line = input().split()
u = min(int(line[0]), int(line[1])) - 1
v = max(int(line[0]), int(line[1])) - 1
a -= (u + 1) * (N - v)
except:
pass
print(a) | p02617 |
N=int(eval(input()))
S=list(range(1, N+1))#頂点の数
H = [list(map(int,input().split())) for i in range(N-1)]#辺のリスト
F = 0
tyouten = int(N*(N+1)*(N+2)/6)
for i in range(1,N+1):
for j in range(i,N+1):
Hselect = [H[x] for x in range(N-1) if i <= H[x][0] <= j and i <= H[x][1] <= j]#L以上R以下の頂点で構成される辺のリスト
F += len(Hselect)
#以上の処理をL＝1〜N、R＝L〜Nまで繰り返す
print((tyouten-F))#頂点数からHselectの要素数を引いた数＝連結成分数 | N=int(eval(input()))
S=list(range(1, N+1))#頂点の数
H = [sorted(list(map(int,input().split()))) for i in range(N-1)]#辺のリスト。頂点は右にいくほど大きい
F = 0
tyouten = int(N*(N+1)*(N+2)/6)
for i in range(len(H)):
F += H[i][0]*(N-H[i][1]+1)#uVの組み合わせによって得られる辺の数をFに追加
print((tyouten-F))#頂点数からHselectの要素数を引いた数＝連結成分数 | p02617 |
n = int(input())
edges = [list(map(int , input().split())) for _ in range(n-1)]
q = 0
for i in range(1, n + 1): q += i * (n - i + 1)
for u,v in edges:
u,v = min(u,v), max(u,v)
q += (u ) * (n -v +1) * -1
print(q) | n = int(input())
print(sum([i * (n - i + 1) for i in range(1, n + 1)]) - sum([u * (n -v +1) for u,v in [sorted(map(int , input().split())) for _ in range(n-1)] ])) | p02617 |
N=int(eval(input()))
P=0
for i in range(N):
P+=(i+1)*(i+2)//2
u,v=0,0
for i in range(N-1):
u,v=list(map(int,input().split()))
u,v=min(u,v),max(u,v)-1
P-=u*(N-v)
print(P)
| N=int(eval(input()))
P=0
for i in range(N):
P+=(i+2)*(i+1)//2
u,v=0,0
for i in range(N-1):
u,v=list(map(int,input().split()))
if u>v:
u,v=v,u
P-=u*(N-v+1)
print(P) | p02617 |
N=int(eval(input()))
ans=0
for _ in range(N-1):
u,v=list(map(int,input().split()))
u,v=min(u-1,v-1),max(u-1,v-1)
ans-=(u+1)*(N-v)
for i in range(N):
for j in range(i,N):
ans+=j-i+1
print(ans) | N=int(eval(input()))
ans=0
for _ in range(N-1):
u,v=list(map(int,input().split()))
u,v=min(u-1,v-1),max(u-1,v-1)
ans-=(u+1)*(N-v)
for i in range(1,N+1):
ans+=i*(i+1)//2
print(ans) | p02617 |
n = int(eval(input()))
lst = [[] for i in range(n+1)]
for i in range(n-1):
ai, bi = list(map(int, input().split()))
lst[ai].append(bi)
lst[bi].append(ai)
tf = [0 for i in range(n+1)]
tf[1] = 1
iro = 1
queue = lst[1]
while queue != []:
iro = -iro
new_queue = []
for i in queue:
if tf[i] == 0:
tf[i] = iro
for j in lst[i]:
if tf[j] == 0:
new_queue.append(j)
queue = new_queue
n_minus = tf.count(-1)
n_plus = tf.count(1)
ans = [0 for i in range(n)]
if n_minus <= n//3:
bai = 1
for i in range(1, n+1):
if tf[i] == -1:
ans[i-1] = 3 * bai
bai += 1
kouho = 1
for i in range(1, n+1):
if tf[i] == 1:
if bai <= n//3:
ans[i-1] = 3 * bai
bai += 1
else:
ans[i-1] = kouho
kouho += 1
if kouho % 3 == 0:
kouho += 1
elif n_plus <= n//3:
bai = 1
for i in range(1, n+1):
if tf[i] == 1:
ans[i-1] = 3 * bai
bai += 1
kouho = 1
for i in range(1, n+1):
if tf[i] == -1:
if bai <= n//3:
ans[i-1] = 3 * bai
bai += 1
else:
ans[i-1] = kouho
kouho += 1
if kouho % 3 == 0:
kouho += 1
else:
bai = 1
kouho1 = 1
kouho2 = 2
for i in range(1, n+1):
if tf[i] == 1:
if kouho1 <= n:
ans[i-1] = kouho1
kouho1 += 3
else:
ans[i-1] = 3 * bai
bai += 1
else:
if kouho2 <= n:
ans[i-1] = kouho2
kouho2 += 3
else:
ans[i-1] = 3 * bai
bai += 1
print((' '.join(map(str, ans)))) | n = int(eval(input()))
lst = [[] for i in range(n+1)]
for i in range(n-1):
ai, bi = list(map(int, input().split()))
lst[ai].append(bi)
lst[bi].append(ai)
tf = [0 for i in range(n+1)]
tf[1] = 1
iro = 1
queue = lst[1]
while queue != []:
iro = -iro
new_queue = []
for i in queue:
tf[i] = iro
for j in lst[i]:
if tf[j] == 0:
new_queue.append(j)
queue = new_queue
n_minus = tf.count(-1)
n_plus = tf.count(1)
ans = [0 for i in range(n)]
if n_minus <= n//3:
bai = 1
for i in range(1, n+1):
if tf[i] == -1:
ans[i-1] = 3 * bai
bai += 1
kouho = 1
for i in range(1, n+1):
if tf[i] == 1:
if bai <= n//3:
ans[i-1] = 3 * bai
bai += 1
else:
ans[i-1] = kouho
kouho += 1
if kouho % 3 == 0:
kouho += 1
elif n_plus <= n//3:
bai = 1
for i in range(1, n+1):
if tf[i] == 1:
ans[i-1] = 3 * bai
bai += 1
kouho = 1
for i in range(1, n+1):
if tf[i] == -1:
if bai <= n//3:
ans[i-1] = 3 * bai
bai += 1
else:
ans[i-1] = kouho
kouho += 1
if kouho % 3 == 0:
kouho += 1
else:
bai = 1
kouho1 = 1
kouho2 = 2
for i in range(1, n+1):
if tf[i] == 1:
if kouho1 <= n:
ans[i-1] = kouho1
kouho1 += 3
else:
ans[i-1] = 3 * bai
bai += 1
else:
if kouho2 <= n:
ans[i-1] = kouho2
kouho2 += 3
else:
ans[i-1] = 3 * bai
bai += 1
print((' '.join(map(str, ans)))) | p02749 |
import sys,random
try: sys.stdin = open('in.in','r')
except: pass
ans = 0
allboth = 1
l = r = 0
n = int(eval(input()))
for i in range(n):
s = input().strip()
ans += s.count('AB')
if s[0] == 'B' or s[-1] == 'A':
l += s[0] == 'B'
r += s[-1] == 'A'
if s[0] != 'B' or s[-1] != 'A':
allboth = 0
ans += min(l,r)
if allboth and ans:
while True:
pass
ans -= 1
print(ans)
| import sys,random
try: sys.stdin = open('in.in','r')
except: pass
ans = 0
allboth = 1
l = r = 0
n = int(eval(input()))
for i in range(n):
s = input().strip()
ans += s.count('AB')
if s[0] == 'B' or s[-1] == 'A':
l += s[0] == 'B'
r += s[-1] == 'A'
if s[0] != 'B' or s[-1] != 'A':
allboth = 0
ans += min(l,r)
if allboth and l:
ans -= 1
print(ans)
| p03049 |
# div2019C - AB Substrings
from itertools import permutations
def main():
N = int(eval(input()))
S = tuple(input().rstrip() for _ in range(N))
ans = 0
for perm in permutations(S, N):
x = "".join(perm)
ans = max(ans, x.count("AB"))
print(ans)
if __name__ == "__main__":
main() | # div2019C - AB Substrings
def main():
N, *S = open(0).read().split()
ans, ab, start_b, end_a = 0, 0, 0, 0
for s in S:
if s[0] == "B" and s[-1] == "A":
ab += 1
elif s[0] == "B":
start_b += 1
elif s[-1] == "A":
end_a += 1
ans += s.count("AB")
if start_b + end_a == 0:
ans += max(0, ab - 1)
else:
ans += ab + min(start_b, end_a)
print(ans)
if __name__ == "__main__":
main() | p03049 |
_,*s=open(0).read().split()
a=b=c=d=0
for S in s:
c+=S.count('AB')
if S[-1]=='A':
a+=1
if S[0]!='B':d=1
if S[0]=='B':
b+=1
if S[-1]!='A':d=1
print((c+max(min(a,b)+d-1,0)))
| _,*s=open(0).read().split()
a=b=c=d=0
for S in s:a+=S[-1]=='A';b+=S[0]=='B';c+=S[-1]+S[0]=='AB';d+=S.count('AB')
print((d+min(a,b)-(0<a==b==c)))
| p03049 |
from collections import*
n,*s=open(0).read().split()
d=defaultdict(int)
#print(s)
ans=0
for i in s:
ans+=i.count("AB")
if i[0]=="B" or i[-1]=="A":
d[(i[0]=="B",i[-1]=="A")]+=1
#print(d,ans)
if len(list(d.values()))==0:
print(ans)
exit()
else:
if d[(True,True)]>0 and d[(True,False)]>0 and d[(False,True)]>0: #ABggfgAB
ans+=d[(True,True)]+1
d[(True,True)]=0
d[(True,False)]-=1
d[(False,True)]-=1
# print(d,ans)
if d[(True,True)]>0 and d[(True,False)]>0:
# print(d)
ans+=d[(True,True)]
d[(True,True)]=0
d[(True,False)]-=1
if d[(True,True)]>0 and d[(False,True)]>0:
# print(d)
ans+=d[(True,True)]
d[(True,True)]=0
d[(False,True)]-=1
if d[(True,True)]>1:
ans+=d[(True,True)]-1
if d[(False,True)]>0 and d[(True,False)]>0:
# print(d)
ans+=min(d[(False,True)],d[(True,False)])
print(ans) | n,*t=open(0).read().split()
n=int(n)
a=0
b=0
c=0
ans=0
for i in t:
if i[0]=="B"and i[-1]=="A":
a+=1
elif i[0]=="B":
b+=1
elif i[-1]=="A":
c+=1
ans+=i.count("AB")
if a>0 and b>0 and c>0:
ans+=a+1
a=0
b-=1
c-=1
if a>0 and b>0:
ans+=a
a=0
b-=1
if a>0 and c>0:
ans+=a
a=0
c-=1
if a>0:
ans+=a-1
a=0
if b>0 and c>0:
ans+=min(b,c)
print(ans)
| p03049 |
#!/usr/bin/env python3
import sys
def solve(N: int, s: "List[str]"):
x = 0
a = 0
b = 0
for i in s:
if(i[0] == 'B' and i[-1] == 'A'):
x += 1
elif(i[-1] == 'A'):
a += 1
elif(i[0] == 'B'):
b += 1
#### AC #####
# if(x == 0):
# ans1 = min(a,b)
# else:
# ans1 = max(0,x-1)+min(a,b)
# if(a > 0 or b > 0):
# ans1 += 1
ans1 = max(0,x-1) + min(a,b)
if((a > 0 or b >0) and x > 0):
ans1 += 1
# if(a == b):
# if(x != 0 and a > 0):
# ans1 += 1
# else:
# if(a > 0 or b > 0):
# ans1 += 1
# ans1 = max(0,x-1)
# if(a == b):
# ans1 += min(a,b)
# else:
# if(x == 0):
# ans1 += min(a,b)
# else:
# ans1 += min(a,b)+1
ans2 = 0
for i in s:
ans2 += i.count('AB')
print((ans1+ans2))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
s = [ next(tokens) for _ in range(N) ] # type: "List[str]"
solve(N, s)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, s: "List[str]"):
x = 0
a = 0
b = 0
for i in s:
if(i[0] == 'B' and i[-1] == 'A'):
x += 1
elif(i[-1] == 'A'):
a += 1
elif(i[0] == 'B'):
b += 1
#### AC1 #####
# if(x == 0):
# ans1 = min(a,b)
# else:
# ans1 = max(0,x-1)+min(a,b)
# if(a > 0 or b > 0):
# ans1 += 1
##### AC2 ####
ans1 = max(0,x-1) + min(a,b)
if((a > 0 or b >0) and x > 0):
ans1 += 1
#### WA #############
# ans1 = max(0,x-1) + min(a,b)
# if(x != 0):
# ans1 += 1
ans1 = max(0,x-1)
if(a == b):
ans1 += min(a,b)
if((a > 0 or b > 0) and x != 0):
ans1 += 1
else:
if(x == 0):
ans1 += min(a,b)
elif(a > 0 or b > 0):
ans1 += min(a,b)+1
ans2 = 0
for i in s:
ans2 += i.count('AB')
print((ans1+ans2))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
s = [ next(tokens) for _ in range(N) ] # type: "List[str]"
solve(N, s)
if __name__ == '__main__':
main()
| p03049 |
import sys
from collections import deque
def main():
input = sys.stdin.readline
N = int(eval(input()))
ans = 0
q = deque()
first_b = 0
last_a = 0
for _ in range(N):
s = str(input().strip())
for i in range(len(s)):
if s[i:i+2] == 'AB':
ans += 1
if s[0] == 'B' or s[-1] == 'A':
if s[0] == 'B':
first_b += 1
if s[-1] == 'A':
last_a += 1
q.append(s)
while first_b * last_a != 0 and len(q) > 1:
q_ = deque()
s = q.popleft()
while len(q) > 0:
s1 = q.popleft()
if s[-1] == 'A' and s1[0] == 'B':
ans += 1
last_a -= 1
first_b -= 1
s = s[0] + s1[-1]
elif s[0] == 'B' and s1[-1] == 'A':
ans += 1
last_a -= 1
first_b -= 1
s = s1[0] + s[-1]
else:
q_.append(s1)
q_.append(s)
q = q_
return ans
if __name__ == '__main__':
print((main()))
| import sys
def main():
input = sys.stdin.readline
N = int(eval(input()))
ans = 0
ba = 0 # Num. of str that the first letter is B and the last one is A.
xa = 0 # Num. of str that the last letter is A and the first one is not B.
bx = 0 # Num. of str that the first letter is B and the last one is not A.
for _ in range(N):
s = str(input().strip())
# Count the number of AB contained in the initial strings.
for i in range(len(s)):
if s[i:i+2] == 'AB':
ans += 1
if s[0] == 'B' and s[-1] == 'A':
ba += 1
elif s[-1] == 'A':
xa += 1
elif s[0] == 'B':
bx += 1
if ba == 0:
# One xa ans one bx make one new "AB".
# xa + bx -> xABx
ans += min(xa, bx)
elif max(xa, bx) == 0:
# N of ba make N-1 new "AB".
# BxxA + BxxA + ... + BxxA -> BxxABxxAB...ABxxA
ans += ba - 1
else: # There is at least one bx or ax and at least one ba.
# N of ba make N-1 new "AB" and a ba.
# ba + ba + ... + ba -> baba...ba = ba
# The last remaining ba and bx/ax make a new "AB" and a new bx/ax.
# ba + bx -> bABx = bx, xa + ba -> xABa = xa
# Then, bx and xa make a new "AB".
# xa + bx -> xABx
ans += ba + min(xa, bx)
return ans
if __name__ == '__main__':
print((main()))
| p03049 |
n = int(eval(input()))
print(((n+1) &- (n+1))) | n = int(eval(input())) + 1
print((n &- n)) | p02116 |
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
pos=nd
while True:
gap=(pos&-pos)//2
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos>maxi:
pos-=gap
elif pos==maxi:
self.val[pos-1]+=x
if not pos&1:
self.lazy[pos-gap-1]+=x
break
else:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x
pos+=gap
while pos!=self.parent[nd]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
pos=nd
while True:
gap=(pos&-pos)//2
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos>mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x
pos-=gap
elif pos==mini:
self.val[pos-1]+=x
if not pos&1:
self.lazy[pos+gap-1]+=x
break
else:
pos+=gap
while pos!=self.parent[nd]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
gap=(pos&-pos)//2
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
pos=nd
while True:
gap=(pos&-pos)//2
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos>maxi:
pos-=gap
elif pos==maxi:
break
else:
pos+=gap
while pos!=self.parent[nd]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
res=self.merge_func(res,self.val[pos-1])
if not pos&1:
res=self.merge_func(res,self.merge[pos-gap-1]+self.lazy[pos-gap-1])
pos=self.parent[pos]
return res
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
pos=nd
while True:
gap=(pos&-pos)//2
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos>mini:
pos-=gap
elif pos==mini:
break
else:
pos+=gap
while pos!=self.parent[nd]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
res=self.merge_func(res,self.val[pos-1])
if not pos&1:
res=self.merge_func(res,self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
return res
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
def segfunc(*args):
return min(args)
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,segfunc,ide_ele)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | p03686 |
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
deq.append(v-gap)
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent(pos)!=1<<self.n:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent(pos)
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent(pos)
res.append(start)
return res[::-1]
def parent(self,n):
lsb=(n&-n)
n-=lsb
lsb2=(n&-n)
return n+2*lsb*(lsb2!=2*lsb)
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | p03686 |
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0))) | p03686 |
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
def range_goal(self,l,r):
n=(l^r).bit_length()-1
m=(l&-l).bit_length()-1
if n>m:
return (r>>n)<<n
else:
return l
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print((max(-add,0)))
| class LazySegmentTree():
def __init__(self,n,init,merge_func=min,ide_ele=10**18):
self.n=(n-1).bit_length()
self.merge_func=merge_func
self.ide_ele=ide_ele
self.data=[0 for i in range(1<<(self.n+1))]
self.lazy=[0 for i in range(1<<(self.n+1))]
for i in range(n):
self.data[2**self.n+i]=init[i]
for i in range(2**self.n-1,0,-1):
self.data[i]=self.merge_func(self.data[2*i],self.data[2*i+1])
def propagate_above(self,i):
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
add=self.lazy[v]
self.lazy[v]=0
self.data[2*v]+=add
self.data[2*v+1]+=add
self.lazy[2*v]+=add
self.lazy[2*v+1]+=add
def remerge_above(self,i):
while i:
i>>=1
self.data[i]=self.merge_func(self.data[2*i],self.data[2*i+1])+self.lazy[i]
def update(self,l,r,x):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
while l<r:
self.data[l]+=x*(l&1)
self.lazy[l]+=x*(l&1)
l+=(l&1)
self.data[r-1]+=x*(r&1)
self.lazy[r-1]+=x*(r&1)
l>>=1
r>>=1
self.remerge_above(l0)
self.remerge_above(r0)
def query(self,l,r):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
self.propagate_above(l0)
self.propagate_above(r0)
res=self.ide_ele
while l<r:
if l&1:
res=self.merge_func(res,self.data[l])
l+=1
if r&1:
res=self.merge_func(res,self.data[r-1])
l>>=1
r>>=1
return res
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=list(map(int,input().split()))
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegmentTree(M+2,init)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r+1,-1)
m=LST.query(l+1,M+2)+l
add=min(m,add)
print((max(-add,0))) | p03686 |
def solve():
from collections import deque
def dfs(start, turn=False):
path = deque()
path.append(start)
bridge_lengths = deque()
bridge_lengths.append(0)
unvisited = [True] * (n + 1)
unvisited[start] = False
rest = core_islands_num - 1
diameter = 0
end_point = start
while True:
u = path[-1]
for i, d in adj_list[u]:
if unvisited[i]:
path.append(i)
unvisited[i] = False
rest -= 1
bridge_lengths.append(d)
break
else:
distance = sum(bridge_lengths)
if diameter < distance:
diameter = distance
end_point = u
if rest == 0:
break
path.pop()
bridge_lengths.pop()
if turn:
return diameter
else:
return end_point
import sys
file_input = sys.stdin
while True:
n = int(file_input.readline())
if n == 0:
break
p = list(map(int, file_input.readline().split()))
d = list(map(int, file_input.readline().split()))
end_bridges_weight = 0
core_islands_num = n
adj_list = [[] for i in range(n + 1)]
s = 1
for i1, i2, b_l in zip(list(range(2, n + 1)), p, d):
if i1 not in p[i1-1:]:
end_bridges_weight += b_l
core_islands_num -= 1
else:
s = i1
adj_list[i1].append((i2, b_l))
adj_list[i2].append((i1, b_l))
if p.count(1) == 1:
del adj_list[2][0]
end_bridges_weight += d[0]
core_islands_num -= 1
e = dfs(s)
dm = dfs(e, turn=True)
ans = sum(d) * 3 - end_bridges_weight * 2 - dm
print(ans)
solve()
| def solve():
from collections import deque
def bfs(start):
q = deque()
q.append(start)
unvisited = [True] * (n + 1)
unvisited[start] = False
distances = [0] * (n + 1)
while q:
x = q.popleft()
for i, d in adj_list[x]:
if unvisited[i]:
q.append(i)
unvisited[i] = False
distances[i] = distances[x] + d
max_d = max(distances)
return (distances.index(max_d), max_d)
import sys
file_input = sys.stdin
while True:
n = int(file_input.readline())
if n == 0:
break
p = list(map(int, file_input.readline().split()))
d = list(map(int, file_input.readline().split()))
end_bridges_weight = 0
adj_list = [[] for i in range(n + 1)]
s = 0
for i1, i2, b_l in zip(list(range(2, n + 1)), p, d):
if i1 not in p[i1-1:]:
end_bridges_weight += b_l
else:
s = i1
adj_list[i1].append((i2, b_l))
adj_list[i2].append((i1, b_l))
if p.count(1) == 1:
del adj_list[2][0]
end_bridges_weight += d[0]
e, dm = bfs(s)
e, dm = bfs(e)
ans = sum(d) * 3 - end_bridges_weight * 2 - dm
print(ans)
solve()
| p00777 |
m, f, b = list(map(int, input().split()))
print(("NA" if m+f < b else max(0, b-m))) | m, f, b = list(map(int, input().split()))
print(("NA"*(m+f < b) + (m+f >= b)*str(max(0, b-m)))) | p00353 |
def solve(string):
x, _, *p = list(map(int, string.split()))
for i in range(101):
if x - i not in p:
return str(x - i)
if x + i not in p:
return str(x + i)
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| x, n = list(map(int, input().split()))
if n != 0:
l = list(map(int, input().split()))
else:
l = []
diff = 10**10
ans = 10**10
for i in range(102):
if i in l:
continue
else:
if abs(x-i) < diff:
ans = i
diff = abs(x-i)
print(ans)
| p02641 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
X, N = LI()
p = LI()
ans = X
for i in range(2 * N):
if X - i not in p:
ans = X -i
break
if X + i not in p:
ans = X + i
break
print(ans)
| # encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
X, N = LI()
p = LI()
ans = mod
for i in range(100):
if X - i not in p:
ans = X - i
break
if X + i not in p:
ans = X + i
break
print(ans)
| p02641 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X, N, *P = list(map(int, read().split()))
nums = list(range(-10, 110))
for p in P:
nums.remove(p)
answer = min(nums, key=lambda x: (abs(x - X), x))
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X, N, *P = list(map(int, read().split()))
se = frozenset(P)
def gen_nums(X):
low, high = X-1, X
while True:
yield high
yield low
low, high = low-1, high+1
for x in gen_nums(X):
if x not in se:
break
print(x)
| p02641 |
def LI():return list(map(int,input().split()))
def MI():return list(map(int,open(0).read().split()))
def I():return int(eval(input()))
def yes():print("Yes")
def no():print("No")
# from collections import deque, Counter
# from heapq import heappop, heappush
INF=float("inf")
# import math
# pi=math.pi
# import numpy as np
x,n=LI()
if n==0:
print(x)
exit()
p=LI()
p.sort()
ans=-1
tmp=INF
for i in range(-100,200):
if i in p:continue
k=abs(i-x)
if k<tmp:
tmp=k
ans=i
# print(i,k,ans)
print(ans)
| x,n=map(int,input().split())
if n==0:exit(print(x))
p=list(map(int,input().split()))
ans=-1
tmp=float("inf")
for i in range(0,102):
if i in p:
continue
k=abs(i-x)
if k<tmp:
ans=i
tmp=k
print(ans)
| p02641 |
x,n,*p=list(map(int,open(0).read().split()))
p=set(p)
l=r=x
while 1:
if l not in p: print(l); break
l-=1
if r not in p: print(r); break
r+=1 | x,n,*p=list(map(int,open(0).read().split()))
l=r=x
while 1:
if l not in p: print(l); break
l-=1
if r not in p: print(r); break
r+=1 | p02641 |
x,n,*l=list(map(int,open(0).read().split()))
print((min((abs(i-x),i) for i in range(102) if i not in l)[1])) | x,_,*l=list(map(int,open(0).read().split()))
print((min((abs(i-x),i) for i in {*list(range(102))}-{*l})[1])) | p02641 |
x,n=[int(x) for x in input().split()]
if n==0:
print(x)
else:
p=[int(x) for x in input().split()]
ans=[]
Flag=False
while ans==[]:
for i in range(105):
if x-i not in p:
ans.append(x-i)
Flag=True
break
elif x+i not in p:
ans.append(x+i)
Flag=True
break
if Flag:
break
print((min(ans))) | x,n=[int(x) for x in input().split()]
if n!=0:
p=[int(x) for x in input().split()]
l=list(range(110))
for i in p:
l.remove(i)
L=[]
for i in l:
L.append(abs(i-x))
m=min(L)
print((l[L.index(m)]))
else:
print(x) | p02641 |
X,N=list(map(int,input().split()))
if N>0:p=list(map(int,input().split()))
else:p=[]
memo=[False for i in range(105)]
for i in range(N):memo[p[i]]=True
riget=X+1
left=X-1
ans_r=0
ans_l=0
while(True):
if memo[X]==False:
ans_r=X
break
if memo[riget]==False:
ans_r=riget
break
riget+=1
while(True):
if memo[X]==False:
ans_l=X
break
if memo[left]==False:
ans_l=left
break
left-=1
if N==0:print(X)
elif abs(X-ans_r)>=abs(X-ans_l):print(ans_l)
else:print(ans_r)
| X,N=list(map(int,input().split()))
if N>0:p=list(map(int,input().split()))
else:p=[]
memo=[False for i in range(105)]
for i in range(N):memo[p[i]]=True
riget,left=X+1,X-1
ans_r,ans_l=0,0
while(True):
if memo[left]==False:
ans_l=left
break
if memo[riget]==False:
ans_r=riget
break
left-=1
riget+=1
if N==0 or memo[X]==False:print(X)
elif abs(X-ans_r)>=abs(X-ans_l):print(ans_l)
else:print(ans_r)
| p02641 |
X,N = list(map(int,input().split()))
min = 100
if N !=0:
Plist = list(map(int,input().split()))
anslist = [i for i in range(201)]
anslist.append(-1)
#anslist.remove(0)
Plist = sorted(Plist)
for i in range(N):
anslist.remove(Plist[i])
temp =100
for i in range(len(anslist)):
if min >abs(anslist[i]-X) :
min = abs(anslist[i]-X)
temp = anslist[i]
print (temp)
else :
print (X) | X,N = list(map(int,input().split()))
min = 100
if N !=0:
Plist = list(map(int,input().split()))
anslist = [i for i in range(102)]
anslist.append(-1)
#anslist.remove(0)
Plist = sorted(Plist)
#print (anslist)
for i in range(N):
anslist.remove(Plist[i])
temp =100
for i in range(len(anslist)):
if min >abs(anslist[i]-X) :
min = abs(anslist[i]-X)
temp = anslist[i]
print (temp)
else :
print (X) | p02641 |
x, n = list(map(int, input().split()))
s = set(list(map(int, input().split())) if n != 0 else "")
i = 0
while True:
k = x + i
if k not in s:
print(k)
break
if i >= 0: i += 1
i *= -1
| x, n = list(map(int, input().split()))
s = set(list(map(int, input().split())) if n != 0 else "")
i = 0
while x + i in s:
if i >= 0: i += 1
i *= -1
print((x + i))
| p02641 |
x,n=list(map(int,input().split()))
if n==0:
print(x)
else:
p=list(map(int,input().split()))
dic={}
for i in p:
d=abs(i-x)
if d in dic:
dic[d].append(i)
else:
dic[d]=[i]
sortdic = sorted(list(dic.items()), key=lambda x:x[0])
chk=0
ans=-1
for k,v in sortdic:
if chk==k:
if chk!=0 and len(v)!=2:
if v[0]>x:
ans=x-k
else:
ans=x+k
break
else:
ans=x-chk
break
chk+=1
if ans==-1:
ans=x-chk
print(ans) | x,y=list(map(int,input().split()))
if y==0:
print(x)
exit()
p=list(map(int,input().split()))
for i in range(200):
if not x-i in p:
print((x-i))
exit()
if not x+i in p:
print((x+i))
exit() | p02641 |
X, N = input().split()
X = int(X)
N = int(N)
if N == 0:
print(X)
exit()
P = input().split()
for i in range(len(P)):
P[i] = int(P[i])
if X not in P:
print(X)
exit()
flag_p = True
flag_n = True
abs_num = 0
abs_num_p = X + 1
abs_num_n = X - 1
while True:
if abs_num_p in P:
flag_p = True
else:
flag_p = False
if abs_num_n in P:
flag_n = True
else:
flag_n = False
if(flag_p == True & flag_n == True):
abs_num_p += 1
abs_num_n -= 1
continue;
elif(flag_p == True & flag_n == False):
print(abs_num_n)
break;
elif(flag_p == False):
print(abs_num_p)
break;
| X, N = input().split()
X = int(X)
N = int(N)
if N == 0:
print(X)
exit()
P = input().split()
for i in range(len(P)):
P[i] = int(P[i])
if X not in P:
print(X)
exit()
abs_num_p = X + 1
abs_num_n = X - 1
while True:
if abs_num_p in P:
flag_p = True
else:
flag_p = False
if abs_num_n in P:
flag_n = True
else:
flag_n = False
if( flag_p == True and flag_n == True ):
abs_num_p += 1
abs_num_n -= 1
continue;
elif(flag_p == True and flag_n == False):
print(abs_num_n)
break;
elif(flag_p == False and flag_n == True ):
print(abs_num_p)
break;
elif(flag_p == False and flag_n == False):
print(abs_num_n)
break;
i += 1
| p02641 |
X, N = list(map(int, input().split()))
if N == 0:
ans = X
else:
p = list(map(int, input().split()))
ans = 0
for i in range(200):
if i in p:
continue
else:
dis = i - X
if dis < abs(ans - X):
ans = i
print(ans) | X, N = list(map(int, input().split()))
if N == 0:
ans = X
else:
p = list(map(int, input().split()))
ans = 0
for i in range(200):
if i in p:
continue
else:
dis = abs(i - X)
if dis < abs(ans - X):
ans = i
print(ans)
| p02641 |
x, n = list(map(int, input().split(' ')))
min_num = 100
ls = [0] * 201
for i in range(0, 201):
ls[i] = i
ls_in = [0] * n
if n > 0:
ls_in = list(map(int, input().split(' ')))
for i in ls_in:
ls.remove(i)
ls.reverse()
for i in ls:
min_num = min(abs(x-i), min_num)
if abs(x-i) == min_num:
ans = i
print(ans)
else:
print(x) | x, n = list(map(int, input().split(' ')))
diff = x
result = 0
if n != 0:
ls = list(map(int, input().split(' ')))
ls_remaind = []
for i in range(1, 102):
if i not in ls:
ls_remaind.append(i)
for j in ls_remaind:
if abs(x-j) == diff:
result = min(result, j)
elif abs(x-j) < diff:
diff = abs(x-j)
result = j
else:
result = x
print(result) | p02641 |
x, n = list(map(int, input().split(' ')))
diff = x
result = 0
if n != 0:
ls = list(map(int, input().split(' ')))
ls_remaind = []
for i in range(1, 102):
if i not in ls:
ls_remaind.append(i)
for j in ls_remaind:
if abs(x-j) == diff:
result = min(result, j)
elif abs(x-j) < diff:
diff = abs(x-j)
result = j
else:
result = x
print(result) | X, N = list(map(int, input().split(' ')))
if N == 0:
print(X)
else:
P_ls = list(map(int, input().split(' ')))
P_ls.sort(reverse=True)
diff = -1
for i in range(101, -1, -1):
if i not in P_ls:
if diff == -1:
diff = abs(X - i)
rst = i
else:
diff = min(diff, abs(X - i))
if diff == abs(X-i):
rst = i
print(rst) | p02641 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.