input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import bisect
import itertools
import sys
A, B, Q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(A)]
t = [int(eval(input())) for _ in range(B)]
X = [int(eval(input())) for _ in range(Q)]
def most_simRL(ds, x):
index = bisect.bisect_left(ds, x)
if index == 0:
return [ds[0]]
elif index == len(ds):
return [ds[-1]]
return ds[index-1:index+1]
def calc(a, b, x):
return min(abs(a-x), abs(b-x)) + abs(a-b)
for x in X:
s_RL = most_simRL(s, x)
t_RL = most_simRL(t, x)
ans = sys.maxsize
for st in itertools.product(s_RL, t_RL):
ans = min(ans, calc(st[0], st[1], x))
print(ans)
|
import bisect
import itertools
import sys
A, B, Q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(A)]
t = [int(eval(input())) for _ in range(B)]
X = [int(eval(input())) for _ in range(Q)]
def most_simRL(ds, x):
index = bisect.bisect_left(ds, x)
if index == 0:
return [ds[0]]
elif index == len(ds):
return [ds[-1]]
return ds[index-1:index+1]
for x in X:
s_RL = most_simRL(s, x)
t_RL = most_simRL(t, x)
ans = sys.maxsize
for a, b in itertools.product(s_RL, t_RL):
ans = min(ans, min(abs(a-x), abs(b-x)) + abs(a-b))
print(ans)
|
p03112
|
from bisect import bisect_left
from itertools import product
a, b, q = [int(i) for i in input().split()]
s_list = [int(eval(input())) for _ in range(a)]
t_list = [int(eval(input())) for _ in range(b)]
n_list = [a, b]
s_t_list = [s_list, t_list]
for _ in range(q):
x = int(eval(input()))
temp_s_t_list = [[10 ** 11] * 2, [10 ** 11] * 2]
for i in range(2):
xi = bisect_left(s_t_list[i], x)
if xi < n_list[i]:
temp_s_t_list[i][0] = s_t_list[i][xi] - x
if xi > 0:
temp_s_t_list[i][1] = s_t_list[i][xi - 1] - x
temp_list = []
for s_x, t_x in list(product(temp_s_t_list[0], temp_s_t_list[1])):
temp_s_x = s_x
s_x = abs(s_x)
temp_t_x = t_x
t_x = abs(t_x)
if temp_s_x // s_x == temp_t_x // t_x:
temp_list.append(max(s_x, t_x))
else:
temp_list.append(s_x + t_x + min(s_x, t_x))
print((min(temp_list)))
|
from bisect import bisect_left
a, b, q = [int(i) for i in input().split()]
s_list = [int(eval(input())) for _ in range(a)]
t_list = [int(eval(input())) for _ in range(b)]
for _ in range(q):
x = int(eval(input()))
temp_s_t_list = [10 ** 11] * 4
si = bisect_left(s_list, x)
if si < a:
temp_s_t_list[0] = s_list[si] - x
if si > 0:
temp_s_t_list[1] = s_list[si - 1] - x
ti = bisect_left(t_list, x)
if ti < b:
temp_s_t_list[2] = t_list[ti] - x
if ti > 0:
temp_s_t_list[3] = t_list[ti - 1] - x
ans = 10 ** 11 * 3
for s_x, t_x in [(temp_s_t_list[0], temp_s_t_list[2]), (temp_s_t_list[0], temp_s_t_list[3]), (temp_s_t_list[1], temp_s_t_list[2]), (temp_s_t_list[1], temp_s_t_list[3])]:
temp_s_x = s_x
s_x = abs(s_x)
temp_t_x = t_x
t_x = abs(t_x)
if temp_s_x // s_x == temp_t_x // t_x:
temp = max(s_x, t_x)
else:
temp = s_x + t_x + min(s_x, t_x)
if ans > temp:
ans = temp
print(ans)
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = float('inf')
s = [-INF] + [int(eval(input())) for _ in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for _ in range(B)] + [INF]
for q in range(Q):
x = int(eval(input()))
b,d = bisect.bisect_right(s,x), bisect.bisect_right(t,x)
res = INF
for S in [s[b-1], s[b]]:
for T in [t[d-1], t[d]]:
d1, d2 = abs(S-x) + abs(T-S), abs(T-x) + abs(S-T)
res = min(res, d1,d2)
print(res)
|
from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
INF = float('inf')
S = [-INF] + list(int(eval(input())) for _ in range(A)) + [INF]
T = [-INF] + list(int(eval(input())) for _ in range(B)) + [INF]
for _ in range(Q):
x = int(eval(input()))
i = bisect_right(S,x)
j = bisect_right(T,x)
d = INF
for s in [S[i-1], S[i]]:
for t in [T[j-1], T[j]]:
d1 = abs(s-x) + abs(s-t)
d2 = abs(t-x) + abs(s-t)
d = min(d, d1, d2)
print(d)
|
p03112
|
import bisect
A, B, Q = [int(_) for _ in input().split()]
S = [int(eval(input())) for _ in range(A)]
T = [int(eval(input())) for _ in range(B)]
X = [int(eval(input())) for _ in range(Q)]
for x in X:
i_sl = bisect.bisect_left(S, x)
i_tl = bisect.bisect_left(T, x)
D_sr = D_sl = D_tl = D_tr = float('inf')
if i_sl < A:
D_sl = S[i_sl] - x
if i_tl < B:
D_tl = T[i_tl] - x
if i_sl:
D_sr = x - S[i_sl - 1]
if i_tl:
D_tr = x - T[i_tl - 1]
print((
min([
max(D_sl, D_tl),
max(D_sr, D_tr),
min(D_sl, D_tr) + D_tr + D_sl,
min(D_tl, D_sr) + D_sr + D_tl
])))
|
import bisect
INF = float('inf')
A, B, Q = [int(_) for _ in input().split()]
S = [-INF] + [int(eval(input())) for _ in range(A)] + [INF]
T = [-INF] + [int(eval(input())) for _ in range(B)] + [INF]
X = [int(eval(input())) for _ in range(Q)]
for x in X:
i_sl = bisect.bisect_left(S, x)
i_tl = bisect.bisect_left(T, x)
D_sl = S[i_sl] - x
D_tl = T[i_tl] - x
D_sr = x - S[i_sl - 1]
D_tr = x - T[i_tl - 1]
print((
min([
max(D_sl, D_tl),
max(D_sr, D_tr),
min(D_sl, D_tr) + D_tr + D_sl,
min(D_tl, D_sr) + D_sr + D_tl
])))
|
p03112
|
a,b,q = list(map(int,input().split()))
s = [int(eval(input())) for i in range(0,a)]
t = [int(eval(input())) for i in range(0,b)]
x = [int(eval(input())) for i in range(0,q)]
s.sort()
t.sort()
def bifind(r,z):
y = len(r)//2
halftime = 2
if z < r[0]:
return [r[0],r[0]]
elif z > r[-1]:
return [r[-1],r[-1]]
while True:
if r[y] <= z:
y += len(r)//(2**halftime)+1
else:
y -= len(r)//(2**halftime)+1
halftime += 1
if y+1 >= len(r):
y = len(r)-2
if y < 0:
y = 0
if r[y] < z < r[y+1]:
break
return [r[y],r[y+1]]
for i in range(0,q):
ls = bifind(s,x[i])
lt = bifind(t,x[i])
ans = list()
for j in range(0,2):
for k in range(0,2):
ans.append(abs(ls[j]-x[i])+abs(lt[k]-ls[j]))
ans.append(abs(lt[k]-x[i])+abs(lt[k]-ls[j]))
print((min(ans)))
|
a,b,q = list(map(int,input().split()))
s = [int(eval(input())) for i in range(0,a)]
t = [int(eval(input())) for i in range(0,b)]
x = [int(eval(input())) for i in range(0,q)]
s.sort()
t.sort()
def bifind(r,z):
low = 0
high = len(r)-1
y = (low + high)//2
if z < r[0]:
return [r[0],r[0]]
elif z > r[-1]:
return [r[-1],r[-1]]
while True:
if r[y] <= z:
low = y
y = (y+high)//2
else:
high = y
y = (low + y)//2
if r[y] < z < r[y+1]:
break
return [r[y],r[y+1]]
for i in range(0,q):
ls = bifind(s,x[i])
lt = bifind(t,x[i])
ans = list()
for j in range(0,2):
for k in range(0,2):
ans.append(abs(ls[j]-x[i])+abs(lt[k]-ls[j]))
ans.append(abs(lt[k]-x[i])+abs(lt[k]-ls[j]))
print((min(ans)))
|
p03112
|
A,B,Q=list(map(int, input().split()))
S=[int(eval(input())) for _ in range(A)]
T=[int(eval(input())) for _ in range(B)]
X=[int(eval(input())) for _ in range(Q)]
import bisect
def solve(x):
sr=bisect.bisect_right(S,x)
tr=bisect.bisect_right(T,x)
sl=sr-1
tl=tr-1
ret=10**12
if sl>=0 and tl>=0:
ret=min(ret,x-min(S[sl],T[tl]))
if sr<A and tl>=0:
ret=min(ret,S[sr]-T[tl]+min(S[sr]-x,x-T[tl]))
if sl>=0 and tr<B:
ret=min(ret,T[tr]-S[sl]+min(T[tr]-x,x-S[sl]))
if sr<A and tr<B:
ret=min(ret,max(S[sr],T[tr])-x)
return ret
for x in X:
print((solve(x)))
|
import sys
input = sys.stdin.readline
A,B,Q=list(map(int, input().split()))
S=[int(eval(input())) for _ in range(A)]
T=[int(eval(input())) for _ in range(B)]
X=[int(eval(input())) for _ in range(Q)]
import bisect
def solve(x):
sr=bisect.bisect_right(S,x)
tr=bisect.bisect_right(T,x)
sl=sr-1
tl=tr-1
ret=10**12
if sl>=0 and tl>=0:
ret=min(ret,x-min(S[sl],T[tl]))
if sr<A and tl>=0:
ret=min(ret,S[sr]-T[tl]+min(S[sr]-x,x-T[tl]))
if sl>=0 and tr<B:
ret=min(ret,T[tr]-S[sl]+min(T[tr]-x,x-S[sl]))
if sr<A and tr<B:
ret=min(ret,max(S[sr],T[tr])-x)
return ret
for x in X:
print((solve(x)))
|
p03112
|
import sys
def main():
input = sys.stdin.readline
A,B,Q=list(map(int, input().split()))
S=[int(eval(input())) for _ in range(A)]
T=[int(eval(input())) for _ in range(B)]
X=[int(eval(input())) for _ in range(Q)]
from bisect import bisect_left
INF=10**11
S=[-INF] + S + [INF]
T=[-INF] + T + [INF]
for x in X:
sr = bisect_left(S, x)
tr = bisect_left(T, x)
sl,tl=sr-1,tr-1
ans=INF
ans = min(ans, abs(S[sl]-T[tl]) + min(abs(S[sl]-x), abs(T[tl]-x)))
ans = min(ans, abs(S[sl]-T[tr]) + min(abs(S[sl]-x), abs(T[tr]-x)))
ans = min(ans, abs(S[sr]-T[tl]) + min(abs(S[sr]-x), abs(T[tl]-x)))
ans = min(ans, abs(S[sr]-T[tr]) + min(abs(S[sr]-x), abs(T[tr]-x)))
print(ans)
if __name__ == '__main__':
main()
|
from bisect import bisect_left
import sys
def main():
input = sys.stdin.readline
A, B, Q = list(map(int, input().split()))
S = [int(eval(input())) for _ in range(A)]
T = [int(eval(input())) for _ in range(B)]
X = [int(eval(input())) for _ in range(Q)]
INF = 10 ** 11
S = [-INF] + S + [INF]
T = [-INF] + T + [INF]
for x in X:
i = bisect_left(S, x)
ls = x - S[i - 1]
rs = S[i] - x
j = bisect_left(T, x)
lt = x - T[j - 1]
rt = T[j] - x
print((min(max(ls, lt), max(rs, rt), 2 * ls + rt, ls + 2 * rt, 2 * rs + lt, rs + 2 * lt)))
if __name__ == '__main__':
main()
|
p03112
|
from bisect import bisect_left
a,b,q,*stx = list(map(int,open(0).read().split()))
s = [-1e10] + stx[:a] + [2*1e10]
t = [-1e10] + stx[a:-q] + [2*1e10]
x = stx[-q:]
for i in x:
pos_s = bisect_left(s,i)
pos_t = bisect_left(t,i)
sl = s[pos_s-1]; sr = s[pos_s]
tl = t[pos_t-1]; tr = t[pos_t]
ans = min( i-min(sl,tl), max(sr,tr)-i, (sr*2-i-tl), (tr*2-i-sl), (i+tr-sl*2), (i+sr-tl*2) )
print(ans)
|
from bisect import bisect
def main():
a,b,q,*stx = list(map(int,open(0).read().split()))
s = [-1e10] + stx[:a] + [2*1e10]
t = [-1e10] + stx[a:a+b] + [2*1e10]
x = stx[a+b:a+b+q]
for i in x:
pos_s = bisect(s,i)
pos_t = bisect(t,i)
sl = s[pos_s-1]; sr = s[pos_s]
tl = t[pos_t-1]; tr = t[pos_t]
ans = min( i-min(sl,tl), max(sr,tr)-i, (sr-i) + (sr-tl), (tr-i) + (tr-sl), (i-sl) + (tr-sl), (i-tl) + (sr-tl) )
print(ans)
if __name__ == '__main__':
main()
|
p03112
|
import bisect
a,b,q=list(map(int,input().split()))
s = []
t = []
for i in range(a):
s.append(int(eval(input())))
for i in range(b):
t.append(int(eval(input())))
for _ in range(q):
x = int(eval(input()))
ans = [0,0,0]
if x in s:
sl = 0
sr = 0
else:
i = bisect.bisect_left(s,x)
if i == 0:
sl = 100000000000
else:
sl = abs(s[i-1]-x)
if i == a:
sr = 100000000000
else:
sr = abs(s[i]-x)
if x in t:
tl = 0
tr = 0
else:
i = bisect.bisect_left(t,x)
if i == 0:
tl = 100000000000
else:
tl = abs(t[i-1]-x)
if i == b:
tr = 100000000000
else:
tr = abs(t[i]-x)
ans[0] = max(tl,sl)
ans[1] = max(tr,sr)
ans[2] = min(2*tl+sr,2*sl+tr,2*sr+tl,2*tr+sl)
print((min(ans)))
|
import bisect
a,b,q=list(map(int,input().split()))
s = []
t = []
for i in range(a):
s.append(int(eval(input())))
for i in range(b):
t.append(int(eval(input())))
for _ in range(q):
x = int(eval(input()))
ans = [0,0,0]
i = bisect.bisect_left(s,x)
if i == 0:
sl = 100000000000
else:
sl = abs(s[i-1]-x)
if i == a:
sr = 100000000000
else:
sr = abs(s[i]-x)
i = bisect.bisect_left(t,x)
if i == 0:
tl = 100000000000
else:
tl = abs(t[i-1]-x)
if i == b:
tr = 100000000000
else:
tr = abs(t[i]-x)
ans[0] = max(tl,sl)
ans[1] = max(tr,sr)
ans[2] = min(2*tl+sr,2*sl+tr,2*sr+tl,2*tr+sl)
print((min(ans)))
|
p03112
|
from itertools import product
from bisect import bisect_left, bisect_right
def main():
A, B, Q = map(int, input().split())
ss = [int(input()) for _ in range(A)]
ts = [int(input()) for _ in range(B)]
xs = [int(input()) for _ in range(Q)]
# gen = TLE(A, B, Q, ss, ts, xs)
gen = f(A, B, Q, ss, ts, xs)
print(*gen, sep="\n")
def TLE(A, B, Q, ss, ts, xs):
for x in xs:
ans = float("inf")
for s in ss:
for t in ts:
if s <= x <= t or t <= x <= s:
ds, dt = abs(x-s), abs(x-t)
tmp = min(ds, dt) + abs(s-t)
elif x <= s <= t or x <= t <= s:
tmp = max(s, t)-x
elif x >= s >= t or x >= t >= s:
tmp = x-min(s, t)
ans = min(ans, tmp)
yield ans
def f_ans(s, t, x):
if s <= x <= t or t <= x <= s:
ds, dt = abs(x-s), abs(x-t)
tmp = min(ds, dt) + abs(s-t)
elif x <= s <= t or x <= t <= s:
tmp = max(s, t)-x
elif x >= s >= t or x >= t >= s:
tmp = x-min(s, t)
return tmp
def f(A, B, Q, ss, ts, xs):
for x in xs:
t_left = bisect_left(ts, x)
t_right = bisect_right(ts, x)
s_left = bisect_left(ss, x)
s_right = bisect_right(ss, x)
t_idx = [t_right + a for a in [-1, 0, 1]]
t_idx += [t_left + a for a in [-1, 0, 1]]
s_idx = [s_right + a for a in [-1, 0, 1]]
s_idx += [s_left + a for a in [-1, 0, 1]]
ans = float("inf")
for si, ti in product(set(s_idx), set(t_idx)):
if 0 <= si < A and 0 <= ti < B:
tmp = f_ans(ss[si], ts[ti], x)
ans = min(ans, tmp)
yield ans
if __name__ == "__main__":
main()
|
from itertools import product
from bisect import bisect_left, bisect_right
def main():
A, B, Q = map(int, input().split())
ss = [int(input()) for _ in range(A)]
ts = [int(input()) for _ in range(B)]
xs = [int(input()) for _ in range(Q)]
# gen = TLE(A, B, Q, ss, ts, xs)
# gen = f(A, B, Q, ss, ts, xs)
gen = editorial(A, B, Q, ss, ts, xs)
print(*gen, sep="\n")
def TLE(A, B, Q, ss, ts, xs):
for x in xs:
ans = float("inf")
for s in ss:
for t in ts:
if s <= x <= t or t <= x <= s:
ds, dt = abs(x-s), abs(x-t)
tmp = min(ds, dt) + abs(s-t)
elif x <= s <= t or x <= t <= s:
tmp = max(s, t)-x
elif x >= s >= t or x >= t >= s:
tmp = x-min(s, t)
ans = min(ans, tmp)
yield ans
def f_ans(s, t, x):
if s <= x <= t or t <= x <= s:
ds, dt = abs(x-s), abs(x-t)
tmp = min(ds, dt) + abs(s-t)
elif x <= s <= t or x <= t <= s:
tmp = max(s, t)-x
elif x >= s >= t or x >= t >= s:
tmp = x-min(s, t)
return tmp
def f(A, B, Q, ss, ts, xs):
for x in xs:
t_left = bisect_left(ts, x)
t_right = bisect_right(ts, x)
s_left = bisect_left(ss, x)
s_right = bisect_right(ss, x)
t_idx = [t_right + a for a in [-1, 0, 1]]
t_idx += [t_left + a for a in [-1, 0, 1]]
s_idx = [s_right + a for a in [-1, 0, 1]]
s_idx += [s_left + a for a in [-1, 0, 1]]
ans = float("inf")
for si, ti in product(set(s_idx), set(t_idx)):
if 0 <= si < A and 0 <= ti < B:
tmp = f_ans(ss[si], ts[ti], x)
ans = min(ans, tmp)
yield ans
def editorial(A, B, Q, ss, ts, xs):
INF = float("inf")
# 番兵
ss = [-INF] + ss + [INF]
ts = [-INF] + ts + [INF]
for x in xs:
# -inf の右 [1]
# +inf の左 [-1]
b, d = bisect_right(ss, x), bisect_right(ts, x)
ans = INF
# 番兵のおかげでindex を気にしなくて良い
for s in [ss[b - 1], ss[b]]:
for t in [ts[d - 1], ts[d]]:
# s--t--x, t--s--x
# s--x--t, t--x--s
# x--t--s, x--s--t
d1 = abs(s - x) + abs(t - s)
d2 = abs(t - x) + abs(s - t)
ans = min(ans, d1, d2)
yield ans
if __name__ == "__main__":
main()
|
p03112
|
import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().split()])
# ===CODE===
def disLR(a, idx):
small = a[max(0, idx - 1)]
large = a[min(len(a) - 1, idx)]
return small, large
def main():
a, b, q = ns()
s = [ni() for _ in range(a)]
t = [ni() for _ in range(b)]
for _ in range(q):
ans = INF
x = ni()
tmpans = [0] * 4
idxs = bisect.bisect_left(s, x)
sml, lrg = disLR(s, idxs)
tmpans[0] += abs(x - sml)
tmpans[1] += abs(x - lrg)
idxsml = bisect.bisect_left(t, sml)
tmpans[0] += min([abs(sml - i) for i in disLR(t, idxsml)])
idxlrg = bisect.bisect_left(t, lrg)
tmpans[1] += min([abs(lrg - i) for i in disLR(t, idxlrg)])
idxt = bisect.bisect_left(t, x)
sml, lrg = disLR(t, idxt)
tmpans[2] += abs(x - sml)
tmpans[3] += abs(x - lrg)
idxsml = bisect.bisect_left(s, sml)
tmpans[2] += min([abs(sml - i) for i in disLR(s, idxsml)])
idxlrg = bisect.bisect_left(s, lrg)
tmpans[3] += min([abs(lrg - i) for i in disLR(s, idxlrg)])
ans = min(ans, min(tmpans))
print(ans)
if __name__ == '__main__':
main()
|
import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().split()])
# ===CODE===
def disLR(a, idx):
small = a[max(0, idx - 1)]
large = a[min(len(a) - 1, idx)]
return [small, large]
def main():
a, b, q = ns()
s = [ni() for _ in range(a)]
t = [ni() for _ in range(b)]
for _ in range(q):
ans = INF
x = ni()
idxs = bisect.bisect_left(s, x)
a1 = disLR(s, idxs)
idxt = bisect.bisect_left(t, x)
a2 = disLR(t, idxt)
for ta1 in a1:
for ta2 in a2:
tmp1 = abs(x - ta1) + abs(ta2 - ta1)
tmp2 = abs(x - ta2) + abs(ta1 - ta2)
ans = min(ans, tmp1, tmp2)
print(ans)
if __name__ == '__main__':
main()
|
p03112
|
import bisect
a, b, q = list(map(int, input().split()))
ss = sorted([int(eval(input())) for _ in range(a)])
ts = sorted([int(eval(input())) for _ in range(b)])
xs = [int(eval(input())) for _ in range(q)]
for x in xs:
sindex = bisect.bisect(ss, x)
if sindex == 0:
sl = float('inf')
sr = ss[sindex] - x
elif sindex == a:
sl = x - ss[sindex - 1]
sr = float('inf')
else:
sl = x - ss[sindex - 1]
sr = ss[sindex] - x
tindex = bisect.bisect(ts, x)
if tindex == 0:
tl = float('inf')
tr = ts[tindex] - x
elif tindex == b:
tl = x - ts[tindex - 1]
tr = float('inf')
else:
tl = x - ts[tindex - 1]
tr = ts[tindex] - x
print((
min([
max(sl, tl),
max(sr, tr),
2 * sl + tr,
2 * tl + sr,
2 * sr + tl,
2 * tr + sl,
])))
|
import bisect
a, b, q = list(map(int, input().split()))
ss = sorted([int(eval(input())) for _ in range(a)] + [float('inf'), -float('inf')])
ts = sorted([int(eval(input())) for _ in range(b)] + [float('inf'), -float('inf')])
xs = [int(eval(input())) for _ in range(q)]
for x in xs:
sindex = bisect.bisect(ss, x)
sl = x - ss[sindex - 1]
sr = ss[sindex] - x
tindex = bisect.bisect(ts, x)
tl = x - ts[tindex - 1]
tr = ts[tindex] - x
print((
min([
max(sl, tl),
max(sr, tr),
2 * sl + tr,
2 * tl + sr,
2 * sr + tl,
2 * tr + sl,
])))
|
p03112
|
from bisect import bisect
num_a,num_b,num_q = list(map(int, input().split(' ')))
lsa = [int(eval(input())) for _ in range(num_a)]
lsb = [int(eval(input())) for _ in range(num_b)]
lsa.sort()
lsb.sort()
# print(lsa)
# print(lsb)
lsq = [int(eval(input())) for _ in range(num_q)]
for ques in lsq:
lower_bound_a = bisect(lsa, ques)
lower_bound_b = bisect(lsb, ques)
upper_bound_a = lower_bound_a - 1
upper_bound_b = lower_bound_b - 1
min_cand = 9223372036854775807
if lower_bound_a < num_a and lower_bound_b < num_b:
min_cand = min(min_cand, max(lsa[lower_bound_a], lsb[lower_bound_b]) - ques)
if upper_bound_a >= 0 and upper_bound_b >= 0:
min_cand = min(min_cand, ques - min(lsa[upper_bound_a], lsb[upper_bound_b]))
if upper_bound_a >= 0 and lower_bound_b < num_b:
min_cand = min(
min_cand,
lsb[lower_bound_b] - ques + lsb[lower_bound_b] - lsa[upper_bound_a],
ques - lsa[upper_bound_a] + lsb[lower_bound_b] - lsa[upper_bound_a],
)
if lower_bound_a < num_a and upper_bound_b >= 0:
min_cand = min(
min_cand,
lsa[lower_bound_a] - ques + lsa[lower_bound_a] - lsb[upper_bound_b],
ques - lsb[upper_bound_b] + lsa[lower_bound_a] - lsb[upper_bound_b],
)
print(min_cand)
|
from bisect import bisect
LONG_MIN = -9223372036854775808
LONG_MAX = 9223372036854775807
num_a,num_b,num_q = list(map(int, input().split(' ')))
lsa = [int(eval(input())) for _ in range(num_a)] + [LONG_MIN, LONG_MAX]
lsb = [int(eval(input())) for _ in range(num_b)] + [LONG_MIN, LONG_MAX]
lsa.sort()
lsb.sort()
lsq = [int(eval(input())) for _ in range(num_q)]
for ques in lsq:
lower_bound_a = bisect(lsa, ques)
lower_bound_b = bisect(lsb, ques)
upper_bound_a = lower_bound_a - 1
upper_bound_b = lower_bound_b - 1
res = min(
max(lsa[lower_bound_a], lsb[lower_bound_b]) - ques,
ques - min(lsa[upper_bound_a], lsb[upper_bound_b]),
lsb[lower_bound_b] - ques + lsb[lower_bound_b] - lsa[upper_bound_a],
ques - lsa[upper_bound_a] + lsb[lower_bound_b] - lsa[upper_bound_a],
lsa[lower_bound_a] - ques + lsa[lower_bound_a] - lsb[upper_bound_b],
ques - lsb[upper_bound_b] + lsa[lower_bound_a] - lsb[upper_bound_b],
)
print(res)
|
p03112
|
A,B,Q=list(map(int,input().split()))
s=[]
t=[]
for i in range(A):
s.append(int(eval(input())))
for i in range(B):
t.append(int(eval(input())))
for i in range(Q):
x=int(eval(input()))
s1=s[:]
s1.append(x)
s1.sort()
j=s1.index(x)
if j==0:
kouhoA=[s[j]]
elif j==A:
kouhoA=[s[j-1]]
else:
kouhoA=[s[j],s[j-1]]
t1=t[:]
t1.append(x)
t1.sort()
k=t1.index(x)
if k==0:
kouhoB=[t[k]]
elif k==B:
kouhoB=[t[k-1]]
else:
kouhoB=[t[k],t[k-1]]
if len(kouhoA)==1:
if len(kouhoB)==1:
a=abs(kouhoA[0]-kouhoB[0])
ans=min([abs(x-kouhoA[0])+a,abs(x-kouhoB[0])+a])
else:
u=abs(x-kouhoA[0])
a=abs(kouhoA[0]-kouhoB[0])
b=abs(kouhoA[0]-kouhoB[1])
ans=min([u+a,abs(x-kouhoB[0])+a,u+b,abs(x-kouhoB[1])+b])
else:
if len(kouhoB)==1:
a=abs(kouhoA[0]-kouhoB[0])
c=abs(kouhoB[0]-kouhoA[1])
v=abs(x-kouhoB[0])
ans=min([abs(x-kouhoA[0])+a,v+a,abs(x-kouhoA[1])+c,v+c])
else:
u=abs(x-kouhoA[0])
a=abs(kouhoA[0]-kouhoB[0])
b=abs(kouhoA[0]-kouhoB[1])
c=abs(kouhoB[0]-kouhoA[1])
d=abs(kouhoA[1]-kouhoB[1])
v=abs(x-kouhoB[0])
w=abs(x-kouhoA[1])
y=abs(x-kouhoB[1])
ans=min([u+a,v+a,w+d,y+d,w+c,v+c,u+b,y+b])
print(ans)
|
import bisect
A,B,Q=list(map(int,input().split()))
s=[]
t=[]
for i in range(A):
s.append(int(eval(input())))
for i in range(B):
t.append(int(eval(input())))
for i in range(Q):
x=int(eval(input()))
j=bisect.bisect_left(s,x)
if j==0:
kouhoA=[s[j]]
elif j==A:
kouhoA=[s[j-1]]
else:
kouhoA=[s[j],s[j-1]]
k=bisect.bisect_left(t,x)
if k==0:
kouhoB=[t[k]]
elif k==B:
kouhoB=[t[k-1]]
else:
kouhoB=[t[k],t[k-1]]
if len(kouhoA)==1:
if len(kouhoB)==1:
a=abs(kouhoA[0]-kouhoB[0])
ans=min([abs(x-kouhoA[0])+a,abs(x-kouhoB[0])+a])
else:
u=abs(x-kouhoA[0])
a=abs(kouhoA[0]-kouhoB[0])
b=abs(kouhoA[0]-kouhoB[1])
ans=min([u+a,abs(x-kouhoB[0])+a,u+b,abs(x-kouhoB[1])+b])
else:
if len(kouhoB)==1:
a=abs(kouhoA[0]-kouhoB[0])
c=abs(kouhoB[0]-kouhoA[1])
v=abs(x-kouhoB[0])
ans=min([abs(x-kouhoA[0])+a,v+a,abs(x-kouhoA[1])+c,v+c])
else:
u=abs(x-kouhoA[0])
a=abs(kouhoA[0]-kouhoB[0])
b=abs(kouhoA[0]-kouhoB[1])
c=abs(kouhoB[0]-kouhoA[1])
d=abs(kouhoA[1]-kouhoB[1])
v=abs(x-kouhoB[0])
w=abs(x-kouhoA[1])
y=abs(x-kouhoB[1])
ans=min([u+a,v+a,w+d,y+d,w+c,v+c,u+b,y+b])
print(ans)
|
p03112
|
a,b,q=list(map(int,input().split()))
s=[int(eval(input())) for i in range(a)]
t=[int(eval(input())) for i in range(b)]
x=[int(eval(input())) for i in range(q)]
import bisect
inf=10**11
def tansak(lis,lis2,dis):
ind=bisect.bisect_left(lis,dis)
ind2=bisect.bisect_left(lis2,dis)
return ind,ind2
for i in range(q):
now = x[i]
ind,ind2 = tansak(s,t,now)
if ind==0:
one=-inf
else:
one=s[ind-1]
if ind==a:
two=inf
else:
two=s[ind]
if ind2==0:
thr=-inf
else:
thr=t[ind2-1]
if ind2==b:
fo=inf
else:
fo=t[ind2]
tmp1=max(two,fo)-now
tmp2=2*two-thr-now
tmp3=2*fo-one-now
tmp4=now-min(one,thr)
tmp5=now-thr+two-thr
tmp6=now-one+fo-one
print((min(tmp1,tmp2,tmp3,tmp4,tmp5,tmp6)))
|
import sys
import math
def input():
return sys.stdin.readline()[:-1]
a,b,q=list(map(int,input().split()))
s=[int(eval(input())) for i in range(a)]
t=[int(eval(input())) for i in range(b)]
x=[int(eval(input())) for i in range(q)]
import bisect
inf=10**11
def tansak(lis,lis2,dis):
ind=bisect.bisect_left(lis,dis)
ind2=bisect.bisect_left(lis2,dis)
return ind,ind2
for i in range(q):
now = x[i]
ind,ind2 = tansak(s,t,now)
if ind==0:
one=-inf
else:
one=s[ind-1]
if ind==a:
two=inf
else:
two=s[ind]
if ind2==0:
thr=-inf
else:
thr=t[ind2-1]
if ind2==b:
fo=inf
else:
fo=t[ind2]
tmp1=max(two,fo)-now
tmp2=2*two-thr-now
tmp3=2*fo-one-now
tmp4=now-min(one,thr)
tmp5=now-thr+two-thr
tmp6=now-one+fo-one
print((min(tmp1,tmp2,tmp3,tmp4,tmp5,tmp6)))
|
p03112
|
import bisect
from sys import stdin
readline=stdin.readline
a,b,q=list(map(int,input().split()))
s=sorted([int(readline()) for i in range(a)])
t=sorted([int(readline()) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(readline())
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
print(ans)
|
import bisect
from sys import stdin
readline=stdin.readline
a,b,q=list(map(int,input().rstrip().split()))
s=sorted([int(readline().rstrip()) for i in range(a)])
t=sorted([int(readline().rstrip()) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(readline().rstrip())
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
print(ans)
|
p03112
|
import bisect
import sys
def input_function():
return sys.stdin.readline().rstrip()
input=input_function
a,b,q=list(map(int,input().split()))
s=sorted([int(eval(input())) for i in range(a)])
t=sorted([int(eval(input())) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(eval(input()))
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
print(ans)
|
import bisect
import sys
input=lambda : sys.stdin.readline().rstrip()
a,b,q=list(map(int,input().split()))
s=sorted([int(eval(input())) for i in range(a)])
t=sorted([int(eval(input())) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(eval(input()))
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
print(ans)
|
p03112
|
import bisect
import sys
input=lambda : sys.stdin.readline().rstrip()
a,b,q=list(map(int,input().split()))
s=sorted([int(eval(input())) for i in range(a)])
t=sorted([int(eval(input())) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(eval(input()))
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
sys.stdout.write("%d"%ans+'\n')
|
import bisect
import sys
input=lambda : sys.stdin.readline().rstrip()
a,b,q=list(map(int,input().split()))
s=sorted([int(eval(input())) for i in range(a)])
t=sorted([int(eval(input())) for i in range(b)])
for i in range(q):
ans=999999999999
x=int(eval(input()))
w=bisect.bisect_left(s,x)
for j in range(2):
if not 0<=w-j<len(s):
continue
z=bisect.bisect_left(t,s[w-j])
for k in range(2):
if not 0<=z-k<len(t):
continue
ans=min(ans,abs(x-s[w-j])+abs(s[w-j]-t[z-k]))
w=bisect.bisect_left(t,x)
for j in range(2):
if not 0<=w-j<len(t):
continue
z=bisect.bisect_left(s,t[w-j])
for k in range(2):
if not 0<=z-k<len(s):
continue
ans=min(ans,abs(x-t[w-j])+abs(t[w-j]-s[z-k]))
print(ans)
|
p03112
|
from bisect import bisect
A,B,Q=list(map(int, input().split()))
s=[int(eval(input())) for _ in range(A)] + [99**99]
t=[int(eval(input())) for _ in range(B)] + [99**99]
for _ in range(Q):
x = int(eval(input()))
ans = []
ps = bisect(s, x)
pt = bisect(t, x)
for vs in (s[ps], s[ps-1]):
for vt in (t[pt], t[pt-1]):
ans.append(abs(x - vs) + abs(vs - vt))
ans.append(abs(x - vt) + abs(vt - vs))
print((min(ans)))
|
from bisect import bisect
A,B,Q=list(map(int, input().split()))
s=[int(eval(input())) for _ in range(A)] + [10**11]
t=[int(eval(input())) for _ in range(B)] + [10**11]
for _ in range(Q):
x = int(eval(input()))
ans = []
ps = bisect(s, x)
pt = bisect(t, x)
for vs in (s[ps], s[ps-1]):
for vt in (t[pt], t[pt-1]):
ans.append(abs(x - vs) + abs(vs - vt))
ans.append(abs(x - vt) + abs(vt - vs))
print((min(ans)))
|
p03112
|
x=[]
for i,j in enumerate(map(int,input().split())):
c=[]
for l in range(j):
t=int(eval(input()))
x.append((i,l,t))
c.append([t])
x.sort(key=lambda x:x[2])
l=[-10**20]*2
for y in x:
if y[0] != 2:
l[y[0]]=y[2]
else:
c[y[1]]+=l[:]
l=[10**20]*2
for y in x[::-1]:
if y[0] != 2:
l[y[0]]=y[2]
else:
c[y[1]]+=l[:]
print(("\n".join(str(min(d[0]-min(d[1],d[2]),max(d[3],d[4])-d[0],
d[4]-d[1]+min(d[0]-d[1],d[4]-d[0]),
d[3]-d[2]+min(d[0]-d[2],d[3]-d[0])
)) for d in c)
))
|
import sys
input = sys.stdin.readline
A, B, Q = list(map(int, input().split()))
inf = 10**18
S = [-inf]
for _ in range(A):
S.append(int(eval(input())))
S.append(inf)
T = [-inf]
for _ in range(B):
T.append(int(eval(input())))
T.append(inf)
def f_s(x, l):
mn, mx = -1, len(l)
idx = mx//2
while mx-mn>1:
if l[idx] < x:
idx, mn = (idx + mx)//2, idx
continue
idx, mx = (idx + mn)//2, idx
return idx
for _ in range(Q):
q = int(eval(input()))
xi, yi = f_s(q, S), f_s(q, T)
s1, s2 = S[xi], S[xi+1]
t1, t2 = T[yi], T[yi+1]
print((min([
max(q-s1,q-t1),
max(s2-q, t2-q),
2*(s2-q) + q-t1,
2*(t2-q) + q-s1,
2*(q-s1) + t2-q,
2*(q-t1) + s2-q,
])))
# print(q, s1, s2, t1, t2)
# print(S[xi], T[yi])
|
p03112
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
A, B, Q = list(map(int, readline().split()))
stx = list(map(int, read().split()))
s = stx[:A]; t = stx[A:-Q]; x = stx[-Q:]
s = [-10 ** 10] + s + [10 ** 11]
t = [-10 ** 10] + t + [10 ** 11]
for i in x:
ax = bisect_left(s, i)
bx = bisect_left(t, i)
pp = max(s[ax], t[bx]) - i
mm = i - min(s[ax - 1], t[bx - 1])
pm = min(s[ax] * 2 - i - t[bx - 1], t[bx] * 2 - i - s[ax - 1])
mp = min(i - s[ax - 1] * 2 + t[bx], i - t[bx - 1] * 2 + s[ax])
print((min(pp, mm, pm, mp)))
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
A, B, Q = list(map(int, readline().split()))
stx = list(map(int, read().split()))
s = stx[:A]; t = stx[A:-Q]; x = stx[-Q:]
s = [-10 ** 10] + s + [10 ** 11]
t = [-10 ** 10] + t + [10 ** 11]
for i in x:
ax = bisect_left(s, i)
bx = bisect_left(t, i)
pp = max(s[ax], t[bx]) - i
mm = i - min(s[ax - 1], t[bx - 1])
pm = min(s[ax] * 2 - i - t[bx - 1], t[bx] * 2 - i - s[ax - 1])
mp = min(i - s[ax - 1] * 2 + t[bx], i - t[bx - 1] * 2 + s[ax])
print((min(pp, mm, pm, mp)))
if __name__ == '__main__':
main()
|
p03112
|
import bisect
a,b,q = list(map(int,input().split()))
s = [-10**11]+[int(eval(input())) for _ in range(a)]+[10**11]
t = [-10**11]+[int(eval(input())) for _ in range(b)]+[10**11]
for i in range(q):
ans = 10**11
x = int(eval(input()))
l = bisect.bisect(s,x)
m = bisect.bisect(t,x)
arr = [[s[l-1],s[l]],[t[m-1],t[m]]]
for i in range(4):
S = 0
now = x
for j in range(2):
S += (now-arr[j][i >> j & 1])*(-1)**(((now-arr[j][i >> j & 1])<0))
now = arr[j][i >> j & 1]
if ans > S:
ans = S
for i in range(4):
S = 0
now = x
for j in range(2):
S += (now-arr[1-j][i >> j & 1])*((-1)**((now-arr[1-j][i >> j & 1])<0))
now = arr[1-j][i >> j & 1]
if ans > S:
ans = S
print(ans)
|
import bisect
a,b,q = list(map(int,input().split()))
s = [-10**11]+[int(eval(input())) for _ in range(a)]+[10**11]
t = [-10**11]+[int(eval(input())) for _ in range(b)]+[10**11]
for i in range(q):
ans = 10**11
x = int(eval(input()))
l = bisect.bisect(s,x)
m = bisect.bisect(t,x)
arr = [[s[l-1],s[l]],[t[m-1],t[m]]]
for i in range(4):
S = 0
now = x
for j in range(2):
t0 = now-arr[j][i >> j & 1]
S += t0*((-1)**(t0<0))
now -= t0
if ans > S:
ans = S
for i in range(4):
S = 0
now = x
for j in range(2):
t0 = now-arr[1-j][i >> j & 1]
S += t0*((-1)**(t0<0))
now -= t0
if ans > S:
ans = S
print(ans)
|
p03112
|
import bisect
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect.bisect_left(S, x)
return [S[p-1], S[p]]
g = lambda x, s, t: abs(x-s)+abs(s-t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF]+I(a)+[INF], [-INF]+I(b)+[INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_)
|
from bisect import bisect_left
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect_left(S, x)
return [S[p-1], S[p]]
g = lambda x, s, t: abs(x-s)+abs(s-t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF]+I(a)+[INF], [-INF]+I(b)+[INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_)
|
p03112
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
A, B, Q = list(map(int, readline().split()))
S = [int(readline()) for _ in range(A)]
T = [int(readline()) for _ in range(B)]
X = [int(readline()) for _ in range(Q)]
ans = [INF] * Q
vs = [0] * 2
vt = [0] * 2
for i, x in enumerate(X):
idx_s = bisect_left(S, x)
idx_t = bisect_left(T, x)
vs[0] = S[idx_s - 1] if idx_s > 0 else -INF
vt[0] = T[idx_t - 1] if idx_t > 0 else -INF
vs[1] = S[idx_s] if idx_s < A else INF
vt[1] = T[idx_t] if idx_t < B else INF
for s in vs:
for t in vt:
ans[i] = min(ans[i], abs(x - s) + abs(s - t), abs(x - t) + abs(t - s))
print(('\n'.join(map(str, ans))))
return
if __name__ == '__main__':
main()
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
A, B, Q = list(map(int, readline().split()))
S = [-INF] + [int(readline()) for _ in range(A)] + [INF]
T = [-INF] + [int(readline()) for _ in range(B)] + [INF]
X = [int(readline()) for _ in range(Q)]
ans = [INF] * Q
for i, x in enumerate(X):
idx_s = bisect_left(S, x)
idx_t = bisect_left(T, x)
for s in (S[idx_s - 1], S[idx_s]):
for t in (T[idx_t - 1], T[idx_t]):
ans[i] = min(ans[i], abs(x - s) + abs(s - t), abs(x - t) + abs(t - s))
print(('\n'.join(map(str, ans))))
return
if __name__ == '__main__':
main()
|
p03112
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
A, B, Q = list(map(int, readline().split()))
S = [-INF] + [int(readline()) for _ in range(A)] + [INF]
T = [-INF] + [int(readline()) for _ in range(B)] + [INF]
X = [int(readline()) for _ in range(Q)]
ans = [INF] * Q
for i, x in enumerate(X):
idx_s = bisect_left(S, x)
idx_t = bisect_left(T, x)
for s in (S[idx_s - 1], S[idx_s]):
for t in (T[idx_t - 1], T[idx_t]):
ans[i] = min(ans[i], abs(x - s) + abs(s - t), abs(x - t) + abs(t - s))
print(('\n'.join(map(str, ans))))
return
if __name__ == '__main__':
main()
|
import sys
from bisect import bisect_left
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
A, B, Q = list(map(int, readline().split()))
S = [-INF]
S.extend(int(readline()) for _ in range(A))
S.append(INF)
T = [-INF]
T.extend(int(readline()) for _ in range(B))
T.append(INF)
X = [int(readline()) for _ in range(Q)]
ans = [INF] * Q
for i, x in enumerate(X):
idx_s = bisect_left(S, x)
idx_t = bisect_left(T, x)
for s in (S[idx_s - 1], S[idx_s]):
for t in (T[idx_t - 1], T[idx_t]):
ans[i] = min(ans[i], abs(x - s) + abs(s - t), abs(x - t) + abs(t - s))
print(('\n'.join(map(str, ans))))
return
if __name__ == '__main__':
main()
|
p03112
|
a,b,q=list(map(int,input().split()))
S,T=[],[]
for i in range(a):
S.append(int(eval(input())))
for i in range(b):
T.append(int(eval(input())))
def f(list,n):
if n<list[0]:
return [-float("inf"),list[0]]
elif list[-1]<n:
return [list[-1],float("inf")]
else:
flag,count=0,0
l=len(list)
i=(l-1)//2
while flag==0:
if list[i]<n<list[i+1]:
flag=1
return [list[i],list[i+1]]
elif n<list[i]:
i//=2
count+=1
else:
i+=(l-1)//(2**(count+1))
count+=1
def g(SS,TT,x):
a,b,c,d=x-SS[0],SS[1]-x,x-TT[0],TT[1]-x
dis1=max(a,c)
dis2=min(2*a+d,2*d+a)
dis3=max(b,d)
dis4=min(2*b+c,2*c+b)
return min([dis1,dis2,dis3,dis4])
for i in range(q):
x=int(eval(input()))
print((g(f(S,x),f(T,x),x)))
|
import bisect
a,b,q=list(map(int,input().split()))
S,T=[],[]
for i in range(a):
S.append(int(eval(input())))
for i in range(b):
T.append(int(eval(input())))
def f(list,n):
if n<list[0]:
return [-float("inf"),list[0]]
elif list[-1]<n:
return [list[-1],float("inf")]
else:
i=bisect.bisect_left(list,n)
return [list[i-1],list[i]]
def g(SS,TT,x):
a,b,c,d=x-SS[0],SS[1]-x,x-TT[0],TT[1]-x
dis1=max(a,c)
dis2=min(2*a+d,2*d+a)
dis3=max(b,d)
dis4=min(2*b+c,2*c+b)
return min([dis1,dis2,dis3,dis4])
for i in range(q):
x=int(eval(input()))
print((g(f(S,x),f(T,x),x)))
|
p03112
|
import bisect
a, b, q = list(map(int, input().split()))
inf = float('inf')
S = [- inf] + [int(eval(input())) for i in range(a)] + [inf]
T = [- inf] + [int(eval(input())) for i in range(b)] + [inf]
for i in range(q):
x = int(eval(input()))
s_idx = bisect.bisect_left(S, x)
s1, s2 = S[s_idx - 1], S[s_idx]
t_idx = bisect.bisect_left(T, x)
t1, t2 = T[t_idx - 1], T[t_idx]
ans = inf
for i in s1, s2, t1, t2:
for j in s1, s2, t1, t2:
if i != j:
tmp = abs(x - i) + abs(i - j)
ans = min(ans, tmp)
print(ans)
|
import bisect
a, b, q = list(map(int, input().split()))
inf = float('inf')
S = [- inf] + [int(eval(input())) for i in range(a)] + [inf]
T = [- inf] + [int(eval(input())) for i in range(b)] + [inf]
for i in range(q):
x = int(eval(input()))
s_idx = bisect.bisect_left(S, x)
s1, s2 = S[s_idx - 1], S[s_idx]
t_idx = bisect.bisect_left(T, x)
t1, t2 = T[t_idx - 1], T[t_idx]
ans = inf
for i in s1, s2:
for j in t1, t2:
ans = min(ans, abs(x - i) + abs(i - j))
ans = min(ans, abs(x - j) + abs(i - j))
print(ans)
|
p03112
|
from bisect import bisect_left
A,B,Q = list(map(int,input().split()))
inf = float('inf')
S = [-inf] + [int(eval(input())) for i in range(A)] + [inf]
T = [-inf] + [int(eval(input())) for i in range(B)] + [inf]
X = [int(eval(input())) for i in range(Q)]
for x in X:
si = bisect_left(S,x); ti = bisect_left(T,x)
ans = inf
for s in [S[si-1],S[si]]:
for t in [T[ti-1],T[ti]]:
d1 = abs(s-x) + abs(t-s)
d2 = abs(t-x) + abs(s-t)
ans = min(ans,d1,d2)
print(ans)
|
import sys
input = sys.stdin.readline
from bisect import bisect
inf = float('inf')
A,B,Q = list(map(int,input().split()))
S = [-inf] + [int(eval(input())) for _ in range(A)] + [inf]
T = [-inf] + [int(eval(input())) for _ in range(B)] + [inf]
X = [int(eval(input())) for _ in range(Q)]
for x in X:
ans = inf
si = bisect(S,x)
ti = bisect(T,x)
for s in [S[si-1],S[si]]:
for t in [T[ti-1],T[ti]]:
res = abs(s-t) + min(abs(x-s),abs(x-t))
ans = min(ans,res)
print(ans)
|
p03112
|
import sys
import bisect
input = sys.stdin.readline
A, B, Q = map(int, input().split())
tera = [int(input()) for _ in range(A)]
sha = [int(input()) for _ in range(B)]
query = [int(input()) for _ in range(Q)]
res = []
for x in query:
tl = bisect.bisect_left(tera, x)
tr = bisect.bisect_right(tera, x)
sl = bisect.bisect_left(sha, x)
sr = bisect.bisect_right(sha, x)
if tl == 0:
temple = [tera[0]]
elif tr == A:
temple = [tera[A - 1]]
else:
temple = [tera[tl-1], tera[tl]]
if sl == 0:
shrine = [sha[0]]
elif sr == B:
shrine = [sha[B - 1]]
else:
shrine = [sha[sl-1], sha[sl]]
ans = 10**18
for t in temple:
for s in shrine:
tx = t - x
sx = s - x
if tx * sx >= 0:
a = max(abs(tx), abs(sx))
else:
a = min(2 * abs(tx) + abs(sx), 2 * abs(sx) + abs(tx))
ans = min(ans, a)
res.append(ans)
print(*res, sep="\n")
|
import sys
import bisect
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
bl = bisect.bisect_left
A, B, Q = list(map(int, input().split()))
inf = 10**18
S = [-inf]+[int(eval(input())) for _ in range(A)]+[inf]
T = [-inf]+[int(eval(input())) for _ in range(B)]+[inf]
def path(x):
sl = S[bl(S, x) - 1]
sr = S[bl(S, x)]
tl = T[bl(T, x) - 1]
tr = T[bl(T, x)]
res = 10 ** 18
res = min(res, abs(x - sl) + abs(sl - tl))
res = min(res, abs(x - sl) + abs(sl - tr))
res = min(res, abs(x - sr) + abs(sr - tr))
res = min(res, abs(x - sr) + abs(sr - tl))
res = min(res, abs(x - tr) + abs(tr - sl))
res = min(res, abs(x - tr) + abs(tr - sr))
res = min(res, abs(x - tl) + abs(tl - sl))
res = min(res, abs(x - tl) + abs(tl - sr))
return res
X = [int(eval(input())) for _ in range(Q)]
for x in X:
print((path(x)))
|
p03112
|
def dfs(p, c, s):
if c==n:
return not s
if p==-1:
return 0
if memo[s][p][c] != -1:
return memo[s][p][c]
ret = 0
for i in range(min(p, s), -1, -1):
ret += dfs(i-1, c+1, s-i)
memo[s][p][c] = ret
return ret
while 1:
n, s = list(map(int, input().split()))
if n==0:
break
memo = [[[-1]*(n+1) for i in range(101)] for j in range(s+1)]
print(dfs(min(s, 100), 0, s))
|
while 1:
n, s = list(map(int, input().split()))
if n==0:
exit(0)
dp = [[0]*(s+1) for _ in range(n+1)]
dp[0][0] = 1
for i in range(min(s+1, 101)):
si1 = s-i+1
for k in range(n, 0, -1):
dp_k = dp[k]; dp_k1 = dp[k-1]
for j in range(si1):
dp_k[i+j] += dp_k1[j]
print(dp[n][s])
|
p00097
|
"""
now...今注目する値
used...使った数字の数
sum...それまでの合計
dp[now][used][sum]...nowまででused個の数字を使って合計sumの場合の数
dp[now][used][sum] = dp[now - 1][used - 1][sum - now] + dp[now - 1][used][sum] (used >= 1 and sum >= now)
dp[now - 1][used][sum] (used == 0 or sum < now)
"""
dp = [[[0 for _ in range(1001)] for _ in range(10)] for _ in range(101)]
dp[0][1][0] = 1
dp[0][0][0] = 1
for now in range(1, 101):
for used in range(10):
for s in range(1001):
if used >= 1 and s >= now:
dp[now][used][s] = dp[now - 1][used - 1][s - now] + dp[now - 1][used][s]
else:
dp[now][used][s] = dp[now - 1][used][s]
while True:
n, s = list(map(int, input().split()))
if not n:
break
print((dp[100][n][s]))
|
"""
now...今注目する値
used...使った数字の数
sum...それまでの合計
dp[now][used][sum]...nowまででused個の数字を使って合計sumの場合の数
dp[now][used][sum] = dp[now - 1][used - 1][sum - now] + dp[now - 1][used][sum] (used >= 1 and sum >= now)
dp[now - 1][used][sum] (used == 0 or sum < now)
2次元化
dp[used][sum]...used個の数字を使って合計sumの場合の数
dp[used][sum] = dp[used - 1][sum - now] + dp[used][sum] (used >= 1 and sum >= now)
ただし、usedの大きい順に更新する(更新がかぶるため)
"""
dp = [[0 for _ in range(1001)] for _ in range(10)]
dp[1][0] = 1
dp[0][0] = 1
for now in range(1, 101):
for used in range(9, 0, -1):
for s in range(now, 1001):
dp[used][s] = dp[used - 1][s - now] + dp[used][s]
while True:
n, s = list(map(int, input().split()))
if not n:
break
print((dp[n][s]))
|
p00097
|
"""
now...今注目する値
used...使った数字の数
sum...それまでの合計
dp[now][used][sum]...nowまででused個の数字を使って合計sumの場合の数
dp[now][used][sum] = dp[now - 1][used - 1][sum - now] + dp[now - 1][used][sum] (used >= 1 and sum >= now)
dp[now - 1][used][sum] (used == 0 or sum < now)
2次元化
dp[used][sum]...used個の数字を使って合計sumの場合の数
dp[used][sum] = dp[used - 1][sum - now] + dp[used][sum] (used >= 1 and sum >= now)
ただし、usedの大きい順に更新する(更新がかぶるため)
"""
dp = [[0 for _ in range(1001)] for _ in range(10)]
dp[1][0] = 1
dp[0][0] = 1
for now in range(1, 101):
for used in range(9, 0, -1):
for s in range(now, 1001):
dp[used][s] = dp[used - 1][s - now] + dp[used][s]
while True:
n, s = list(map(int, input().split()))
if not n:
break
print((dp[n][s]))
|
dp = [[0 for _ in range(1001)] for _ in range(10)]
dp[1][0] = dp[0][0] = 1
for now in range(1, 101):
for used in range(9, 0, -1):
dpu = dp[used]
dpu_1 = dp[used - 1]
for s in range(now, 1001):
dpu[s] = dpu_1[s - now] + dpu[s]
while True:
n, s = list(map(int, input().split()))
if not n:
break
print((dp[n][s]))
|
p00097
|
m=1001
A=list(range(9))
d=[[0]*m for i in A]
for i in range(101):
for j in A[::-1]:
if j==0: d[j][i]=1
else:
for k in range(m):
if k+i<m: d[j][k+i]+=d[j-1][k]
while 1:
n,s=list(map(int,input().split()))
if n==s==0: break
print(d[n-1][s])
|
m=1001
A=list(range(9))
d=[[0]*m for i in A]
for i in range(101):
for j in A[::-1]:
if j==0: d[j][i]=1
else:
for k in range(m-i): d[j][k+i]+=d[j-1][k]
while 1:
n,s=list(map(int,input().split()))
if n==s==0: break
print(d[n-1][s])
|
p00097
|
m=1001
A=list(range(10))
d=[[0]*m for i in A]
d[0][0]=1
for i in range(101):
for j in A[1:][::-1]:
for k in range(m-i): d[j][k+i]+=d[j-1][k]
while 1:
n,s=list(map(int,input().split()))
if n==s==0: break
print(d[n][s])
|
m=1001
A=list(range(9))
d=[[0]*m for i in A]
for i in range(101):
for j in A[1:][::-1]:
for k in range(m-i): d[j][k+i]+=d[j-1][k]
d[0][i]=1
while 1:
n,s=list(map(int,input().split()))
if n==s==0: break
print(d[n-1][s])
|
p00097
|
while 1:
try:
N,M = list(map(int,input().split()))
dp = [[0]*(M+1) for i in range(3)]
for _ in range(N):
name = input()
C,V,D,L = list(map(int,input().split()))
VDL = [V,D,L]
for i in range(3):
try: dp[i][C] = max(dp[i][C],VDL[i])
except: pass
for j in range(M):
if dp[i][j]:
try: dp[i][j+C] = max(dp[i][j+C],dp[i][j]+VDL[i])
except: break
print(max(max(dp[0]),max(dp[1]),max(dp[2])))
except:
break
|
while 1:
try:
N,M = list(map(int,input().split()))
dp = [[0]*(M+1) for i in range(3)]
for _ in range(N):
name = input()
C,V,D,L = list(map(int,input().split()))
VDL = [V,D,L]
for i in range(3):
try: dp[i][C] = max(dp[i][C],VDL[i])
except: break
for j in range(M):
if dp[i][j]:
try: dp[i][j+C] = max(dp[i][j+C],dp[i][j]+VDL[i])
except: break
print(max(max(dp[0]),max(dp[1]),max(dp[2])))
except:
break
|
p01336
|
import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000)
N=int(eval(input()))
edge={i:[] for i in range(1,N+1)}
for i in range(0,N-1):
a,b=list(map(int,input().split()))
edge[a].append(b)
edge[b].append(a)
K=int(eval(input()))
dic={}
for i in range(K):
v,p=list(map(int,input().split()))
dic[v]=0
dic[v]=p
memo={i:[] for i in range(1,N+1)}
flag={i:True for i in range(2,N+1)}
def dfs(num):
flag[num]=False
if memo[num]:
return memo[num]
if num!=1 and len(edge[num])==1:
if num in list(dic.keys()):
memo[num]=[dic[num],dic[num],dic[num]%2]
return memo[num]
else:
memo[num]=[-float("inf"),float("inf"),2]
return memo[num]
ansl=-float("inf")
ansr=float("inf")
anseo=2
if num in list(dic.keys()):
ansl=dic[num]
ansr=dic[num]
anseo=dic[num]%2
for i in edge[num]:
if flag[i]:
l,r,eo=dfs(i)
if eo!=2:
eo=(eo+1)%2
if anseo==2:
ansr=min(ansr,r+1)
ansl=max(ansl,l-1)
anseo=eo
if ansl>ansr:
print("No")
exit()
else:
ansr=min(ansr,r+1)
ansl=max(ansl,l-1)
if ansl>ansr or (eo!=2 and eo!=anseo):
print("No")
exit()
memo[num]=[ansl,ansr,anseo]
return memo[num]
l,r,eo=dfs(1)
print("Yes")
ans={i:-float("inf") for i in range(1,N+1)}
flag={i:True for i in range(2,N+1)}
ans[1]=l
flag[1]=False
q=set([(1,ans[1])])
sub=set([])
while q:
while q:
node,num=q.pop()
for i in edge[node]:
if flag[i]:
flag[i]=False
l,r,eo=memo[i]
if r>=num-1>=l:
ans[i]=num-1
sub.add((i,ans[i]))
else:
ans[i]=num+1
sub.add((i,ans[i]))
if not q:
q=sub
sub=set([])
break
for i in range(1,N+1):
print((ans[i]))
|
import sys
input=sys.stdin.readline
sys.setrecursionlimit(1000000)
N=int(eval(input()))
edge={i:[] for i in range(1,N+1)}
for i in range(0,N-1):
a,b=list(map(int,input().split()))
edge[a].append(b)
edge[b].append(a)
K=int(eval(input()))
dic={}
for i in range(K):
v,p=list(map(int,input().split()))
dic[v]=0
dic[v]=p
memo={i:[] for i in range(1,N+1)}
flag={i:True for i in range(2,N+1)}
def dfs(num):
flag[num]=False
if memo[num]:
return memo[num]
if num!=1 and len(edge[num])==1:
if num in list(dic.keys()):
memo[num]=[dic[num],dic[num],dic[num]%2]
return memo[num]
else:
memo[num]=[-float("inf"),float("inf"),2]
return memo[num]
ansl=-float("inf")
ansr=float("inf")
anseo=2
if num in list(dic.keys()):
ansl=dic[num]
ansr=dic[num]
anseo=dic[num]%2
for i in edge[num]:
if flag[i]:
l,r,eo=dfs(i)
if eo!=2:
eo=(eo+1)%2
if anseo==2:
ansr=min(ansr,r+1)
ansl=max(ansl,l-1)
anseo=eo
if ansl>ansr:
print("No")
exit()
else:
ansr=min(ansr,r+1)
ansl=max(ansl,l-1)
if ansl>ansr or (eo!=2 and eo!=anseo):
print("No")
exit()
memo[num]=[ansl,ansr,anseo]
return memo[num]
l,r,eo=dfs(1)
print("Yes")
ans={i:-float("inf") for i in range(1,N+1)}
flag={i:True for i in range(2,N+1)}
ans[1]=l
flag[1]=False
q=set([(1,ans[1])])
sub=set([])
while q:
while q:
node,num=q.pop()
for i in edge[node]:
if flag[i]:
flag[i]=False
l,r,eo=memo[i]
if r>=num-1>=l:
ans[i]=num-1
else:
ans[i]=num+1
sub.add((i,ans[i]))
if not q:
q=sub
sub=set([])
break
for i in range(1,N+1):
print((ans[i]))
|
p03949
|
import math
def main():
X = int(eval(input()))
ans = False
for i in range(X+1):
mx = 105 * i
mn = 100 * i
if mn <= X <= mx:
ans = True
if ans:
print((1))
else:
print((0))
if __name__ == "__main__":
main()
|
import math
def main():
X = int(eval(input()))
# ans = False
c = X // 100
mx = 105 * c
mn = 100 * c
if mn <= X <= mx:
print((1))
else:
print((0))
if __name__ == "__main__":
main()
|
p02843
|
x = int(eval(input()))
max_a = (x // 100) + 1
max_b = (x // 101) + 1
max_c = (x // 102) + 1
max_d = (x // 103) + 1
max_e = (x // 104) + 1
for a in range(max_a):
for b in range(max_b):
for c in range(max_c):
for d in range(max_d):
for e in range(max_e):
for_f = x - (a * 100 + b * 101 + c * 102 + d * 103 + e * 104)
if for_f >= 0 and for_f % 105 == 0:
# print(a, b, c, d, e, for_f // 105)
print('1')
exit(0)
print('0')
|
x = int(eval(input()))
c = int(x / 100)
# print(c)
for i in range(c * 100, c * 105 + 1):
if i == x:
print((1))
exit(0)
print((0))
|
p02843
|
#!/usr/bin/env python3
import sys
def solve(X: int):
dp = [[False]*(X+1) for _ in range(7)]
price = [100,101,102,103,104,105]
for i in range(7):
dp[i][0] = True
## i番目まででjを払えるか
for i in range(6):
for j in range(X+1):
if j >= price[i]:
for k in range(1,j//price[i]+1):
dp[i+1][j] |= dp[i][j] or dp[i][j-k*price[i]]
else:
dp[i+1][j] = dp[i][j]
if dp[6][X]:
print((1))
else:
print((0))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(X: int):
dp = [[-1]*(X+1) for _ in range(7)]
price = [100,101,102,103,104,105]
m = [10**5]*6
for i in range(7):
dp[i][0] = 10**5
## i番目まででjを払えるか
for i in range(6):
for j in range(X+1):
if dp[i][j]>=0:
dp[i+1][j] = m[i]
elif j < price[i] or dp[i+1][j-price[i]]<=0:
dp[i+1][j] = -1
else:
dp[i+1][j] = dp[i+1][j-price[i]]-1
if dp[6][X]>=0:
print((1))
else:
print((0))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
p02843
|
#!/usr/bin/env python3
import sys
def solve(X: int):
dp = [[-1]*(X+1) for _ in range(7)]
price = [100,101,102,103,104,105]
m = [10**5]*6
for i in range(7):
dp[i][0] = 10**5
## i番目まででjを払えるか
for i in range(6):
for j in range(X+1):
if dp[i][j]>=0:
dp[i+1][j] = m[i]
elif j < price[i] or dp[i+1][j-price[i]]<=0:
dp[i+1][j] = -1
else:
dp[i+1][j] = dp[i+1][j-price[i]]-1
if dp[6][X]>=0:
print((1))
else:
print((0))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(X: int):
dp = [False for _ in range(X+1)]
dp[0] = True
prices = [100,101,102,103,104,105]
for i in range(1,X+1):
for price in prices:
if i >= price:
if dp[i-price]:
dp[i] = dp[i-price]
break
print((int(dp[X])))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
p02843
|
#!/usr/bin/env python3
import sys
def solve(X: int):
dp = [False for _ in range(X+1)]
dp[0] = True
prices = [100,101,102,103,104,105]
for i in range(1,X+1):
for price in prices:
if i >= price:
if dp[i-price]:
dp[i] = dp[i-price]
break
print((int(dp[X])))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(X: int):
for i in range(1000):
if i*100 <= X <= i*105:
print((1))
return
print((0))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
X = int(next(tokens)) # type: int
solve(X)
if __name__ == '__main__':
main()
|
p02843
|
import sys
input = sys.stdin.readline
from collections import *
X = int(eval(input()))
dp = [False]*(X+1)
dp[0] = True
for i in range(X+1):
for j in range(100, 106):
if i-j>=0:
dp[i] |= dp[i-j]
if dp[X]:
print((1))
else:
print((0))
|
X = int(eval(input()))
dp = [False]*(X+1)
dp[0] = True
for i in range(X+1):
for j in range(100, 106):
if i+j<=X:
dp[i+j] |= dp[i]
if dp[X]:
print((1))
else:
print((0))
|
p02843
|
X = int(eval(input()))
dp = [-1] * (X + 1)
a = [100, 101, 102, 103, 104, 105]
m = [1000000] * 6
dp[0] = 0
for i in range(6):
for j in range(X + 1):
if dp[j] >= 0:
dp[j] = m[i]
elif j < a[i] or dp[j - a[i]] <= 0:
dp[j] = -1
else:
dp[j] = dp[j - a[i]] - 1
print((int(dp[-1] >= 0)))
|
X = int(eval(input()))
n = X % 100
m = X // 100
cnt = 0
for a in reversed(list(range(1, 6))):
while n - a >= 0:
n -= a
cnt += 1
if cnt <= m:
print((1))
else:
print((0))
|
p02843
|
n = int(eval(input()))
ans = 0
for i in range(1, n+1):
if n in list(range(100 * i, 105 * i + 1)):
ans = 1
print(ans)
|
x = int(eval(input()))
flag = False
for c in range(1,x+1):
if c * 100 <= x and x <= c * 105:
flag = True
break
print((1 if flag else 0))
|
p02843
|
X = int(eval(input()))
X_MOD = X % 100
X_DIV = X // 100
def bfs():
from collections import deque
queue = deque([(0, 0)])
while queue:
sum_x, cnt_x = queue.popleft()
#print(sum_x, cnt_x)
if sum_x == X_MOD:
return 1
if sum_x > X_MOD:
continue
if cnt_x == X_DIV:
continue
queue.append((sum_x + 1,cnt_x+1))
queue.append((sum_x + 2,cnt_x+1))
queue.append((sum_x + 3,cnt_x+1))
queue.append((sum_x + 4,cnt_x+1))
queue.append((sum_x + 5,cnt_x+1))
return 0
ans = bfs()
print(ans)
|
X = int(eval(input()))
X_MOD = X % 100
X_DIV = X // 100
import sys
sys.setrecursionlimit(2000)
def dfs(sum_x, cnt_x):
if cnt_x > X_DIV:
return False
if sum_x == X_MOD:
return True
return dfs(sum_x+1, cnt_x+1) or dfs(sum_x+1, cnt_x+2) or dfs(sum_x+3, cnt_x+1) or dfs(sum_x+4, cnt_x+1) or dfs(sum_x+5, cnt_x+1)
ans = int(dfs(0,0))
print(ans)
|
p02843
|
X = int(eval(input()))
X_MOD = X % 100
X_DIV = X // 100
import sys
sys.setrecursionlimit(2000)
def dfs(sum_x, cnt_x):
if cnt_x > X_DIV:
return False
if sum_x == X_MOD:
return True
return dfs(sum_x+1, cnt_x+1) or dfs(sum_x+1, cnt_x+2) or dfs(sum_x+3, cnt_x+1) or dfs(sum_x+4, cnt_x+1) or dfs(sum_x+5, cnt_x+1)
ans = int(dfs(0,0))
print(ans)
|
X = int(eval(input()))
X_MOD = X % 100
X_DIV = X // 100
import sys
sys.setrecursionlimit(2000)
def dfs(sum_x, cnt_x, num):
if cnt_x > X_DIV:
return False
if sum_x == X_MOD:
return True
if num == 1:
return dfs(sum_x+1, cnt_x+1, 1) or dfs(sum_x+1, cnt_x+2, 2) or dfs(sum_x+3, cnt_x+1, 3) or dfs(sum_x+4, cnt_x+1, 4) or dfs(sum_x+5, cnt_x+1, 5)
if num == 2:
return dfs(sum_x+1, cnt_x+2, 2) or dfs(sum_x+3, cnt_x+1, 3) or dfs(sum_x+4, cnt_x+1, 4) or dfs(sum_x+5, cnt_x+1, 5)
if num == 3:
return dfs(sum_x+3, cnt_x+1, 3) or dfs(sum_x+4, cnt_x+1, 4) or dfs(sum_x+5, cnt_x+1, 5)
if num == 4:
return dfs(sum_x+4, cnt_x+1, 4) or dfs(sum_x+5, cnt_x+1, 5)
if num == 5:
return dfs(sum_x+5, cnt_x+1, 5)
ans = int(dfs(0,0,1))
print(ans)
|
p02843
|
import sys
import itertools
input = sys.stdin.readline
X = int(eval(input()))
#a = [int(i) for i in input().split()]
#e = [[int(i) for i in input().split()] for i in range(n)]
maxtimes = int(X/100)+1
pools = itertools.product(list(range(maxtimes)), repeat=6)
for comb in pools:
c = list(comb)
price = c[0]*100+c[1]*101+c[2]*102+c[3]*103+c[4]*104+c[5]*105
if price == X:
print((1))
exit()
print((0))
|
import sys
import itertools
input = sys.stdin.readline
X = int(eval(input()))
#a = [int(i) for i in input().split()]
#e = [[int(i) for i in input().split()] for i in range(n)]
maxtimes = int(X/100)+2
price = 0
for i1 in range(0, maxtimes):
#if i1*100 > X:
#break
for i2 in range(0, int(X/101)+2):
#if i1*100+i2*101 > X:
#break
for i3 in range(0, int(X/102)+2):
#if i1*100+i2*101+i3*102 > X:
#break
for i4 in range(0, int(X/103)+2):
#if i1*100+i2*101+i3*102+i4*103 > X:
#break
for i5 in range(0, int(X/104)+2):
#if i1*100+i2*101+i3*102+i4*103+i5+104 > X:
#break
for i6 in range(0, int(X/105)+2):
price = i1*100+i2*101+i3*102+i4*103+i5*104+i6*105
#print(i1, i2, i3, i4, i5, i6)
if price == X:
print((1))
exit()
elif price > X:
break
print((0))
|
p02843
|
# C - 100 to 105
from collections import defaultdict
def main():
X = int(eval(input()))
items = tuple(range(100, 106))
dp = defaultdict(bool)
dp[0] = True
while max(dp.keys()) < X:
for possible_price in tuple(dp.keys()):
for item in items:
dp[possible_price + item] = True
print((int(X in dp)))
if __name__ == "__main__":
main()
|
# C - 100 to 105
def main():
X = int(eval(input()))
check = lambda x: x * 100 <= X <= x * 105
is_possible = any(check(i) for i in range(X))
print((int(is_possible)))
if __name__ == "__main__":
main()
|
p02843
|
x=int(eval(input()))
a=b=c=d=e=f=0
flag=False
for a in range(x//100+1):
for b in range(x//101+1):
for c in range(x//102+1):
for d in range(x//103+1):
for e in range(x//104+1):
for f in range(x//105+1):
if a*100+b*101+c*102+d*103+e*104+f*105==x:
flag=True
print((1))
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if flag==False:
print((0))
|
x=int(eval(input()))
y=1 # y個購入すると題意をみたす時、1<=y<=x//100、実際に支払い可能な金額は100＊y〜105＊y
if x<100:
print((0))
else:
while y<=x//100+1:
if y*100<=x<=y*105:
print((1))
break
elif y>x//100:
print((0))
break
else:
y+=1
|
p02843
|
# coding: utf-8
import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(eval(input()))
def MI() : return list(map(int, input().split()))
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(eval(input())) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in list(currentframe().f_back.f_locals.items())}; print((', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args)))
K = I()
N = 6
a = [100,101,102,103,104,105]
m = [1000000 for i in range(N)]
# initialize
dp = [0 if i==0 else -1 for i in range(K + 1)]
# DP
for i in range(N):
dp_tmp = []
for j in range(K + 1):
if (dp[j] >= 0):
dp_next = m[i]
elif ((j < a[i]) or (dp_tmp[j-a[i]] <= 0)):
dp_next = -1
else:
dp_next = dp_tmp[j-a[i]] - 1
dp_tmp.append(dp_next)
dp = dp_tmp
if dp[-1] >= 0:
print((1))
else:
print((0))
|
# coding: utf-8
import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(eval(input()))
def MI() : return list(map(int, input().split()))
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(eval(input())) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in list(currentframe().f_back.f_locals.items())}; print((', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args)))
X = I()
for i in range(X):
if i * 100 <= X and X <= i * 105:
print((1))
break
else:
print((0))
|
p02843
|
n = int(eval(input()))
if(n%100==0):
print((1))
elif(n%101==0):
print((1))
elif(n%102==0):
print((1))
elif(n%103==0):
print((1))
elif(n%104==0):
print((1))
elif(n%105==0):
print((1))
else:
tmp=n//100
mod=n%100/5
if(mod<tmp):
print((1))
else:
print((0))
|
n = int(eval(input()))
tmp=n//100
mod=n%100/5
if(mod<=tmp):
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
while(x>=0):
if x%100==0:
print("1")
break
elif x<100:
print("0")
break
elif x%100>=5:
x -= 105
continue
else:
x-=(x%100)+100
continue
|
x = int(eval(input()))
if ((x%100)+4)//5 > x//100:
print((0))
else:
print((1))
|
p02843
|
# 品物数を決めると合計金額は100*個数～105*個数の範囲となる
# xが範囲内にあれば買い方が存在する。なければしない。
x = int(eval(input()))
for i in range(1, 1000001):
if 100*i <= x <= 105*i:
print((1))
break
else:
print((0))
|
X = int(eval(input()))
for i in range(1, 100001):
if 100*i <= X <= 105*i:
print((1))
exit(0)
print((0))
|
p02843
|
#!/usr/bin/env python3
#三井住友信託銀行プログラミングコンテスト2019 C
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
x = I()
y,z = divmod(x,100)
if y*5 >= z:
print((1))
else:
print((0))
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
x = I()
y = x // 100
z = x % 100
if 0 <= z <= 5*y:
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
ans = 0
for a in range((x//100)+1):
for b in range((x//101)+1):
for c in range((x//102)+1):
for d in range((x//103)+1):
for e in range((x//104)+1):
for f in range((x//105)+1):
if (100*a) + (101*b) + (102*c) + (103*d) + (104*e) + (105*f)== x:
ans += 1
if ans == 0:
print((0))
else:
print((1))
|
x = int(eval(input()))
ans = 0
flag = False
for a in range((x//100)+1):
for b in range((x//101)+1):
for c in range((x//102)+1):
for d in range((x//103)+1):
for e in range((x//104)+1):
for f in range((x//105)+1):
if (100*a) + (101*b) + (102*c) + (103*d) + (104*e) + (105*f)== x:
ans += 1
flag = True
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if flag:
break
if ans == 0:
print((0))
else:
print((1))
|
p02843
|
X = int(eval(input()))
mod = X % 100
q = int(X //100)
sum = 0
ans = 0
for i in range (0,q+1):
for j in range (0,q+1-i):
for k in range (0,q+1-i-j):
for l in range (0,q+1-i-k-j):
for m in range (0,q+1-i-j-k-l):
sum = i+(2*j)+(3*k)+(4*l)+(5*m)
if sum == mod:
ans = 1
print(ans)
|
X = int(eval(input()))
mod = X % 100
q = int(X //100)
sum = 0
ans = 0
if q >= 20:
ans = 1
else:
for i in range (0,q+1):
for j in range (0,q+1-i):
for k in range (0,q+1-i-j):
for l in range (0,q+1-i-k-j):
for m in range (0,q+1-i-j-k-l):
sum = i+(2*j)+(3*k)+(4*l)+(5*m)
if sum == mod:
ans = 1
print(ans)
|
p02843
|
X = int(eval(input()))
num = X // 100
res = 0
for a in range(num+1):
for b in range(num-a+1):
for c in range(num-(a+b)+1):
for d in range(num-(a+b+c)+1):
for e in range(num-(a+b+c+d)+1):
for f in range(num-(a+b+c+d+e)+1):
if a*100 + b*101 + c*102 + d*103 + e*104 + f*105 == X:
res = 1
break
print(res)
|
X = int(eval(input()))
if X >= 2000:
print((1))
else:
num = X // 100
res = 0
for a in range(num+1):
for b in range(num-a+1):
for c in range(num-(a+b)+1):
for d in range(num-(a+b+c)+1):
for e in range(num-(a+b+c+d)+1):
for f in range(num-(a+b+c+d+e)+1):
if a*100 + b*101 + c*102 + d*103 + e*104 + f*105 == X:
res = 1
break
print(res)
|
p02843
|
x = int(eval(input()))
dp = [False] * (x+1)
dp[0] = True
for i in range(1,x+1):
if i < 99:
continue
else:
if dp[i-100]:
dp[i] = True
elif dp[i-101]:
dp[i] = True
elif dp[i-102]:
dp[i] = True
elif dp[i-103]:
dp[i] = True
elif dp[i-104]:
dp[i] = True
elif dp[i-105]:
dp[i] = True
if dp[x]:
print((1))
else:
print((0))
|
a = int(eval(input()))
tmp01 = a/100
tmp02 = a/105
n = a//100
#print(tmp01,n,tmp02)
if tmp01 >= n >= tmp02:
print((1))
else:
print((0))
|
p02843
|
n = int(eval(input()))
L = [i for i in range(100,2001,100)]
#print(L)
LL = []
for i in L:
n1 = int(str(i)[0])
n2 = int(str(i)[0]+str(i)[1])
len1 = len(str(i))
if len1 == 3:
LL.append((n1*100+5*n1+1,(n1+1)*100-1))
else:
LL.append((n2*100+5*(n2)+1,(n2+1)*100-1))
LL = [(1,99)] + LL
LL.pop()
#print(LL)
for i in range(len(LL)):
if LL[i][0] <= n <= LL[i][1]:
print((0))
exit()
print((1))
|
n = int(eval(input()))
print((1 if divmod(n,100)[1] <= divmod(n,100)[0]*5 else 0))
|
p02843
|
import sys
payable = [False] * (10 ** 5 + 1)
payable[0] = True
for i in range(100,106):
payable[i] = True
for i in range(106, 10 ** 5 + 1):
payable[i] = any(payable[i-105:i-99])
def main():
x = int(sys.stdin.readline().rstrip())
print((payable[x] & 1))
if __name__ == '__main__':
main()
|
import sys
def main():
x = int(sys.stdin.readline().rstrip())
q, r = divmod(x, 100)
if 5 * q >= r:
ans = 1
else:
ans = 0
print(ans)
if __name__ == '__main__':
main()
|
p02843
|
import itertools
import math
x = int(eval(input()))
remain = x % 100
quotient = math.floor(x/100)
items = [100, 101, 102, 103, 104, 105]
n = 6
for moneys in itertools.product(items, repeat=quotient):
if sum(moneys) == x:
print((1))
exit()
print((0))
|
import itertools
import math
x = int(eval(input()))
remain = x % 100
quotient = math.floor(x/100)
items = [100, 101, 102, 103, 104, 105]
n = 6
for moneys in itertools.combinations_with_replacement(items, quotient):
if sum(moneys) == x:
print((1))
exit()
print((0))
|
p02843
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
X = int(eval(input()))
l = []
for i in range(1001):
l.extend(list(range(i*100, 105*i+1)))
if X in l:
print((1))
else:
print((0))
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
X = int(eval(input()))
for i in range(100000):
if 100 * i <= X <= 100 * i + 5 * i:
print((1))
exit()
print((0))
|
p02843
|
import itertools
x = int(eval(input()))
max_c = int(x/100)
p_L = [i for i in range(100,106)]
a = list(itertools.combinations_with_replacement(p_L, max_c))
for val in a:
if sum(val) == x:
print((1))
exit()
print((0))
|
import sys
sys.setrecursionlimit(200000)
x = int(eval(input()))
p_L = [i for i in range(100,106)]
def dfs(ans,next):
global p_L
global x
global stop_memo
ans += p_L[next]
if ans > x:
return
elif ans == x:
print((1))
exit()
for val in range(0,6):
dfs(ans,val)
for i in range(0,6):
dfs(0,i)
print((0))
|
p02843
|
from collections import deque
def solve(X):
if X >= 2000:
return 1
prices = list(range(100, 106))
Q = deque([(0, 0)])
while Q:
i, pNow = Q.popleft()
if i == 6:
if pNow == X:
return 1
else:
price = prices[i]
for num in range(20):
p2 = pNow + price*num
if p2 > X: break
Q.append((i+1, p2))
return 0
X = int(eval(input()))
print((solve(X)))
|
X = int(eval(input()))
dp = [False] * (X+1)
dp[0] = True
for i in range(1, X+1):
dp[i] = any(dp[i-(X+1)-105:i-(X+1)-99])
print((int(dp[X])))
|
p02843
|
import itertools
def modelAnswer(X:int):
lis = [i for i in range(100,106)]
C = X//100
for p in itertools.combinations_with_replacement(lis,C):
if(sum(p)==X):
return 1
return 0
def main():
X = int(eval(input()))
print((modelAnswer(X)))
if __name__ == '__main__':
main()
|
def solve(X:int) -> int:
if(X < 100):return 0
first = int(str(X)[-1])
seccond = int(str(X)[-2])
ans = 0
if(first >= 6):
ans += first + 200
elif(first > 0):
ans += first + 100
ans += (seccond * 2) * 105
return 1 if(ans <= X) else 0
def main():
X = int(eval(input()))
print((solve(X)))
if __name__ == "__main__":
main()
|
p02843
|
def main():
n = 6
A = (100, 101, 102, 103, 104, 105)
M = [10**6]*6
K = int(eval(input()))
dp = [[-1]*(K+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(K+1):
if dp[i][j] >= 0:
dp[i+1][j] = M[i]
elif j < A[i] or dp[i+1][j-A[i]] <= 0:
dp[i+1][j] = -1
else:
dp[i+1][j] = dp[i+1][j-A[i]] - 1
if dp[n][K] >= 0:
print((1))
else:
print((0))
if __name__ == '__main__':
main()
|
def main():
N = int(input())
for i in range(1, N+1):
if 100*i <= N <= 105*i:
return print(1)
print(0)
if __name__ == '__main__':
main()
|
p02843
|
def main():
N = int(input())
for i in range(1, N+1):
if 100*i <= N <= 105*i:
return print(1)
print(0)
if __name__ == '__main__':
main()
|
def main():
N = int(input())
i = N//100
if 100*i <= N <= 105*i:
return print(1)
else:
return print(0)
if __name__ == '__main__':
main()
|
p02843
|
X = int(eval(input()))
A = X // 100
for i_100 in range(A + 1):
for i_101 in range(A + 1 - i_100):
for i_102 in range(A + 1 - i_100 - i_101):
for i_103 in range(A + 1 - i_100 - i_101 - i_102):
for i_104 in range(A + 1 - i_100 - i_101 - i_102 - i_103):
for i_105 in range(A + 1 - i_100 - i_101 - i_102 - i_103 - i_104):
if i_100 + i_101 + i_102 + i_103 + i_104 + i_105 == A:
if i_100 * 100 + i_101 * 101 + i_102 * 102 + i_103 * 103 + i_104 * 104 + i_105 * 105 == X:
print("1")
exit()
print("0")
|
X = int(eval(input()))
A100 = 0
A105 = 0
for i in range(1001):
A100 += 100
A105 += 105
if A100 <= X <= A105:
print("1")
exit()
print("0")
|
p02843
|
import sys
N=int(eval(input()))
if 100<=N<=105:
print((1))
sys.exit()
min_=N//105
max_= N//100 + 1
#print(min_,max_)
count=0
for m in range(min_,max_):
X = N - 100*m
for i in range(0,X+1):
for j in range(0,(X-i)//2 +1):
for k in range(0,(X-i-2*j)//3 +1):
for l in range(0,(X-i-2*j-3*k)//4 +1):
count+=1
if count >= 10**8:
print((0))
sys.exit()
temp = (X-i-2*j-3*k-4*l)
if (temp % 5 == 0) and (m-i-j-k-l-temp//5>=0):
a=m-i-j-k-l-temp//5
t=temp // 5
print((1))
#print(N,m,a,i,j,k,l,t,100*a+101*i+102*j+103*k+104*l+105*t)
sys.exit()
else:
print((0))
|
import sys
N=int(eval(input()))
if 100<=N<=105:
print((1))
sys.exit()
min_=N//105
max_= N//100 + 1
#print(min_,max_)
count=0
for m in range(min_,max_):
X = N - 100*m
for i in range(0,X+1):
for j in range(0,(X-i)//2 +1):
for k in range(0,(X-i-2*j)//3 +1):
for l in range(0,(X-i-2*j-3*k)//4 +1):
count+=1
if count >= 5*10**7:
print((1))
sys.exit()
temp = (X-i-2*j-3*k-4*l)
if (temp % 5 == 0) and (m-i-j-k-l-temp//5>=0):
a=m-i-j-k-l-temp//5
t=temp // 5
print((1))
#print(N,m,a,i,j,k,l,t,100*a+101*i+102*j+103*k+104*l+105*t)
sys.exit()
else:
print((0))
|
p02843
|
x = int(eval(input()))
n = x // 100
x %= 100
for i in range(n):
if x - 5 >= 0:
x -= 5
elif x - 4 >= 0:
x -= 4
elif x - 3 >= 0:
x -= 3
elif x - 2 >= 0:
x -= 2
elif x - 1 >= 0:
x -= 1
else:
break
if x == 0:
print((1))
else:
print((0))
|
x = int(eval(input()))
n = x // 100
x %= 100
if n * 5 >= x:
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
n = x//100 + 1
for i in range(n):
for j in range(n):
for k in range(n):
for l in range(n):
for m in range(n):
c = 100*i + 101*j + 102*k + 103*l + 104*m
if x >= c:
t = x-c
if t%105 == 0:
print((1))
exit()
print((0))
|
x = int(eval(input()))
n = x//100
if 100*n <= x and x <= 105*n:
print((1))
else:
print((0))
|
p02843
|
import queue
x=int(eval(input()))
avail=list(range(100,106))
q=queue.Queue()
for i in avail:
q.put(i)
while not q.empty():
f=q.get()
for i in range(100,106):
if(i+f<=x and i+f not in avail):
avail.append(i+f)
q.put(i+f)
print((1 if x in avail else 0))
|
import queue
x=int(eval(input()))
avail=list(range(100,106))
ok=[False]*max(x+1,106)
q=queue.Queue()
for i in avail:
ok[i]=True
q.put(i)
while not q.empty():
f=q.get()
for i in range(100,106):
if(i+f<=x and not ok[i+f]):
ok[i+f]=True
q.put(i+f)
print((1 if ok[x] else 0))
|
p02843
|
x = int(eval(input()))
from collections import deque
q = deque([0])
prices = [100, 101, 102, 103, 104, 105]
while q:
cost = q.pop()
if cost > x:
continue
elif any([(x-cost)%p == 0 for p in prices]):
print((1))
break
for p in prices:
q.append(cost+p)
else:
print((0))
|
x = int(eval(input()))
c = 1
while True:
if c*100 <= x <= c*105:
print((1))
break
if c*100 > x:
print((0))
break
c += 1
|
p02843
|
import sys
X = int(eval(input()))
if 1 <= X and X < 100:
print("0")
sys.exit()
i = 0
dp = [0]*(X+1)
dp[0] = 1
for i in range(100, X+1):
for j in range(6):
if dp[i-(100+j)] == 0:
pass
else:
dp[i] = 1
print((dp[X]))
|
# import sys
X = int(eval(input()))
# if 1 <= X and X < 100:
# print("0")
# sys.exit()
i = 0
dp = [0]*(X+1)
dp[0] = 1
for i in range(100, X+1):
for j in range(6):
if dp[i-(100+j)] == 0:
pass
else:
dp[i] = 1
print((dp[X]))
|
p02843
|
#!/usr/bin/env python3
def solve(x):
if x >= 2000:
return True
memo = [True] + [False]*x
def dp(k):
if k == 0:
return True
elif k < 0:
return False
elif memo[k]:
return True
for i in range(100,106):
if dp(k-i):
return True
return False
for i in range(x):
memo[i+1] = dp(i+1)
return memo[x]
def main():
X = int(eval(input()))
print((int(solve(X))))
return
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def solve(x):
if x >= 2000:
return True
memo = [True] + [False]*x
def dp(k):
if k == 0:
return True
for i in range(100,106):
if k-i >= 0 and memo[k-i]:
return True
return False
for i in range(x):
memo[i+1] = dp(i+1)
return memo[x]
def main():
X = int(eval(input()))
print((int(solve(X))))
return
if __name__ == '__main__':
main()
|
p02843
|
N = int(eval(input()))
import sys
sys.setrecursionlimit(10 ** 9)
def dfs(x):
ans = False
if x == 0:
return True
elif x < 0:
return False
else:
ans |= dfs(x - 100)
ans |= dfs(x - 101)
ans |= dfs(x - 102)
ans |= dfs(x - 103)
ans |= dfs(x - 104)
ans |= dfs(x - 105)
return ans
if dfs(N):
print((1))
else:
print((0))
|
N = int(eval(input()))
import sys
sys.setrecursionlimit(10 ** 9)
memo = [-1] * (N + 1)
def dfs(x):
if x >= 0 and memo[x] != -1:
return memo[x]
ans = False
if x == 0:
memo[x] = 1
return True
elif x < 0:
return False
else:
ans |= dfs(x - 100)
ans |= dfs(x - 101)
ans |= dfs(x - 102)
ans |= dfs(x - 103)
ans |= dfs(x - 104)
ans |= dfs(x - 105)
memo[x] = 1 if ans else 0
return ans
if dfs(N):
print((1))
else:
print((0))
|
p02843
|
X = int(eval(input()))
c = 0
for i in range(int(X/105)+1):
for j in range(int((X-105*i)/104)+1):
for k in range(int((X-105*i-104*j)/103) +1):
for l in range(int((X-105*i-104*j-103*k)/102) +1):
for m in range(int((X-105*i-104*j-103*k-102*l)/101)+1):
if (X-105*i-104*j-103*k-102*l-101*m) % 100 == 0:
c = 1
print(c)
|
X= int(eval(input()))
val = X // 100
diff = X % 100
if diff <= 5*val:
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
# 最大n個は買う必要がある
n = x // 100
# 最低m個買う必要がある
m = x // 105
ans = 0
# もし割り切れたら、OK
for i in range(100,106):
if x % i == 0:
ans = 1
break
import itertools
shinamono = [100,101,102,103,104,105] * (n)
for i in range(m,n+1):
if ans == 1:
break
a = itertools.combinations(shinamono, i)
for j in a:
if sum(j) == x:
ans = 1
break
print(ans)
|
x = int(eval(input()))
ans = 0
for i in range(1,100001):
if 100 * i <= x and 105 * i >= x:
ans = 1
break
print(ans)
|
p02843
|
import itertools
X = int(eval(input()))
num = X//100
r = X % 100
li = [0, 1, 2, 3, 4, 5]
flag = False
for i in itertools.product(li, repeat=num):
if sum(i) == r:
flag = True
break
print(('1' if flag else '0'))
|
X = int(eval(input()))
flag = False
for i in range(1, X+1):
if 100*i <= X <= 105*i:
flag = True
break
print(('1' if flag else '0'))
|
p02843
|
x=int(eval(input()))
for i in range(1,100000):
if 100*i<=x<=105*i:
print((1))
exit()
print((0))
|
x=int(eval(input()))
print((1 if x<=x//100*105 else 0))
|
p02843
|
import sys
x = int(eval(input()))
number = int(x/100)
xn = x-number*100
number = number+1
for i in range(0,number):
for j in range(0,number-i):
for k in range (0,number-i-j):
for l in range(0,number-i-j-k):
for m in range(0,number-i-j-k-l):
for n in range(0,number-i-j-k-l-m):
if j*1+k*2+l*3+m*4+n*5==xn:
if i*100+j*101+k*102+l*103+m*104+n*105==x:
print((1))
sys.exit()
print((0))
|
import sys
x = int(eval(input()))
number = int(x/100)
number = number+1
for i in range(0,number):
for j in range(0,number-i):
for k in range (0,number-i-j):
for l in range(0,number-i-j-k):
for m in range(0,number-i-j-k-l):
for n in range(0,number-i-j-k-l-m):
if i*100+j*101+k*102+l*103+m*104+n*105==x:
print((1))
sys.exit()
print((0))
|
p02843
|
from itertools import combinations
import sys
"""
10の６条
ijklm
"""
X = int(eval(input()))
P = [1, 2, 3, 4, 5]
if 1 <= X <= 99:
print("0")
sys.exit(0)
a = X % 100
b = X // 100
if a == 0:
print("1")
sys.exit(0)
for i in range(20):
for j in range(25):
for k in range(34):
for l in range(50):
ans = 5 * i + 4 * j + 3 * k + 2 * l
if a -ans <= b - (i + j + k + l) and a - ans >= 0:
print("1")
sys.exit(0)
print('0')
|
X = int(eval(input()))
flag = False
for i in range(X + 1):
if 100 * i <= X <= 105 * i:
flag = True
if flag:
print((1))
else:
print((0))
|
p02843
|
x = int(input())
def a(lst, target, with_replacement=False):
def _a(idx, l, r, t, w):
if t == sum(l):
r.append(l)
return r
elif t < sum(l): return
for u in range(idx, len(lst)):
_a(u if w else (u + 1), l + [lst[u]], r, t, w)
return r
return _a(0, [], [], target, with_replacement)
goods = [100, 101, 102, 103, 104, 105]
res = a( goods, x, True)
print(1) if len(res)>0 else print(0)
|
x = int(input())
cnt = int(x/100)
print(1) if x-cnt*105<=0 else print(0)
|
p02843
|
x=int(eval(input()))
ans=0
for i in range(x//105+1):
for j in range(x//104+1):
for k in range(x//103+1):
for l in range(x//102+1):
for m in range(x//101+1):
for n in range(x//100+1):
if i*105+j*104+k*103+l*102+m*101+n*100==x:
ans=1
break
print(ans)
|
x=int(eval(input()))
num = x//100
div = x%100
ans=0
if 0<=div<=(num*5):
ans=1
print(ans)
|
p02843
|
# -*- coding: utf-8 -*-
X = int(eval(input()))
num = X // 100
reminder = X % 100
if reminder == 0:
print("1")
exit()
for i in range(num+1):
for j in range(num+1):
if i+j > num:
continue
for k in range(num+1):
if i+j+k > num:
continue
for l in range(num+1):
if i+j+k+l>num:
continue
for m in range(num+1):
if i+j+k+l+m>num:
continue
res = i*1+j*2+k*3+l*4+m*5
if res == reminder:
print("1")
exit()
print("0")
|
# -*- coding: utf-8 -*-
X = int(eval(input()))
num = X // 100
if num*100 <= X and X<=num*105:
print("1")
else:
print("0")
|
p02843
|
x = int(eval(input()))
y = x // 100
z = x % 100
t = 0
for i in range(101):
if t == 1 or i>y:
break
for j in range(101):
if t == 1 or i+j > y:
break
for k in range(101):
if t == 1 or i+j+k > y:
break
for l in range(101):
if t == 1 or i+j+k+l > y:
break
for m in range(101):
if t == 1 or i+j+k+l+m > y:
break
for n in range(101):
if t == 1 or i+j+k+l+m+n > y:
break
if (i+j+k+l+m+n == y):
if i*0+j*1+k*2+l*3+m*4+n*5 == z:
t = 1
break
if (i+j+k+l+m+n > y):
break
if t == 1:
print((1))
else:
print((0))
|
x = int(eval(input()))
x_ = x%100
t = 0
a = 5
while x_ != 0:
t += x_//a
x_ -= (x_//a)*a
a -= 1
if x//100 >= t:
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
dp = [False] * (x + 1)
dp[0] = True
for j in range(100, x + 1):
for t in range(100, 105 + 1):
if j - t >= 0:
dp[j] = dp[j] or dp[j - t]
print((1 if dp[x] else 0))
|
def solve():
x = int(eval(input()))
min_ = x // 105
max_ = x // 100
for c in range(max_, max_ + 1):
if 100 * c <= x <= 105 * c:
return 1
return 0
print((solve()))
# 品物の個数 C が決まっていると、合計価格としてありうるものは 「100 × C 円以上 105 × C 円以下」 す
# べてになります。ですので、判定が簡単です。
# C = 1, 2, 3, …, X すべてに対して判定して、この中に 「ちょうど X 円の買い物をすることは可能」 と判定
# されたものがひとつでもあれば X 円の買い物ができ (その場合の答えは 「1」)、ひとつもなければどうやっ
# ても X 円の買い物ができません (その場合の答えは 「0」)。
# 範囲がすべて達成可能という考え方は、
# agc017bでも使ったが、意識できていない
|
p02843
|
X=int(eval(input()))
N=X//100
for a in range(N+1):
for b in range(N+1):
for c in range(N+1):
for d in range(N+1):
for e in range(N+1):
for f in range(N+1):
if 100*a+101*b+102*c+103*d+104*e+105*f==X:
print('1')
exit()
print('0')
|
X=int(eval(input()))
N=X%100
if N%5==0:
if N//5<=X//100:
print('1')
else:
print('0')
else:
if N//5+1<=X//100:
print('1')
else:
print('0')
|
p02843
|
import itertools as it
num = int(eval(input()))
item_number = num//100
res_list = []
candi_list = list(it.combinations_with_replacement([100, 101, 102, 103, 104, 105], item_number))
candi_ans_list = [sum(item) for item in candi_list]
if num in candi_ans_list:
print((1))
else:
print((0))
|
import itertools as it
num = int(eval(input()))
item_number = num//100
if item_number>= 20:
item_number = 20
res_list = []
candi_list = list(it.combinations_with_replacement([100, 101, 102, 103, 104, 105], item_number))
candi_ans_list = [sum(item) for item in candi_list]
if num >= 2000:
print((1))
else:
if num in candi_ans_list:
print((1))
else:
print((0))
|
p02843
|
import itertools as it
num = int(eval(input()))
item_number = num//100
if item_number>= 20:
item_number = 20
res_list = []
candi_list = list(it.combinations_with_replacement([100, 101, 102, 103, 104, 105], item_number))
candi_ans_list = [sum(item) for item in candi_list]
if num >= 2000:
print((1))
else:
if num in candi_ans_list:
print((1))
else:
print((0))
|
import itertools as it
num = int(eval(input()))
item_number = num//100
temp_val = num%100
times = temp_val //15
temp_val = temp_val % 15
if temp_val <= 5:
temp_val = 1
elif temp_val <= 10:
temp_val = 2
else:
temp_val =3
need_item_number = 3*times + temp_val
# print(item_number)
# print(times)
# print(need_item_number)
if item_number >= need_item_number:
print((1))
else:
print((0))
|
p02843
|
X=int(eval(input()))
dp=[0]*(X+105)
dp[0]=1
for x in range(X):
if dp[x]==1:
for price in range(100,106):
dp[x+price]=1
print((dp[X]))
|
X=int(eval(input()))
div=X//100
mod=X%100
print((1 if 5*div>=mod else 0))
|
p02843
|
X = int(eval(input()))
t = X%100
k = X//100
if k*5 >= t:
print((1))
else:
print((0))
|
X = int(eval(input()))
t = X//100
if 0 <= X%100 <= t*5:
print((1))
else:
print((0))
|
p02843
|
X = int(eval(input()))
A = [100,101,102,103,104,105]
dp = [[-1 for _ in range(X+1)] for _ in range(7)]
for i in range(1,7):
dp[i][0] = 10**6
for i in range(1,7):
for j in range(1,X+1):
if dp[i-1][j]>=0:
dp[i][j] = 10**6
elif j<A[i-1] or dp[i][j-A[i-1]]<=0:
dp[i][j] = -1
else:
dp[i][j] = dp[i][j-A[i-1]]-1
if dp[6][X]>=0:
print((1))
else:
print((0))
|
X = int(eval(input()))
x = X%100
cnt = 0
cnt += x//5
x = x%5
cnt += x//4
x = x%4
cnt += x//3
x = x%3
cnt += x//2
x = x%2
cnt += x
X = X-X%100
if X>=100*cnt:
print((1))
else:
print((0))
|
p02843
|
import itertools
X=int(eval(input()))
l=[100,101,102,103,104,105]
for i in range(1,X//100+1):
for v in itertools.combinations_with_replacement(l,i):
if sum(v)==X:
print((1))
exit()
print((0))
|
N=int(eval(input()))
n=N//100
if n>0:
m=N%100
if m/n<=5:
print((1))
else:
print((0))
else:
print((0))
|
p02843
|
from itertools import combinations
n= int(eval(input()))
l = [100,101,102,103,104,105]
res = [comb for i in range(1,10**5) for comb in combinations(l, i) if sum(comb) == n]
if len(res) >= 1:
print((1))
else:
print((0))
|
x = int(eval(input()))
n = x%100
q,r=divmod(n,5)
if r:
q+=1
if x//100 >= q:
print((1))
else:
print((0))
|
p02843
|
x = int(eval(input()))
h = x//100
for a in range(0,h+1):
for b in range(0,h+1):
for c in range(0,h+1):
for d in range(0,h+1):
for e in range(0,h+1):
for f in range(0,h+1):
if 100*a+101*b+102*c+103*d+104*e+105*f==x:
print('1')
exit()
else:
print('0')
|
x = int(eval(input()))
l = -(-x//105)
h = x//100
fix = l*100
for b in range(0,h+1):
for c in range(0,h+1):
for d in range(0,h+1):
for e in range(0,h+1):
for f in range(0,h+1):
if fix + 1*b+2*c+3*d+4*e+5*f==x:
print('1')
exit()
else:
print('0')
|
p02843
|
x = int(eval(input()))
l = -(-x//105)
h = x//100
fix = l*100
for b in range(0,h+1):
for c in range(0,h+1):
for d in range(0,h+1):
for e in range(0,h+1):
for f in range(0,h+1):
if fix + 1*b+2*c+3*d+4*e+5*f==x:
print('1')
exit()
else:
print('0')
|
x = int(eval(input()))
l = -(-x//105)
h = x//100
#fix = l*100
for i in range(l,h+1):
for b in range(0,i+1):
for c in range(0,i+1):
for d in range(0,i+1):
for e in range(0,i+1):
if x - (i*100 + 1*b+2*c+3*d+4*e+5*(i-b-c-d-e)) == 0:
print('1')
exit()
else:
print('0')
|
p02843
|
X = int(eval(input()))
dp = [0]*(X+1)
dp[0] = 1
for i in range(X+1):
for j in [100, 101, 102, 103, 104, 105]:
if i-j>=0 and dp[i-j]:
dp[i] = 1
print((dp[X]))
|
X = int(eval(input()))
dp = [0]*(X+1)
dp[0] = 1
for i in range(100, X+1):
dp[i] = dp[i-100] or dp[i-101] or dp[i-102] or dp[i-103] or dp[i-104] or dp[i-105]
print((dp[X]))
|
p02843
|
x = int(eval(input()))
item_list = [100,101,102,103,104,105] * 1000
def part_sum(a,A):
#初期化
N = len(a)
dp = [[0 for i in range(A+1)] for j in range(N + 1)]
dp[0][0] = 1
#DP
for i in range(N):
for j in range(A+1):
if a[i] <= j :
dp[i + 1][j] = dp[i][j - a[i]] or dp[i][j]
else :
dp[i +1][j] = dp[i][j]
return dp[N][A]
print((part_sum(item_list,x)))
|
x = int(eval(input()))
dp = [0]*(x + 106)
dp[0] = 1
for i in range(x):
if dp[i] == 1:
dp[i + 100] =1
dp[i + 101] =1
dp[i + 102] =1
dp[i + 103] =1
dp[i + 104] =1
dp[i + 105] =1
if dp[x] ==1:
print((1))
else :
print((0))
|
p02843
|
X = int(eval(input()))
hasuu = X % 100
product_count = X // 100
# print(hasuu)
# print(product_count)
if product_count * 5 >= hasuu:
print("1")
else:
print("0")
|
X = int(eval(input())) # 金額
product_amount = X // 100
hasuu = X % 100
# print(product_amount)
# print(hasuu)
if 5 * product_amount >= hasuu:
print((1))
else:
print((0))
|
p02843
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.