input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import sys
input = sys.stdin.readline
INF = 10**11
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]
def binary_search(lis,x):
ok = 0
ng = len(lis)-1
while ng-ok > 1:
mid = (ok+ng)//2
if lis[mid] < x:
ok = mid
else:
ng = mid
return ok
#print(s,t)
for _ in range(Q):
x = int(eval(input()))
ps = binary_search(s,x)
pt = binary_search(t,x)
ans = INF
#print(ps,pt)
for i in range(ps,ps+2):
for j in range(pt,pt+2):
ds = x - s[i]
dt = x - t[j]
if (ds < 0 and dt < 0) or (ds > 0 and dt > 0):
ans = min(ans,max(abs(ds),abs(dt)))
else:
ans = min(ans,abs(ds)+abs(dt)+min(abs(ds),abs(dt)))
print(ans)
|
import sys
input = sys.stdin.readline
INF = 10**11
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]
def binary_search(lis,x):
ok = 0
ng = len(lis)-1
while ng-ok > 1:
mid = (ok+ng)//2
if lis[mid] < x:
ok = mid
else:
ng = mid
return ok
#print(s,t)
for _ in range(Q):
x = int(eval(input()))
ps = binary_search(s,x)
pt = binary_search(t,x)
ans = INF
#print(ps,pt)
for i in range(ps,ps+2):
for j in range(pt,pt+2):
ans = min(ans,abs(s[i]-x)+abs(s[i]-t[j]), abs(t[j]-x)+abs(t[j]-s[i]))
print(ans)
|
p03112
|
a,b,q=list(map(int,input().split()))
s=sorted([int(eval(input())) for _ in range(a)])
t=sorted([int(eval(input())) for _ in range(b)])
import bisect
for _ in range(q):
x=int(eval(input()))
ss=[x-s[max(bisect.bisect_left(s,x)-1,0)],x-s[min(bisect.bisect_right(s,x),a-1)]]
tt=[x-t[max(bisect.bisect_left(t,x)-1,0)],x-t[min(bisect.bisect_right(t,x),b-1)]]
l=[]
for i in ss:
for j in tt:
if i*j>=0:
l.append(max(abs(i),abs(j)))
else:
l.append(max(abs(i),abs(j))+2*min(abs(i),abs(j)))
print((min(l)))
|
a,b,q=list(map(int,input().split()))
s=[int(eval(input())) for _ in range(a)]
t=[int(eval(input())) for _ in range(b)]
import bisect
for _ in range(q):
x=int(eval(input()))
sb=bisect.bisect_left(s,x)
tb=bisect.bisect_left(t,x)
ss=[x-s[max(sb-1,0)],x-s[min(sb,a-1)]]
tt=[x-t[max(tb-1,0)],x-t[min(tb,b-1)]]
l=[]
for i in ss:
for j in tt:
if i*j>=0:
l.append(max(abs(i),abs(j)))
else:
l.append(max(abs(i),abs(j))+2*min(abs(i),abs(j)))
print((min(l)))
|
p03112
|
def near(x, Y):
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x
elif i == len(Y):
return x-Y[i-1]
else:
return min(Y[i]-x, x-Y[i-1])
def near2(x, D):
Y = [d for d ,_ in D]
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x + D[i][1]
elif i == len(Y):
return x-Y[i-1] + D[i-1][1]
else:
return min(Y[i]-x+D[i][1], x-Y[i-1]+D[i-1][1])
from bisect import *
A, B, Q = list(map(int, input().split()))
S = []
T = []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
D = []
for a in S:
D.append((a, near(a, T)))
for b in T:
D.append((b, near(b, S)))
D.sort(key=lambda x:x[0])
for _ in range(Q):
x = int(eval(input()))
print((near2(x,D)))
|
def near(x, Y):
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x
elif i == len(Y):
return x-Y[i-1]
else:
return min(Y[i]-x, x-Y[i-1])
def near2(x, Y):
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x + D[i][1]
elif i == len(Y):
return x-Y[i-1] + D[i-1][1]
else:
return min(Y[i]-x+D[i][1], x-Y[i-1]+D[i-1][1])
from bisect import *
A, B, Q = list(map(int, input().split()))
S = []
T = []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
D = []
for a in S:
D.append((a, near(a, T)))
for b in T:
D.append((b, near(b, S)))
D.sort(key=lambda x:x[0])
D2 = [d for d, _ in D]
for _ in range(Q):
x = int(eval(input()))
print((near2(x,D2)))
|
p03112
|
def near(x, Y):
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x
elif i == len(Y):
return x-Y[i-1]
else:
return min(Y[i]-x, x-Y[i-1])
def near2(x, Y):
i = bisect_left(Y,x)
if i == 0:
return Y[i]-x + D[i][1]
elif i == len(Y):
return x-Y[i-1] + D[i-1][1]
else:
return min(Y[i]-x+D[i][1], x-Y[i-1]+D[i-1][1])
from bisect import *
A, B, Q = list(map(int, input().split()))
S = []
T = []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
D = []
for a in S:
D.append((a, near(a, T)))
for b in T:
D.append((b, near(b, S)))
D.sort(key=lambda x:x[0])
D2 = [d for d, _ in D]
for _ in range(Q):
x = int(eval(input()))
print((near2(x,D2)))
|
def near(x, X):
i = bisect_left(X, x)
if i == 0: return [X[i]-x]
elif i == len(X): return [X[i-1]-x]
else: return [X[i]-x, X[i-1]-x]
from bisect import *
A, B, Q = list(map(int, input().split()))
S, T = [], []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
for _ in range(Q):
res = 1<<40
x = int(eval(input()))
for a in near(x,S):
for b in near(x,T):
res = min(abs(a)+abs(a-b), abs(b)+abs(b-a), res)
print(res)
|
p03112
|
def near(x, X):
i = bisect_left(X, x)
if i == 0: return [X[i]-x]
elif i == len(X): return [X[i-1]-x]
else: return [X[i]-x, X[i-1]-x]
from bisect import *
from itertools import product
A, B, Q = list(map(int, input().split()))
S, T = [], []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
for _ in range(Q):
res = 1<<40
x = int(eval(input()))
for a, b in product(near(x,S), near(x,T)):
res = min(abs(a)+abs(a-b), abs(b)+abs(b-a), res)
print(res)
|
def near(x, X):
i = bisect_left(X, x)
if i == 0: return [X[i]-x]
elif i == len(X): return [X[i-1]-x]
else: return [X[i]-x, X[i-1]-x]
import sys
input = sys.stdin.readline
from bisect import *
from itertools import product
A, B, Q = list(map(int, input().split()))
S, T = [], []
for _ in range(A):
S.append(int(eval(input())))
for _ in range(B):
T.append(int(eval(input())))
for _ in range(Q):
res = 1<<40
x = int(eval(input()))
for a, b in product(near(x,S), near(x,T)):
res = min(abs(a)+abs(a-b), abs(b)+abs(b-a), res)
print(res)
|
p03112
|
from bisect import bisect_left
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]
X = [int(eval(input())) for _ in range(Q)]
S1 = [0]*A
T1 = [0]*B
for i, s in enumerate(S[1:-1]):
x = bisect_left(T, s)
S1[i] = (s, min(abs(s - T[x-1]), abs(T[x] - s)))
for i, t in enumerate(T[1:-1]):
x = bisect_left(S, t)
T1[i] = (t, min(abs(t - S[x-1]), abs(S[x] - t)))
ST = S1 + T1
ST.sort()
ST = [(-10**11, 10**11)] + ST + [(10**11, 10**11)]
bist, dist = list(map(list, list(zip(*ST))))
for d in X:
x = bisect_left(bist, d)
print((min(abs(d - bist[x-1]) + dist[x-1], abs(bist[x] - d) + dist[x])))
|
import sys
from bisect import bisect as br
A, B, Q = list(map(int, input().split()))
inf = 10**11
S = [-inf] + [int(sys.stdin.readline()) for _ in range(A)] + [inf]
T = [-inf] + [int(sys.stdin.readline()) for _ in range(B)] + [inf]
X = [int(sys.stdin.readline()) for _ in range(Q)]
StoT = [0]*A
for i, s in enumerate(S[1:-1]):
x = br(T, s)
StoT[i] = (s, min(s - T[x-1], T[x] - s))
TtoS = [0]*B
for i, t in enumerate(T[1:-1]):
x = br(S, t)
TtoS[i] = (t, min(t - S[x-1], S[x] - t))
M = [(-inf, inf)] + TtoS + StoT + [(inf, inf)]
M.sort()
Mk , Mv = list(map(list, list(zip(*M))))
for x in X:
idx = br(Mk, x)
print((min(Mk[idx] - x + Mv[idx], x - Mk[idx-1] + Mv[idx-1])))
|
p03112
|
from bisect import bisect_left as bl
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)]
s.insert(0,-10**12)
s.append(10**12)
t.insert(0,-10**12)
t.append(10**12)
for i in range(q):
x = int(eval(input()))
si = bl(s,x)
ti = bl(t,x)
ans = 10**12
for j in range(si-1,si+1):
for k in range(ti-1,ti+1):
if s[j] <= t[k]:
if t[k] <= x:
ans = min(ans,x-s[j])
elif x <= s[j]:
ans = min(ans,t[k]-x)
else:
ans = min(ans,min(x-s[j],t[k]-x)+t[k]-s[j])
else:
if s[j] <= x:
ans = min(ans,x-t[k])
elif x <= t[k]:
ans = min(ans,s[j]-x)
else:
ans = min(ans,min(x-t[k],s[j]-x)+s[j]-t[k])
print(ans)
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
p03112
|
import sys
import bisect
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a,b,q = list(map(int,readline().split()))
jinja = [-(2*10**10+10)]
for i in range(a):
jinja.append(int(eval(input())))
tera = [-(2*10**10+10)]
for i in range(b):
tera.append(int(eval(input())))
#add big number
jinja.append(2*10**10+10)
tera.append(2*10**10+10)
for query in range(q):
x = int(eval(input()))
j_r = bisect.bisect_left(jinja,x)
j_l = jinja[j_r-1]
t_r = bisect.bisect_left(tera,x)
t_l = tera[t_r-1]
j_r = jinja[j_r]
t_r = tera[t_r]
ans = min((x-j_l)*2+(t_r-x),(x-t_l)*2+(j_r-x),(x-j_l)+(t_r-x)*2,(x-t_l)+(j_r-x)*2)
ans = min (ans,x - min(j_l,t_l), max(j_r,t_r)-x)
print(ans)
|
import sys
import bisect
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a,b,q = list(map(int,readline().split()))
jinja = [-(10**10+10)]
for i in range(a):
jinja.append(int(readline()))
tera = [-(10**10+10)]
for i in range(b):
tera.append(int(readline()))
#add big number
jinja.append(2*10**10+10)
tera.append(2*10**10+10)
for query in range(q):
x = int(readline())
j_r = bisect.bisect_left(jinja,x)
j_l = jinja[j_r-1]
t_r = bisect.bisect_left(tera,x)
t_l = tera[t_r-1]
j_r = jinja[j_r]
t_r = tera[t_r]
ans = min((x-j_l)*2+(t_r-x),(x-t_l)*2+(j_r-x),(x-j_l)+(t_r-x)*2,(x-t_l)+(j_r-x)*2)
ans = min (ans,x - min(j_l,t_l), max(j_r,t_r)-x)
print(ans)
|
p03112
|
from bisect import bisect_left
a,b,q = list(map(int, input().split()))
S = []
for _ in range(a):
S.append(int(eval(input())))
T = []
for _ in range(b):
T.append(int(eval(input())))
X = []
for _ in range(q):
X.append(int(eval(input())))
INF = 10 ** 11
def dfs(direction, tors, pos, count):
if tors == 1:
L = T
elif tors == -1:
L = S
i = bisect_left(L, pos)
if i == len(L):
if direction == 1:
return INF
elif direction == -1:
res = abs(L[i-1]-pos)
next_pos = L[i-1]
elif L[i] == pos:
res = 0
next_pos = pos
else:
if direction == 1:
res = abs(L[i]-pos)
next_pos = L[i]
elif direction == -1:
if i == 0:
return INF
res = abs(L[i-1]-pos)
next_pos = L[i-1]
if count == 1:
return res
res0 = res + dfs(direction, tors*(-1), next_pos, count-1)
res1 = res + dfs(direction*(-1), tors*(-1), next_pos, count-1)
return min(res0, res1)
for x in X:
res0 = dfs(1, 1, x, 2)
res1 = dfs(-1, 1, x, 2)
res2 = dfs(1, -1, x, 2)
res3 = dfs(-1, -1, x, 2)
print((min(res0, res1, res2, res3)))
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
p03112
|
#D問題
A,B,Q = list(map(int,(input().split())))
si = [-(10**10)]+[int(eval(input())) for _ in range(A)]+[2*(10**10)] # 範囲外に追加して、xの左右に常にデータがあるようにする
ti = [-(10**10)]+[int(eval(input())) for _ in range(B)]+[2*(10**10)]
A +=2
B +=2
for _ in [0]*Q:
x = int(eval(input()))
l = 0
r = A-1
while l+1<r:
i = (l+r)//2
if si[i]<x:
l = i
else:
r = i
sl = si[l]
sr = si[r]
l = 0
r = B-1
while l+1<r:
i = (l+r)//2
if ti[i]<x:
l = i
else:
r = i
tl = ti[l]
tr = ti[r]
dsl = x-sl
dsr = sr-x
dtl = x-tl
dtr = tr-x
print((min(max(dsr,dtr),max(dsl,dtl),dsl+dtr+min(dsl,dtr),dsr+dtl+min(dsr,dtl))))
|
#D問題
A,B,Q = list(map(int,(input().split())))
si = [-(10**10)]+[int(eval(input())) for _ in range(A)]+[2*(10**10)] # 範囲外に追加して、xの左右に常にデータがあるようにする
ti = [-(10**10)]+[int(eval(input())) for _ in range(B)]+[2*(10**10)]
xi = [int(eval(input())) for i in range(Q)]
A +=2
B +=2
for x in xi:
l = 0
r = A-1
while l+1<r:
i = (l+r)//2
if si[i]<x:
l = i
else:
r = i
sl = si[l]
sr = si[r]
l = 0
r = B-1
while l+1<r:
i = (l+r)//2
if ti[i]<x:
l = i
else:
r = i
tl = ti[l]
tr = ti[r]
dsl = x-sl
dsr = sr-x
dtl = x-tl
dtr = tr-x
print((min(max(dsr,dtr),max(dsl,dtl),dsl+dtr+min(dsl,dtr),dsr+dtl+min(dsr,dtl))))
|
p03112
|
#D問題
A,B,Q = list(map(int,(input().split())))
si = [-(10**10)]+[int(eval(input())) for _ in range(A)]+[2*(10**10)] # 範囲外に追加して、xの左右に常にデータがあるようにする
ti = [-(10**10)]+[int(eval(input())) for _ in range(B)]+[2*(10**10)]
xi = [int(eval(input())) for i in range(Q)]
A +=2
B +=2
for x in xi:
l = 0
r = A-1
while l+1<r:
i = (l+r)//2
if si[i]<x:
l = i
else:
r = i
sl = si[l]
sr = si[r]
l = 0
r = B-1
while l+1<r:
i = (l+r)//2
if ti[i]<x:
l = i
else:
r = i
tl = ti[l]
tr = ti[r]
dsl = x-sl
dsr = sr-x
dtl = x-tl
dtr = tr-x
print((min(max(dsr,dtr),max(dsl,dtl),dsl+dtr+min(dsl,dtr),dsr+dtl+min(dsr,dtl))))
|
#D問題
import sys
A,B,Q = list(map(int,(input().split())))
si = [-(10**10)]+[int(eval(input())) for _ in range(A)]+[2*(10**10)] # 範囲外に追加して、xの左右に常にデータがあるようにする
ti = [-(10**10)]+[int(eval(input())) for _ in range(B)]+[2*(10**10)]
#xi = [int(input()) for i in range(Q)]
*xi, = list(map(int,"".join(sys.stdin.readlines()).split()))
A +=2
B +=2
for x in xi:
l = 0
r = A-1
while l+1<r:
i = (l+r)//2
if si[i]<x:
l = i
else:
r = i
sl = si[l]
sr = si[r]
l = 0
r = B-1
while l+1<r:
i = (l+r)//2
if ti[i]<x:
l = i
else:
r = i
tl = ti[l]
tr = ti[r]
dsl = x-sl
dsr = sr-x
dtl = x-tl
dtr = tr-x
print((min(max(dsr,dtr),max(dsl,dtl),dsl+dtr+min(dsl,dtr),dsr+dtl+min(dsr,dtl))))
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
import bisect
import sys
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
for q in range(Q):
x = int(sys.stdin.readline())
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)
|
p03112
|
import bisect
import sys
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
for q in range(Q):
x = int(sys.stdin.readline())
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)
|
import bisect
import sys
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(sys.stdin.readline()) for i in range(Q)]
for x in xs:
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)
|
p03112
|
import bisect
import sys
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(sys.stdin.readline()) for i in range(Q)]
for x in xs:
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)
|
def solve():
import bisect
import sys
A, B, Q = list(map(int, input().split()))
INF = 10 ** 13
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(sys.stdin.readline()) for i in range(Q)]
for x in xs:
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)
if __name__ == '__main__':
solve()
|
p03112
|
from bisect import bisect_right
A , B , Q = list(map(int,input().split()))
INF = 10**20
s = [0] * A
t = [0] * B
x = [0] * Q
for i in range(A) :
s[i] = int(eval(input()))
for i in range(B) :
t[i] = int(eval(input()))
for i in range(Q) :
x[i] = int(eval(input()))
s = [-INF] + s + [INF]
t = [-INF] + t + [INF]
for p in x :
rightS = bisect_right(s,p)
rightT = bisect_right(t,p)
dist = INF
for ss in [s[rightS - 1], s[rightS]] :
for tt in [t[rightT - 1], t[rightT]] :
dist1 = abs(ss - p) + abs(ss - tt)
dist2 = abs(tt - p) + abs(tt - ss)
dist = min(dist, dist1, dist2)
print(dist)
|
from bisect import bisect_left, bisect_right
A, B, Q = map(int, input().split())
S = [int(input()) for _ in range(A)] + [float('inf'), -float('inf')]
T = [int(input()) for _ in range(B)] + [float('inf'), -float('inf')]
S.sort()
T.sort()
ans = []
for _ in range(Q):
x = int(input())
midS = bisect_right(S, x)
midT = bisect_right(T, x)
lS = S[midS - 1]
rS = S[midS]
lT = T[midT - 1]
rT = T[midT]
dist = min(
max(rS, rT) - x,
x - min(lS, lT),
abs(rS - lT) + min(rS - x, x - lT),
abs(rT - lS) + min(rT - x, x - lS)
)
ans.append(dist)
print(*ans, sep='\n')
|
p03112
|
from bisect import bisect_right, 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]
for _ in range(Q):
x = int(eval(input()))
lS, lT = S[bisect_right(S, x) - 1], T[bisect_right(T, x) - 1]
rS, rT = S[bisect_left(S, x)], T[bisect_left(T, x)]
ans = min(
abs(lS - lT) + (x - max(lS, lT)),
abs(rS - rT) + (min(rS, rT) - x),
(rT - lS) + min(x - lS, rT - x),
(rS - lT) + min(x - lT, rS - x)
)
print(ans)
|
from bisect import bisect_left
A, B, Q = list(map(int, input().split()))
INF = 10**18
S = [int(eval(input())) for _ in range(A)] + [INF, INF, -INF, -INF]
T = [int(eval(input())) for _ in range(B)] + [INF, INF, -INF, -INF]
S.sort()
T.sort()
for _ in range(Q):
x = int(eval(input()))
s = bisect_left(S, x)
ls = S[s - 1]
rs = S[s]
t = bisect_left(T, x)
lt = T[t - 1]
rt = T[t]
ans = min(
abs(ls - rt) + min(abs(x - ls), abs(x - rt)),
abs(lt - rs) + min(abs(x - lt), abs(x - rs)),
max(abs(x - ls), abs(x - lt)),
max(abs(x - rs), abs(x - rt))
)
print(ans)
|
p03112
|
import bisect
a, b, q = [ int(v) for v in input().split() ]
temple_list = [ int(eval(input())) for i in range(a) ]
shrine_list = [ int(eval(input())) for i in range(b) ]
def excursion(x):
global temple_list, shine_list
temple_west = bisect.bisect_left(temple_list,x)
shrine_west = bisect.bisect_left(shrine_list,x)
tw, te, sw, se = temple_list[(temple_west-1)%a],temple_list[temple_west%a],shrine_list[(shrine_west-1)%b],shrine_list[(shrine_west)%b]
print((min( abs(x-tw) + min(abs(sw-tw),abs(tw-se)) , abs(te-x) + min(abs(se-te),abs(te-sw)), abs(x-sw) + min(abs(tw-sw),abs(sw-te)) , abs(se-x) + min(abs(te-se),abs(se-tw)))))
return
for i in range(q):
excursion(int(eval(input())))
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = [ int(v) for v in input().split() ]
temple_list = [ int(eval(input())) for i in range(a) ]
shrine_list = [ int(eval(input())) for i in range(b) ]
def excursion(x):
global temple_list, shine_list
temple_west = bisect.bisect_left(temple_list,x)
shrine_west = bisect.bisect_left(shrine_list,x)
tw, te, sw, se = temple_list[(temple_west-1)%a],temple_list[temple_west%a],shrine_list[(shrine_west-1)%b],shrine_list[(shrine_west)%b]
print((min( abs(x-tw) + min(abs(sw-tw),abs(tw-se)) , abs(te-x) + min(abs(se-te),abs(te-sw)), abs(x-sw) + min(abs(tw-sw),abs(sw-te)) , abs(se-x) + min(abs(te-se),abs(se-tw)))))
return
for i in range(q):
excursion(int(eval(input())))
|
p03112
|
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]
s.sort()
t.sort()
import bisect
import itertools
for _ in range(Q):
pos = int(eval(input()))
s_near_id = bisect.bisect_left(s, pos)-1
t_near_id = bisect.bisect_left(t, pos)-1
print((min( min(abs(pos-s_pos)+abs(s_pos-t_pos), abs(pos-t_pos)+abs(t_pos-s_pos)) for s_pos, t_pos in itertools.product(s[s_near_id:s_near_id+2],t[t_near_id:t_near_id+2]) )))
|
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]
s.sort()
t.sort()
import bisect
import itertools
for _ in range(Q):
pos = int(eval(input()))
near_s = bisect.bisect_left(s, pos)-1
near_t = bisect.bisect_left(t, pos)-1
s1, s2 = s[near_s], s[near_s+1]
t1, t2 = t[near_t], t[near_t+1]
print((min(
pos - min(s1,t1),
max(s2,t2) - pos,
(s2 - pos) + (s2 - t1),
(pos - t1) + (s2 - t1),
(t2 - pos) + (t2 - s1),
(pos - s1) + (t2 - s1)
)))
|
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)]
def bs(z, st):
l = 0
r = len(st) - 1
while r - l != 1:
m = (l + r) // 2
if st[m] == z:
return m
elif st[m] < z:
l = m
else:
r = m
return l
for xi in x:
tmps = []
tmpt = []
if xi <= s[0]:
tmps.append(s[0] - xi)
elif s[-1] <= xi:
tmps.append(s[-1] - xi)
else:
tmp = bs(xi, s)
tmps.append(s[tmp] - xi)
tmps.append(s[tmp + 1] - xi)
if xi <= t[0]:
tmpt.append(t[0] - xi)
elif t[-1] <= xi:
tmpt.append(t[-1] - xi)
else:
tmp = bs(xi, t)
tmpt.append(t[tmp] - xi)
tmpt.append(t[tmp + 1] - xi)
anss = []
for i in tmps:
for j in tmpt:
if i // abs(i) == j // abs(j):
anss.append(max(abs(i), abs(j)))
else:
maxij = max(abs(i), abs(j))
minij = min(abs(i), abs(j))
anss.append(abs(maxij + minij * 2))
anss.sort()
print((anss[0]))
|
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 bs(z, st):
l = 0
r = len(st) - 1
while r - l != 1:
m = (l + r) // 2
if st[m] <= z:
l = m
else:
r = m
return l
for xi in x:
tmps = []
tmpt = []
if xi <= s[0]:
tmps.append(s[0] - xi)
elif s[-1] <= xi:
tmps.append(s[-1] - xi)
else:
tmp = bs(xi, s)
tmps.append(s[tmp] - xi)
tmps.append(s[tmp + 1] - xi)
if xi <= t[0]:
tmpt.append(t[0] - xi)
elif t[-1] <= xi:
tmpt.append(t[-1] - xi)
else:
tmp = bs(xi, t)
tmpt.append(t[tmp] - xi)
tmpt.append(t[tmp + 1] - xi)
anss = []
for i in tmps:
for j in tmpt:
if i // abs(i) == j // abs(j):
anss.append(max(abs(i), abs(j)))
else:
maxij = max(abs(i), abs(j))
minij = min(abs(i), abs(j))
anss.append(abs(maxij + minij * 2))
anss.sort()
print((anss[0]))
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
import bisect
a,b,q = list(map(int,input().split()))
shrine = [-10**12, 10**12]
for _ in range(a):
s = int(eval(input()))
shrine.append(s)
shrine.sort()
temple = [-10**12, 10**12]
for _ in range(b):
t = int(eval(input()))
temple.append(t)
temple.sort()
for _ in range(q):
x = int(eval(input()))
sx = bisect.bisect_right(shrine,x)
tx = bisect.bisect_right(temple,x)
ans = 10**12
for i in [shrine[sx-1], shrine[sx]]:
for j in [temple[tx-1], temple[tx]]:
case_1 = abs(i-x)+abs(i-j)
case_2 = abs(j-x)+abs(i-j)
ans = min(ans,case_1,case_2)
print(ans)
|
p03112
|
import bisect
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)]
s.append(float('inf'))
s.insert(0, -float('inf'))
t.append(float('inf'))
t.insert(0, -float('inf'))
x = [int(eval(input())) for _i in range(q)]
for i in x:
n = bisect.bisect_right(s, i)
m = bisect.bisect_right(t, i)
e = abs(max([s[n], t[m]])-i)
f = abs(i-min(s[n-1], t[m-1]))
g = min([abs(i-s[n]), abs(i-t[m-1])])+abs(s[n]-t[m-1])
h = min([abs(i-s[n-1]), abs(i-t[m])])+abs(s[n-1]-t[m])
print((min([e, f, g, h])))
|
import bisect
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)]
s.append(float('inf'))
s.insert(0, -float('inf'))
t.append(float('inf'))
t.insert(0, -float('inf'))
x = [int(eval(input())) for _i in range(q)]
for i in x:
n = bisect.bisect_right(s, i)
m = bisect.bisect_right(t, i)
print((min([abs(max([s[n], t[m]])-i), min([abs(i-s[n-1]), abs(i-t[m])])+abs(s[n-1]-t[m]), min([abs(i-s[n]), abs(i-t[m-1])])+abs(s[n]-t[m-1]), abs(i-min(s[n-1], t[m-1]))])))
|
p03112
|
def main():
inf = float("INF")
a,b,q = list(map(int, input().split()))
s = [None] * (a + 3)
s[0:2] = [-inf,-inf]
s[-1] = inf
t = [None] * (b + 3)
t[0:2] = [-inf,-inf]
t[-1] = inf
for i in range(a):
s[i+2] = int(eval(input()))
for i in range(b):
t[i+2] = int(eval(input()))
from bisect import bisect_left
dp0 = [None] * (a+3)
dp1 = [None] * (b+3)
def f(s,t,x,ss,i):
if i == 0 and dp0[ss] != None: return abs(x - s[ss]) + dp0[ss]
elif i == 1 and dp1[ss] != None: return abs(x - s[ss]) + dp1[ss]
tr = bisect_left(t, s[ss])
tl = tr - 1
if i == 0: dp0[ss] = min(abs(s[ss] - t[tl]), abs(s[ss] - t[tr]))
if i == 1: dp1[ss] = min(abs(s[ss] - t[tl]), abs(s[ss] - t[tr]))
return abs(x - s[ss]) + min(abs(s[ss] - t[tl]), abs(s[ss] - t[tr]))
for _ in range(q):
ans = inf
x = int(eval(input()))
sr = bisect_left(s, x)
ans = min(ans, f(s,t,x,sr,0))
ans = min(ans, f(s,t,x,sr - 1,0))
tr = bisect_left(t, x)
ans = min(ans, f(t,s,x,tr,1))
ans = min(ans, f(t,s,x,tr - 1,1))
print(ans)
if __name__ == "__main__":
main()
|
def main():
inf = float("INF")
a,b,q = list(map(int, input().split()))
s = [None] * (a + 3)
s[0:2] = [-inf,-inf]
s[-1] = inf
t = [None] * (b + 3)
t[0:2] = [-inf,-inf]
t[-1] = inf
for i in range(a):
s[i+2] = int(eval(input()))
for i in range(b):
t[i+2] = int(eval(input()))
from bisect import bisect_right
dp0 = [None] * (a+3)
dp1 = [None] * (b+3)
for _ in range(q):
ans = inf
x = int(eval(input()))
sr = bisect_right(s, x)
tr = bisect_right(t, x)
for si in (sr, sr-1):
for ti in (tr, tr-1):
ans = min(ans, abs(x-s[si]) + abs(s[si]-t[ti]), abs(x-t[ti]) + abs(s[si]-t[ti]))
print(ans)
if __name__ == "__main__":
main()
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
s = [0]*(A+4)
t = [0]*(B+4)
for i in range(2, A+2):
s[i] = int(eval(input()))
for i in range(2, B+2):
t[i] = int(eval(input()))
s[0], s[1], s[-2], s[-1] = -10**11-1, -10**11, 10**11, 10**11+1
t[0], t[1], t[-2], t[-1] = -10**11-1, -10**11, 10**11, 10**11+1
for i in range(Q):
x = int(eval(input()))
sh_left = bisect.bisect(s, x) - 1
sh_right = sh_left + 1
ans = 10**12
for i in range(2):
loc_sh = s[[sh_left, sh_right][i]]
dis = abs(x-loc_sh)
te_left = bisect.bisect(t, loc_sh) - 1
te_right = te_left + 1
loc_te_l = t[te_left]
loc_te_r = t[te_right]
tmp = min(dis+abs(loc_sh-loc_te_l), dis+abs(loc_sh-loc_te_r))
ans = min(ans, tmp)
te_left = bisect.bisect(t, x) - 1
te_right = te_left + 1
for i in range(2):
loc_te = t[[te_left, te_right][i]]
dis = abs(x-loc_te)
sh_left = bisect.bisect(s, loc_te) - 1
sh_right = sh_left + 1
loc_sh_l = s[sh_left]
loc_sh_r = s[sh_right]
tmp = min(dis+abs(loc_te-loc_sh_l), dis+abs(loc_te-loc_sh_r))
ans = min(ans, tmp)
print(ans)
|
from bisect import bisect_right
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]
for _ in range(Q):
x = int(eval(input()))
sh_r, te_r = bisect_right(s, x), bisect_right(t, x)
sh_l, te_l = sh_r - 1, te_r - 1
SR, SL, TR, TL = s[sh_r], s[sh_l], t[te_r], t[te_l]
ans = INF
for i in [SR, SL]:
for j in [TR, TL]:
dis = abs(i-x) + abs(i-j)
dis = min(dis, abs(j-x) + abs(j-i))
ans = min(ans, dis)
print(ans)
|
p03112
|
a,b,q = list(map(int,input().split()))
jinjya = []
otera = []
for i in range(a):
jinjya.append(int(eval(input())))
for i in range(b):
otera.append(int(eval(input())))
def find(arr,tar,start,end):
if start >= end:
return start
bar = (start+end)//2
if arr[bar]<tar:
return find(arr,tar,bar+1,end)
elif arr[bar]>tar:
return find(arr,tar,start,bar-1)
else:
return bar
for i in range(q):
jinjyaEast = 0
jinjyaWest = 0
oteraEast = 0
oteraWest = 0
pos = int(eval(input()))
idx = find(jinjya,pos,0,len(jinjya)-1)
if(jinjya[idx] < pos):
jinjyaWest = jinjya[idx]
if idx<len(jinjya)-1:
jinjyaEast = jinjya[idx+1]
else:
jinjyaEast = jinjya[idx]
if idx>0:
jinjyaWest = jinjya[idx-1]
idx = find(otera,pos,0,len(otera)-1)
if(otera[idx] < pos):
oteraWest = otera[idx]
if idx<len(otera)-1:
oteraEast = otera[idx+1]
else:
oteraEast = otera[idx]
if idx>0:
oteraWest = otera[idx-1]
res = []
j = []
o = []
if jinjyaWest != 0:
j.append(jinjyaWest)
if jinjyaEast != 0:
j.append(jinjyaEast)
if oteraWest != 0:
o.append(oteraWest)
if oteraEast != 0:
o.append(oteraEast)
for a in j:
for b in o:
res.append(min(abs(pos-a)+abs(b-a),abs(pos-b)+abs(a-b)))
print((min(res)))
|
import bisect
a,b,q = list(map(int,input().split()))
jinjya = []
otera = []
for i in range(a):
jinjya.append(int(eval(input())))
for i in range(b):
otera.append(int(eval(input())))
INF = 10**18
jinjya = [-INF] + jinjya + [INF]
otera = [-INF] + otera + [INF]
for i in range(q):
res = INF
pos = int(eval(input()))
j,o = bisect.bisect_right(jinjya,pos),bisect.bisect_right(otera,pos)
for a in [jinjya[j-1],jinjya[j]]:
for b in [otera[o-1],otera[o]]:
res = min(res,abs(pos-a)+abs(a-b),abs(pos-b)+abs(a-b))
print(res)
|
p03112
|
import bisect
a, b, q = list(map(int, input().split()))
s, t = [0]*(a+2), [0]*(b+2)
for i in range(a):
s[i+1] = int(eval(input()))
for i in range(b):
t[i+1] = int(eval(input()))
s[0] = -float("inf")
s[-1] = float("inf")
t[0] = -float("inf")
t[-1] = float("inf")
#print(s)
#print(t)
for _ in range(q):
start = int(eval(input()))
x = bisect.bisect_right(s, start)
y = bisect.bisect_right(t, start)
ans = float("inf")
for i in [s[x], s[x-1]]:
for j in [t[y], t[y-1]]:
res = min(abs(i-start) + abs(j-i), abs(j-start) + abs(i-j))
ans = min(ans, res)
print(ans)
|
import bisect
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]
#print(s)
#print(t)
for _ in range(q):
start = int(eval(input()))
x = bisect.bisect_right(s, start)
y = bisect.bisect_right(t, start)
ans = inf
for i in [s[x], s[x-1]]:
for j in [t[y], t[y-1]]:
res = min(abs(i-start) + abs(j-i), abs(j-start) + abs(i-j))
ans = min(ans, res)
print(ans)
|
p03112
|
# baseline
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
n = len(values)
self.left = [-1] * (n+1)
self.right = [-1] * (n+1)
self.values = [-float("inf")] + values
self.diff = [0] * (n+1) # left - right
self.size_l = [0] * (n+1)
if not sorted_:
values.sort()
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2
if self.values[c] < self.values[idx_par]: # 親の左
self.left[idx_par] = c
else:
self.right[idx_par] = c
siz = r - l
if siz & -siz == siz and siz != 1: # 2冪だったら
self.diff[c] = 1
siz_l = c - l
self.size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
idx = self.right[0]
res = 0
while idx != -1:
value = self.values[idx]
if value == x:
return res + self.size_l[idx]
elif value < x:
res += self.size_l[idx] + 1
idx = self.right[idx]
else:
idx = self.left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x and A - 1 >= x:
return True
return False
def g(x):
if 0 <= x and B - 1 >= x:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
# baseline!?
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
n = len(values)
self.left = [-1] * (n+1)
self.right = [-1] * (n+1)
self.values = [-float("inf")] + values
self.diff = [0] * (n+1) # left - right
self.size_l = [0] * (n+1)
if not sorted_:
values.sort()
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2
if self.values[c] < self.values[idx_par]:
self.left[idx_par] = c
else:
self.right[idx_par] = c
siz = r - l
if siz & -siz == siz and siz != 1: # 2冪だったら
self.diff[c] = 1
siz_l = c - l
self.size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
idx = self.right[0]
res = 0
while idx != -1:
value = self.values[idx]
if value == x:
return res + self.size_l[idx]
elif value < x:
res += self.size_l[idx] + 1
idx = self.right[idx]
else:
idx = self.left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x and A - 1 >= x:
return True
return False
def g(x):
if 0 <= x and B - 1 >= x:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
p03112
|
# __slots__
class AvlTree: # std::set
__slots__ = ["left", "right", "values", "diff", "size_l"]
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self.left = [-1] * (n+1)
self.right = [-1] * (n+1)
self.values = [-float("inf")] + values
self.diff = [0] * (n+1) # left - right
self.size_l = [0] * (n+1)
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2
if self.values[c] < self.values[idx_par]:
self.left[idx_par] = c
else:
self.right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self.diff[c] = 1
siz_l = c - l
self.size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x and A - 1 >= x:
return True
return False
def g(x):
if 0 <= x and B - 1 >= x:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
# _ _
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self.left = [-1] * (n+1)
self.right = [-1] * (n+1)
self.values = [-float("inf")] + values
self.diff = [0] * (n+1) # left - right
self.size_l = [0] * (n+1)
self_values = self.values
self_left = self.left
self_right = self.right
self_size_l = self.size_l
self_diff = self.diff
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2
if self_values[c] < self_values[idx_par]:
self_left[idx_par] = c
else:
self_right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self_diff[c] = 1
siz_l = c - l
self_size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x and A - 1 >= x:
return True
return False
def g(x):
if 0 <= x and B - 1 >= x:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
p03112
|
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self_left = self.left = [-1] * (n+1)
self_right = self.right = [-1] * (n+1)
self_values = self.values = [-float("inf")] + values
self_diff = self.diff = [0] * (n+1) # left - right
self_size_l = self.size_l = [0] * (n+1)
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2
if self_values[c] < self_values[idx_par]:
self_left[idx_par] = c
else:
self_right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self_diff[c] = 1
siz_l = c - l
self_size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x < A:
return True
return False
def g(x):
if 0 <= x < B:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self_left = self.left = [-1] * (n+1)
self_right = self.right = [-1] * (n+1)
self_values = self.values = [-float("inf")] + values
self_diff = self.diff = [0] * (n+1) # left - right
self_size_l = self.size_l = [0] * (n+1)
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) >> 1 # pypy -> >>1
if self_values[c] < self_values[idx_par]:
self_left[idx_par] = c
else:
self_right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self_diff[c] = 1
siz_l = c - l
self_size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x < A:
return True
return False
def g(x):
if 0 <= x < B:
return True
return False
for i in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if f(p) and g(m):
res.append(max(T[m], S[p]) - x)
if f(p) and g(m - 1):
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if f(p - 1) and g(m):
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if f(p - 1) and g(m - 1):
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
p03112
|
# クエリ処理部分を改善
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self_left = self.left = [-1] * (n+1)
self_right = self.right = [-1] * (n+1)
self_values = self.values = [-float("inf")] + values
self_diff = self.diff = [0] * (n+1) # left - right
self_size_l = self.size_l = [0] * (n+1)
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2 # pypy -> >>1
if self_values[c] < self_values[idx_par]:
self_left[idx_par] = c
else:
self_right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self_diff[c] = 1
siz_l = c - l
self_size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
def f(x):
if 0 <= x < A:
return True
return False
def g(x):
if 0 <= x < B:
return True
return False
for _ in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
res = []
if p < A:
if m < B:
res.append(max(T[m], S[p]) - x)
if 0 <= m - 1:
res.append(min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if 0 <= p - 1:
if m < B:
res.append(T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if 0 <= m - 1:
res.append(x - min(T[m - 1], S[p - 1]))
print((min(res)))
|
# クエリ処理改善2
class AvlTree: # std::set
def __init__(self, values=None, sorted_=False):
if values is None:
self.left = [-1]
self.right = [-1]
self.values = [-float("inf")]
self.diff = [0] # left - right
self.size_l = [0]
else:
if not sorted_:
values.sort()
n = len(values)
self_left = self.left = [-1] * (n+1)
self_right = self.right = [-1] * (n+1)
self_values = self.values = [-float("inf")] + values
self_diff = self.diff = [0] * (n+1) # left - right
self_size_l = self.size_l = [0] * (n+1)
st = [[1, n+1, 0]]
while len(st) > 0:
l, r, idx_par = st.pop() # 半開区間
c = (l+r) // 2 # pypy -> >>1
if self_values[c] < self_values[idx_par]:
self_left[idx_par] = c
else:
self_right[idx_par] = c
siz = r - l
if siz & -siz == siz != 1: # 2冪だったら
self_diff[c] = 1
siz_l = c - l
self_size_l[c] = siz_l
if siz_l > 0:
st.append([l, c, c])
c1 = c + 1
if c1 < r: # 左にノードがなければ右には必ず無いので
st.append([c1, r, c])
# def print(self):
# print(f"left ={self.left}")
# print(f"right ={self.right}")
# print(f"values={self.values}")
# print(f"diff ={self.diff}")
# print(f"dixr_l={self.size_l}")
def rotate_right(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_l = self.left[idx]
assert idx_l != -1 # 左の子が存在する
# 部分木の大きさの計算
self.size_l[idx] -= self.size_l[idx_l] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_l] # 左の子の高さの差
if b >= 0:
na = a - 1 - b
if na >= 0:
nb = b - 1
else:
nb = a - 2
else:
na = a - 1
if na >= 0:
nb = b - 1
else:
nb = a + b - 2
self.diff[idx] = na
self.diff[idx_l] = nb
# 回転
self.left[idx] = self.right[idx_l]
self.right[idx_l] = idx
if lr==0:
self.left[idx_par] = idx_l
else:
self.right[idx_par] = idx_l
def rotate_left(self, idx_par, lr): # lr: 親の左なら 0
idx = self.left[idx_par] if lr==0 else self.right[idx_par]
idx_r = self.right[idx]
assert idx_r != -1 # 右の子が存在する
# 部分木の大きさの計算
self.size_l[idx_r] += self.size_l[idx] + 1
# 高さの計算
a = self.diff[idx]
b = self.diff[idx_r] # 右の子の高さの差
if b <= 0:
na = a + 1 - b
if na <= 0:
nb = b + 1
else:
nb = a + 2
else:
na = a + 1
if na <= 0:
nb = b + 1
else:
nb = a + b + 2
self.diff[idx] = na
self.diff[idx_r] = nb
# 回転
self.right[idx] = self.left[idx_r]
self.left[idx_r] = idx
if lr == 0:
self.left[idx_par] = idx_r
else:
self.right[idx_par] = idx_r
def add(self, x): # insert
idx = 0
path = []
path_left = []
while idx != -1:
path.append(idx)
value = self.values[idx]
if x == value:
return # 重複を許さない
elif x < value:
path_left.append(idx)
idx = self.left[idx]
else:
idx = self.right[idx]
if x < value:
self.left[path[-1]] = len(self.values)
else:
self.right[path[-1]] = len(self.values)
self.left.append(-1)
self.right.append(-1)
self.values.append(x)
self.diff.append(0)
self.size_l.append(0)
for idx_ in path_left:
self.size_l[idx_] += 1
self.diff[path[-1]] += 1 if x < value else -1
for idx, idx_par in zip(path[:0:-1], path[-2::-1]):
diff = self.diff[idx]
if diff == 0:
return
elif diff == 2: # 右回転
idx_l = self.left[idx] # 左の子
if self.diff[idx_l] == -1: # 左右のパターン
self.rotate_left(idx, 0)
self.rotate_right(idx_par, self.right[idx_par]==idx)
return
elif diff == -2: # 左回転
idx_r = self.right[idx] # 右の子
if self.diff[idx_r] == 1: # 右左のパターン
self.rotate_right(idx, 1)
self.rotate_left(idx_par, self.right[idx_par]==idx)
return
else:
self.diff[idx_par] += 1 if self.left[idx_par]==idx else -1
def remove(self): # erase
raise NotImplementedError
def __contains__(self, x): # count
raise NotImplementedError
def bisect_left(self, x): # lower_bound
self_left = self.left
self_right = self.right
self_values = self.values
self_size_l = self.size_l
idx = self_right[0]
res = 0
while idx != -1:
value = self_values[idx]
if value == x:
return res + self_size_l[idx]
elif value < x:
res += self_size_l[idx] + 1
idx = self_right[idx]
else:
idx = self_left[idx]
return res
def bisect_right(self): # upper_bound
raise NotImplementedError
from bisect import bisect_left
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)]
avl_S = AvlTree(S, True)
avl_T = AvlTree(T, True)
for _ in range(Q):
x = int(eval(input()))
p = avl_S.bisect_left(x)
m = avl_T.bisect_left(x)
mi = 1<<60
if p < A:
if m < B:
mi = min(mi, max(T[m], S[p]) - x)
if 0 <= m - 1:
mi = min(mi, min(S[p] - x, x - T[m - 1]) + S[p] - T[m - 1])
if 0 <= p - 1:
if m < B:
mi = min(mi, T[m] - S[p - 1] + min(T[m] - x, x - S[p - 1]))
if 0 <= m - 1:
mi = min(mi, x - min(T[m - 1], S[p - 1]))
print(mi)
|
p03112
|
import bisect
def main():
a,b,q = list(map(int, input().split()))
sl = [int(eval(input())) for _ in range(a)]
tl = [int(eval(input())) for _ in range(b)]
xl = [int(eval(input())) for _ in range(q)]
for x in xl:
ans = 10**11
curr_dist = 0
ind_s = bisect.bisect_left(sl, x)
ind_t = bisect.bisect_left(tl, x)
for next_s in [ind_s, ind_s-1]:
if 0 <= next_s < a:
curr_dist = abs(x-sl[next_s])
curr_pos = sl[next_s]
ind_t2 = bisect.bisect_left(tl, curr_pos)
if ind_t2 == 0:
curr_dist += abs(tl[0] - curr_pos)
elif ind_t2 == b:
curr_dist += abs(tl[b-1] - curr_pos)
else:
curr_dist += min( abs( tl[ind_t2-1] - curr_pos), abs(tl[ind_t2]-curr_pos))
ans = min(curr_dist, ans)
for next_t in [ind_t, ind_t-1]:
if 0 <= next_t < b:
curr_dist = abs(x-tl[next_t])
curr_pos = tl[next_t]
ind_s2 = bisect.bisect_left(sl, curr_pos)
if ind_s2 == 0:
curr_dist += abs(sl[0] - curr_pos)
elif ind_s2 == a:
curr_dist += abs(sl[a-1] - curr_pos)
else:
curr_dist += min( abs( sl[ind_s2-1] - curr_pos), abs(sl[ind_s2]-curr_pos))
ans = min(curr_dist, ans)
print(ans)
if __name__ == "__main__":
main()
|
import bisect
import sys
input = sys.stdin.readline
def main():
a,b,q = list(map(int, input().split()))
sl = [int(eval(input())) for _ in range(a)]
tl = [int(eval(input())) for _ in range(b)]
xl = [int(eval(input())) for _ in range(q)]
for x in xl:
ans = 10**11
curr_dist = 0
ind_s = bisect.bisect_left(sl, x)
ind_t = bisect.bisect_left(tl, x)
for next_s in [ind_s, ind_s-1]:
if 0 <= next_s < a:
curr_dist = abs(x-sl[next_s])
curr_pos = sl[next_s]
ind_t2 = bisect.bisect_left(tl, curr_pos)
if ind_t2 == 0:
curr_dist += abs(tl[0] - curr_pos)
elif ind_t2 == b:
curr_dist += abs(tl[b-1] - curr_pos)
else:
curr_dist += min( abs( tl[ind_t2-1] - curr_pos), abs(tl[ind_t2]-curr_pos))
ans = min(curr_dist, ans)
for next_t in [ind_t, ind_t-1]:
if 0 <= next_t < b:
curr_dist = abs(x-tl[next_t])
curr_pos = tl[next_t]
ind_s2 = bisect.bisect_left(sl, curr_pos)
if ind_s2 == 0:
curr_dist += abs(sl[0] - curr_pos)
elif ind_s2 == a:
curr_dist += abs(sl[a-1] - curr_pos)
else:
curr_dist += min( abs( sl[ind_s2-1] - curr_pos), abs(sl[ind_s2]-curr_pos))
ans = min(curr_dist, ans)
print(ans)
if __name__ == "__main__":
main()
|
p03112
|
from bisect import bisect_left as bl
A,B,Q=list(map(int,input().split()))
S=[]
T=[]
X=[]
for i in range(A):
S.append(int(eval(input())))
for i in range(B):
T.append(int(eval(input())))
def rl(X,a):
ind=bl(X,a)
if ind>=len(X):
return ind-1
return ind
def ll(X,a):
ind=bl(X,a)-1
if ind<0:
return ind+1
return ind
def l(X,a):
ind=bl(X,a)
if ind>=len(X):
ind1=ind-1
return (ind1,ind1)
elif ind-1<0:
return (ind,ind)
else:
return (ind,ind-1)
t=[]
for i in range(A):
ind1,ind2=l(T,S[i])
mi=min(abs(T[ind1]-S[i]),abs(T[ind2]-S[i]))
t.append(mi)
"""
if abs(T[rl(T,S[i])]-S[i])>=abs(T[ll(T,S[i])]-S[i]):
t.append(abs(T[ll(T,S[i])]-S[i]))
else:
t.append(abs(T[rl(T,S[i])])-S[i])
"""
s=[]
for i in range(B):
ind1,ind2=l(S,T[i])
mi=min(abs(S[ind1]-T[i]),abs(S[ind2]-T[i]))
s.append(mi)
"""
if abs(S[rl(S,T[i])]-T[i])>=abs(S[ll(S,T[i])]-T[i]):
s.append(abs(S[ll(S,T[i])]-T[i]))
else:
s.append(abs(S[rl(S,T[i])])-T[i])
"""
for i in range(Q):
x=int(eval(input()))
a=rl(S,x)
a=t[a]+abs(S[a]-x)
b=ll(S,x)
b=t[b]+abs(S[b]-x)
c=rl(T,x)
c=s[c]+abs(T[c]-x)
d=ll(T,x)
d=s[d]+abs(T[d]-x)
print((min(a,b,c,d)))
|
from bisect import bisect_left as bl
A,B,Q=list(map(int,input().split()))
S=[]
T=[]
X=[]
INF=10**18
S.append(-INF)
T.append(-INF)
for i in range(A):
S.append(int(eval(input())))
for i in range(B):
T.append(int(eval(input())))
S.append(INF)
T.append(INF)
for i in range(Q):
x=int(eval(input()))
b,d=bl(S,x),bl(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)
|
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)]
def bs(x, L, ub, lb):
if x < L[0]:
return -1
if x > L[-1]:
return len(L)-1
c = (ub+lb)//2
if ub-lb <= 1:
return c
if L[c] >= x:
return bs(x, L, c, lb)
else:
return bs(x, L, ub, c)
for i in range(Q):
s_l = bs(X[i], S, A-1, 0)
t_l = bs(X[i], T, B-1, 0)
if s_l < 0:
sl = 10**11
su = S[0]-X[i]
elif s_l == A-1:
sl = X[i]-S[s_l]
su = 10**11
else:
sl = X[i]-S[s_l]
su = S[s_l+1]-X[i]
if t_l < 0:
tl = 10**11
tu = T[0]-X[i]
elif t_l == B-1:
tl = X[i]-T[t_l]
tu = 10**11
else:
tl = X[i]-T[t_l]
tu = T[t_l+1]-X[i]
ans = min(max(su, tu), max(sl, tl), su*2+tl, tl*2+su, sl*2+tu, tu*2+sl)
print(ans)
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
p03112
|
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]
X = [int(eval(input())) for _ in range(Q)]
def binary_search(q, A):
l, r = 0, len(A)
while r - l > 1:
mid = (l + r) // 2
if q > A[mid]:
l = mid
else:
r = mid
return A[l], A[r]
def main():
for x in X:
s1, s2 = binary_search(x, S)
t1, t2 = binary_search(x, T)
print((min(abs(s-t) + min(abs(s-x), abs(t-x)) for s in [s1, s2] for t in [t1, t2])))
return
if __name__ == '__main__':
main()
|
import sys
import bisect
A, B, Q = list(map(int, sys.stdin.readline().split()))
INF = 10 ** 18
S = [-INF] + [int(sys.stdin.readline()) for _ in range(A)] + [INF]
T = [-INF] + [int(sys.stdin.readline()) for _ in range(B)] + [INF]
X = [int(sys.stdin.readline()) for _ in range(Q)]
# def binary_search(q, A):
# l, r = 0, len(A)
# while r - l > 1:
# mid = (l + r) // 2
# if q > A[mid]:
# l = mid
# else:
# r = mid
# return A[l], A[r]
def main():
for x in X:
ids, idt = bisect.bisect_right(S, x), bisect.bisect_right(T, x)
print((min(abs(s-t) + min(abs(s-x), abs(t-x)) for s in S[ids-1:ids+1] for t in T[idt-1:idt+1])))
return
if __name__ == '__main__':
main()
|
p03112
|
from collections import deque
import bisect
a, b, q = [int(x) for x in input().split()]
s = [int(eval(input())) for i in range(a)]
t = [int(eval(input())) for i in range(b)]
#x = [int(input()) for i in range(q)]
s_que = deque(s)
s_que.appendleft(-10 ** 12)
s_que.append(10 ** 12)
t_que = deque(t)
t_que.appendleft(-10 ** 12)
t_que.append(10 ** 12)
for i in range(q):
x = int(eval(input()))
k = bisect.bisect_left(s_que, x)
sb = s_que[k]
sa = s_que[k-1]
j = bisect.bisect_left(t_que, x)
tb = t_que[j]
ta = t_que[j-1]
y = []
for h in [sa, sb]:
for g in [ta, tb]:
y.append(abs(x-h) + abs(h-g))
for h in [ta, tb]:
for g in [sa, sb]:
y.append(abs(x-h) + abs(h-g))
print((min(y)))
|
#from collections import deque
import bisect
a, b, q = [int(x) for x in input().split()]
s = [-10**12] + [int(eval(input())) for i in range(a)] + [10**12]
t = [-10**12] + [int(eval(input())) for i in range(b)] + [10**12]
#x = [int(input()) for i in range(q)]
#s_que = deque(s)
#s_que.appendleft(-10 ** 12)
#s_que.append(10 ** 12)
#t_que = deque(t)
#t_que.appendleft(-10 ** 12)
#t_que.append(10 ** 12)
for i in range(q):
x = int(eval(input()))
k = bisect.bisect_left(s, x)
sb = s[k]
sa = s[k-1]
j = bisect.bisect_left(t, x)
tb = t[j]
ta = t[j-1]
y = []
for h in [sa, sb]:
for g in [ta, tb]:
y.append(abs(x-h) + abs(h-g))
for h in [ta, tb]:
for g in [sa, sb]:
y.append(abs(x-h) + abs(h-g))
print((min(y)))
|
p03112
|
import sys
sys.setrecursionlimit(10000)
def my_search(l, low, high, t):
n = (low+high)//2
if t > l[n]:
low = n
else:
high = n
if high == low + 1:
return low
else:
return my_search(l, low, high, t)
a,b,q = [int(_) for _ in input().split()]
s_l = [-float('inf')]
t_l = [-float('inf')]
x_l = []
for i in range(a):
s_l.append(int(eval(input())))
s_l.append(float('inf'))
for i in range(b):
t_l.append(int(eval(input())))
t_l.append(float('inf'))
for i in range(q):
x_l.append(int(eval(input())))
for i in range(q):
x = x_l[i]
s1_id = my_search(s_l, 0, len(s_l)-1, x)
s2_id = s1_id + 1
s1 = s_l[s1_id]
s2 = s_l[s2_id]
t1_id = my_search(t_l, 0, len(t_l)-1, x)
t2_id = t1_id + 1
t1 = t_l[t1_id]
t2 = t_l[t2_id]
res = float('inf')
for s in [s1,s2]:
for t in [t1,t2]:
d1, d2 = abs(s-x) + abs(t-s), abs(t-x) + abs(s-t)
res = min(res, d1, d2)
print(res)
|
import bisect
a,b,q = [int(_) for _ in input().split()]
s_l = [-float('inf')]
t_l = [-float('inf')]
x_l = []
for i in range(a):
s_l.append(int(eval(input())))
s_l.append(float('inf'))
for i in range(b):
t_l.append(int(eval(input())))
t_l.append(float('inf'))
for i in range(q):
x_l.append(int(eval(input())))
for i in range(q):
x = x_l[i]
s1_id = bisect.bisect_left(s_l, x) - 1
s2_id = s1_id + 1
s1 = s_l[s1_id]
s2 = s_l[s2_id]
t1_id = bisect.bisect_left(t_l, x) - 1
t2_id = t1_id + 1
t1 = t_l[t1_id]
t2 = t_l[t2_id]
res = float('inf')
for s in [s1,s2]:
for t in [t1,t2]:
d1, d2 = abs(s-x) + abs(t-s), abs(t-x) + abs(s-t)
res = min(res, d1, d2)
print(res)
|
p03112
|
from bisect import bisect_left, bisect_right
def func(x, y, z):
yi = bisect_right(y, x)
if yi == 0 or yi == len(y):
ans = 0
if yi == len(y):
yi -= 1
ans += abs(y[yi] - x)
x = y[yi]
zi = bisect_right(z, x)
ans += min(abs(z[zi % len(z)] - x), abs(z[(zi-1) % len(z)] - x))
return ans
else:
ans1 = ans2 = 0
ans1 += abs(y[yi-1] - x)
x1 = y[yi-1]
zi = bisect_right(z, x1)
ans1 += min(abs(z[zi % len(z)] - x1), abs(z[(zi-1) % len(z)] - x1))
ans2 += abs(y[yi] - x)
x2 = y[yi]
zi = bisect_right(z, x2)
ans2 += min(abs(z[zi % len(z)] - x2), abs(z[(zi-1) % len(z)] - x2))
return min(ans1, ans2)
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(a)]
t = [int(eval(input())) for _ in range(b)]
for _ in range(q):
x = int(eval(input()))
print((min(func(x, s, t), func(x, t, s))))
|
from bisect import bisect_right
a, b, q = list(map(int, input().split()))
INF = 10**11
s = [-INF] + [int(eval(input())) for _ in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for _ in range(b)] + [INF]
for _ in range(q):
x = int(eval(input()))
si = bisect_right(s, x)
ti = bisect_right(t, x)
ans = INF * 10
for ss in [s[si-1], s[si]]:
for tt in [t[ti-1], t[ti]]:
ans = min(ans,
abs(x - ss) + abs(ss - tt),
abs(x - tt) + abs(tt - ss))
print(ans)
|
p03112
|
import bisect
from itertools import product
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
r1 = bisect.bisect_right(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
if 0 <= r1 <= ab[i]-1:
cand1.add(st[r1])
if 0 <= r1+1 <= ab[i]-1:
cand1.add(st[r1+1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
import sys
import bisect
from itertools import product
def input(): return sys.stdin.readline().strip()
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
r1 = bisect.bisect_right(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
if 0 <= r1 <= ab[i]-1:
cand1.add(st[r1])
if 0 <= r1+1 <= ab[i]-1:
cand1.add(st[r1+1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
p03112
|
import sys
import bisect
from itertools import product
def input(): return sys.stdin.readline().strip()
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
r1 = bisect.bisect_right(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
if 0 <= r1 <= ab[i]-1:
cand1.add(st[r1])
if 0 <= r1+1 <= ab[i]-1:
cand1.add(st[r1+1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
import sys
import bisect
from itertools import product
def input(): return sys.stdin.readline().strip()
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
r1 = bisect.bisect_right(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
p03112
|
import sys
import bisect
from itertools import product
def input(): return sys.stdin.readline().strip()
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
r1 = bisect.bisect_right(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
import sys
import bisect
from itertools import product
def input(): return sys.stdin.readline().strip()
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)]
stlist = [s,t]
ab = [A,B]
for i in range(Q):
x = int(eval(input()))
cand = []
for i in range(2):
st = stlist[i]
cand1 = set()
l1 = bisect.bisect_left(st,x)
if 0 <= l1 <= ab[i]-1:
cand1.add(st[l1])
if 0 <= l1-1 <= ab[i]-1:
cand1.add(st[l1-1])
cand.append(cand1)
ans = float('inf')
for a,b in product(cand[0],cand[1]):
c = min(abs(x-a)+abs(b-a),abs(x-b)+abs(b-a))
ans = min(ans,c)
print(ans)
|
p03112
|
A, B, Q = list(map(int,input().split()))
ss = [-10**10]+[int(eval(input())) for _ in range(A)]+[2*10**10]
ts = [-10**10]+[int(eval(input())) for _ in range(B)]+[2*10**10]
# xs = [int(input()) for _ in range(Q)]
def binarysearch(ls,x):
n = len(ls)
width = n//2
pos = n//2
while True:
width = (width+1)//2
if ls[pos] < x < ls[pos+1]:
index = pos
break
elif x < ls[pos]:
pos -= width
elif ls[pos+1] < x:
pos += width
pos = min(n-1,pos)
pos = max(pos,0)
return index
# for x in xs:
for i in range(Q):
x = int(eval(input()))
sind = binarysearch(ss,x)
tind = binarysearch(ts,x)
s0,s1,t0,t1 = ss[sind],ss[sind+1],ts[tind],ts[tind+1]
d1,d2,d3,d4 = 10**10,10**10,10**10,10**10
d1 = max(x-s0,x-t0)
d2 = min((t1-x)*2+(x-s0),(x-s0)*2+(t1-x))
d3 = min((s1-x)*2+(x-t0),(x-t0)*2+(s1-x))
d4 = max(s1-x, t1-x)
print((min(d1,d2,d3,d4)))
|
from bisect import bisect_right as binarysearch
A, B, Q = list(map(int,input().split()))
ss = [-10**10]+[int(eval(input())) for _ in range(A)]+[2*10**10]
ts = [-10**10]+[int(eval(input())) for _ in range(B)]+[2*10**10]
xs = [int(eval(input())) for _ in range(Q)]
for x in xs:
sind = binarysearch(ss,x)-1
tind = binarysearch(ts,x)-1
s0,s1,t0,t1 = ss[sind],ss[sind+1],ts[tind],ts[tind+1]
d1,d2,d3,d4 = 10**10,10**10,10**10,10**10
d1 = max(x-s0,x-t0)
d2 = min((t1-x)*2+(x-s0),(x-s0)*2+(t1-x))
d3 = min((s1-x)*2+(x-t0),(x-t0)*2+(s1-x))
d4 = max(s1-x, t1-x)
print((min(d1,d2,d3,d4)))
|
p03112
|
def main():
a,b,q = list(map(int,input().split()))
A = []
B = []
for _ in range(a):
A.append(int(eval(input())))
for _ in range(b):
B.append(int(eval(input())))
def search(A,x):
left =0
right = len(A)-1
if x<A[0]:
return (float('inf'),0)
if x >A[-1]:
return (right,float('inf'))
while left != right-1:
center = (left+right)//2
if A[center] > x:
right = center
else:
left = center
return (left,right)
def dist(A,x,lr):
if lr == float('inf'):
return float('inf')
return abs(x - A[lr])
for _ in range(q):
x = int(eval(input()))
sl,sr = search(A,x)
tl,tr = search(B,x)
sl = dist(A,x,sl)
sr = dist(A,x,sr)
tl = dist(B,x,tl)
tr = dist(B,x,tr)
p1 = min(sl,sr)+min(tl,tr)+min(min(sl,sr),min(tl,tr))
p2 = max(sl,tl)
p3 = max(sr,tr)
print((min(p1,p2,p3)))
if __name__ == '__main__':
main()
|
def main():
a,b,q = list(map(int,input().split()))
A = []
B = []
for _ in range(a):
A.append(int(eval(input())))
for _ in range(b):
B.append(int(eval(input())))
def search(A,x):
left =0
right = len(A)-1
if x<A[0]:
return (float('inf'),abs(x - A[left]))
if x >A[-1]:
return (abs(x - A[right]),float('inf'))
while left != right-1:
center = (left+right)//2
if A[center] > x:
right = center
else:
left = center
return (abs(x - A[left]),abs(x - A[right]))
def dist(A,x,lr):
if lr == float('inf'):
return float('inf')
return abs(x - A[lr])
for _ in range(q):
x = int(eval(input()))
sl,sr = search(A,x)
tl,tr = search(B,x)
p1 = min(sl,sr)+min(tl,tr)+min(min(sl,sr),min(tl,tr))
p2 = max(sl,tl)
p3 = max(sr,tr)
print((min(p1,p2,p3)))
if __name__ == '__main__':
main()
|
p03112
|
def main():
a,b,q = list(map(int,input().split()))
A = []
B = []
for _ in range(a):
A.append(int(eval(input())))
for _ in range(b):
B.append(int(eval(input())))
def search(A,x):
left =0
right = len(A)-1
if x<A[0]:
return (float('inf'),abs(x - A[left]))
if x >A[-1]:
return (abs(x - A[right]),float('inf'))
while left != right-1:
center = (left+right)//2
if A[center] > x:
right = center
else:
left = center
return (abs(x - A[left]),abs(x - A[right]))
def dist(A,x,lr):
if lr == float('inf'):
return float('inf')
return abs(x - A[lr])
for _ in range(q):
x = int(eval(input()))
sl,sr = search(A,x)
tl,tr = search(B,x)
print((min(min(sl,sr)+min(tl,tr)+min(min(sl,sr),min(tl,tr)),max(sl,tl),max(sr,tr))))
if __name__ == '__main__':
main()
|
import sys
readline = sys.stdin.readline
def main():
a,b,q = list(map(int,readline().split()))
A = [int(readline()) for i in range(a)]
B = [int(readline()) for i in range(b)]
def search(A,x):
left =0
right = len(A)-1
if x<A[0]:
return (float('inf'),abs(x - A[left]))
if x >A[-1]:
return (abs(x - A[right]),float('inf'))
while left != right-1:
center = (left+right)//2
if A[center] > x:
right = center
else:
left = center
return (abs(x - A[left]),abs(x - A[right]))
def dist(A,x,lr):
if lr == float('inf'):
return float('inf')
return abs(x - A[lr])
for _ in range(q):
x = int(readline())
sl,sr = search(A,x)
tl,tr = search(B,x)
print((min(min(sl,sr)+min(tl,tr)+min(min(sl,sr),min(tl,tr)),max(sl,tl),max(sr,tr))))
if __name__ == '__main__':
main()
|
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()))
b, d = bisect.bisect_left(s, x), bisect.bisect_left(t, x)
ans = 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)
ans = min(ans, d1, d2)
print(ans)
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
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()))
b, d = bisect.bisect_left(s, x), bisect.bisect_left(t, x)
ans = 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)
ans = min(ans, d1, d2)
print(ans)
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
s = [None] * A
t = [None] * B
x = [None] * Q
for i in range(A):
s[i] = int(eval(input()))
for i in range(B):
t[i] = int(eval(input()))
for i in range(Q):
x[i] = int(eval(input()))
s.sort()
t.sort()
def calc(s, t, x):
len_s = len(s)
len_t = len(t)
def f_nishi_pos(l, x):
p1 = bisect.bisect_left(l, x)
p2 = bisect.bisect_right(l, x)
if p2 == len(l):
return p1-1
if l[p1] == l[p2]:
return max(p2-1, 0)
else:
return p1
def f_higashi_pos(l, x):
p1 = bisect.bisect_left(l, x)
p2 = bisect.bisect_right(l, x)
if p1 == len(l):
return p1-1
if l[p1] == l[p2]:
return min(p1, len(l)-1)
else:
return p1
# 神社 -> 寺
## 西の神社
j_nishi_pos = f_nishi_pos(s, x)
j_nishi = s[j_nishi_pos]
## 東の神社
j_higashi_pos = f_higashi_pos(s, x)
j_higashi = s[j_higashi_pos]
## 西の神社の西の寺
j_nishi_t_nishi_pos = f_nishi_pos(t, j_nishi)
j_nishi_t_nishi = t[j_nishi_t_nishi_pos]
## 西の神社の東の寺
j_nishi_t_higashi_pos = f_higashi_pos(t, j_nishi)
j_nishi_t_higashi = t[j_nishi_t_higashi_pos]
## 東の神社の西の寺
j_higashi_t_nishi = t[f_nishi_pos(t, j_higashi)]
## 東の神社の東の寺
j_higashi_t_higashi = t[f_higashi_pos(t, j_higashi)]
# 寺 -> 神社
t_nishi = t[f_nishi_pos(t, x)]
t_higashi = t[f_higashi_pos(t, x)]
## 西の寺の西の神社
t_nishi_j_nishi = s[f_nishi_pos(s, t_nishi)]
## 西の寺の東の神社
t_nishi_j_higashi = s[f_higashi_pos(s, t_nishi)]
## 東の寺の東の神社
t_higashi_j_nishi = s[f_nishi_pos(s, t_higashi)]
## 東の寺の東の神社
t_higashi_j_higashi = s[f_higashi_pos(s, t_higashi)]
l = [
abs(x - j_nishi) + abs(j_nishi - j_nishi_t_nishi),
abs(x - j_nishi) + abs(j_nishi - j_nishi_t_higashi),
abs(x - j_higashi) + abs(j_higashi - j_higashi_t_nishi),
abs(x - j_higashi) + abs(j_higashi - j_higashi_t_higashi),
abs(x - t_nishi) + abs(t_nishi - t_nishi_j_nishi),
abs(x - t_nishi) + abs(t_nishi - t_nishi_j_higashi),
abs(x - t_higashi) + abs(t_higashi - t_higashi_j_nishi),
abs(x - t_higashi) + abs(t_higashi - t_higashi_j_higashi)
]
return min(l)
for xx in x:
print((calc(s, t, xx)))
|
import bisect
A, B, Q = list(map(int, input().split()))
s = [None] * A
t = [None] * B
x = [None] * Q
for i in range(A):
s[i] = int(eval(input()))
for i in range(B):
t[i] = int(eval(input()))
for i in range(Q):
x[i] = int(eval(input()))
s.sort()
t.sort()
def calc(s, t, x):
len_s = len(s)
len_t = len(t)
def f_nishi_pos(l, x):
p1 = bisect.bisect_left(l, x)
#p2 = bisect.bisect_right(l, x)
#if p2 == len(l):
# return p1-1
#if l[p1] == l[p2]:
# return max(p2-1, 0)
#else:
# return p1
if p1 == len(l):
return p1 - 1
else:
if l[p1] == x:
return p1
else:
return p1 - 1
def f_higashi_pos(l, x):
#p1 = bisect.bisect_left(l, x)
p2 = bisect.bisect_right(l, x)
#if p1 == len(l):
# return p1-1
#if l[p1] == l[p2]:
# return min(p1, len(l)-1)
#else:
# return p1
if p2 == len(l):
return p2 - 1
else:
return p2
# 神社 -> 寺
## 西の神社
j_nishi_pos = f_nishi_pos(s, x)
j_nishi = s[j_nishi_pos]
## 東の神社
j_higashi_pos = f_higashi_pos(s, x)
j_higashi = s[j_higashi_pos]
## 西の神社の西の寺
j_nishi_t_nishi_pos = f_nishi_pos(t, j_nishi)
j_nishi_t_nishi = t[j_nishi_t_nishi_pos]
## 西の神社の東の寺
j_nishi_t_higashi_pos = f_higashi_pos(t, j_nishi)
j_nishi_t_higashi = t[j_nishi_t_higashi_pos]
## 東の神社の西の寺
j_higashi_t_nishi = t[f_nishi_pos(t, j_higashi)]
## 東の神社の東の寺
j_higashi_t_higashi = t[f_higashi_pos(t, j_higashi)]
# 寺 -> 神社
t_nishi = t[f_nishi_pos(t, x)]
t_higashi = t[f_higashi_pos(t, x)]
## 西の寺の西の神社
t_nishi_j_nishi = s[f_nishi_pos(s, t_nishi)]
## 西の寺の東の神社
t_nishi_j_higashi = s[f_higashi_pos(s, t_nishi)]
## 東の寺の東の神社
t_higashi_j_nishi = s[f_nishi_pos(s, t_higashi)]
## 東の寺の東の神社
t_higashi_j_higashi = s[f_higashi_pos(s, t_higashi)]
return min(
abs(x - j_nishi) + abs(j_nishi - j_nishi_t_nishi),
abs(x - j_nishi) + abs(j_nishi - j_nishi_t_higashi),
abs(x - j_higashi) + abs(j_higashi - j_higashi_t_nishi),
abs(x - j_higashi) + abs(j_higashi - j_higashi_t_higashi),
abs(x - t_nishi) + abs(t_nishi - t_nishi_j_nishi),
abs(x - t_nishi) + abs(t_nishi - t_nishi_j_higashi),
abs(x - t_higashi) + abs(t_higashi - t_higashi_j_nishi),
abs(x - t_higashi) + abs(t_higashi - t_higashi_j_higashi)
)
for xx in x:
print((calc(s, t, xx)))
|
p03112
|
a,b,q = list(map(int, input().split()))
s = [0]*a
t = [0]*b
x = [0]*q
for i in range(a):
s[i] = int(eval(input()))
for i in range(b):
t[i] = int(eval(input()))
for i in range(q):
x[i] = int(eval(input()))
s.sort()
t.sort()
#print(s)
#print(t)
import bisect
for xi in x:
i = bisect.bisect_left(s,xi)
s_right = 10**11
if i < len(s):
s_right = s[i] - xi
s_left = 10**11
if i != 0:
s_left = xi - s[i-1]
j = bisect.bisect_left(t,xi)
t_right = 10**11
if j < len(t):
t_right = t[j] - xi
t_left = 10**11
if j != 0:
t_left = xi - t[j-1]
#print(i,j,xi)
#print(s_left,s_right,t_left,t_right)
ans = min(max(s_right,t_right), max(s_left,t_left), min(s_left,t_right)*2+max(s_left,t_right), min(s_right,t_left)*2+max(s_right,t_left))
print(ans)
|
a,b,q = list(map(int, input().split()))
s = [0]*a
t = [0]*b
x = [0]*q
for i in range(a):
s[i] = int(eval(input()))
for i in range(b):
t[i] = int(eval(input()))
for i in range(q):
x[i] = int(eval(input()))
s.sort()
t.sort()
INT_MAX = 10**11
#print(s)
#print(t)
import bisect
def func(xi):
i = bisect.bisect_left(s,xi)
s_right = INT_MAX
if i < len(s):
s_right = s[i] - xi
s_left = INT_MAX
if i != 0:
s_left = xi - s[i-1]
j = bisect.bisect_left(t,xi)
t_right = INT_MAX
if j < len(t):
t_right = t[j] - xi
t_left = INT_MAX
if j != 0:
t_left = xi - t[j-1]
#print(i,j,xi)
#print(s_left,s_right,t_left,t_right)
return min(max(s_right,t_right), max(s_left,t_left), min(s_left,t_right)*2+max(s_left,t_right), min(s_right,t_left)*2+max(s_right,t_left))
ans = list(map(func, x))
print(("\n".join(map(str,ans))))
|
p03112
|
from bisect import bisect_left
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)]
for xx in x:
# 神先
ps_r = 0
s_r = bisect_left(s, xx)
if s_r < A:
ps_r += s[s_r] - xx
t_r = bisect_left(t, s[s_r])
t_l = t_r - 1
b = 0
if t_r < B:
b = t[t_r] - s[s_r]
if 0 <= t_l < B:
if b == 0:
b = s[s_r] - t[t_l]
else:
b = min(b, s[s_r] - t[t_l])
ps_r += b
else:
ps_r = 10 ** 12
ps_l = 0
s_l = s_r - 1
if 0 <= s_l < A:
ps_l += xx - s[s_l]
t_r = bisect_left(t, s[s_l])
t_l = t_r - 1
b = 0
if t_r < B:
b = t[t_r] - s[s_l]
if 0 <= t_l < B:
if b == 0:
b = s[s_l] - t[t_l]
else:
b = min(b, s[s_l] - t[t_l])
ps_l += b
else:
ps_l = 10 ** 12
# 寺前
pt_r = 0
t_r = bisect_left(t, xx)
if t_r < B:
pt_r += t[t_r] - xx
s_r = bisect_left(s, t[t_r])
s_l = s_r - 1
b = 0
if s_r < A:
b = s[s_r] - t[t_r]
if 0 <= s_l < A:
if b == 0:
b = t[t_r] - s[s_l]
else:
b = min(b, t[t_r] - s[s_l])
pt_r += b
else:
pt_r = 10 ** 12
pt_l = 0
t_l = t_r - 1
if 0 <= t_l < B:
pt_l += xx - t[t_l]
s_r = bisect_left(s, t[t_l])
s_l = s_r - 1
b = 0
if s_r < A:
b = s[s_r] - t[t_l]
if 0 <= s_l < A:
if b == 0:
b = t[t_l] - s[s_l]
else:
b = min(b, t[t_l] - s[s_l])
pt_l += b
else:
pt_l = 10 ** 12
# print(ps_r, ps_l, pt_r, pt_l)
print((min(ps_r, ps_l, pt_r, pt_l)))
|
from bisect import bisect_left
from itertools import product
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 xx in x:
ret = inf
sr = bisect_left(s, xx) # xx以上の最小値
sl = max(0, sr - 1)
tr = bisect_left(t, xx)
tl = max(0, tr - 1)
for ss, tt in product(s[sl:sr + 1], t[tl:tr + 1]):
ret = min(
ret,
abs(xx - ss) + abs(ss - tt),
abs(xx - tt) + abs(tt - ss)
)
print(ret)
|
p03112
|
from bisect import bisect
A, B, Q = list(map(int, input().split()))
s = [-10**15]
t = [-10**15]
for _ in range(A):
s.append(int(eval(input())))
s.append(10**15)
for _ in range(B):
t.append(int(eval(input())))
t.append(10**15)
x = list(map(int, (eval(input()) for _ in range(Q))))
for y in x:
i = bisect(s, y)
j = bisect(t, y)
ans = min(
max(abs(s[i] - y), abs(t[j] - y)),
max(abs(s[i - 1] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i] - y), abs(t[j - 1] - y)) + max(abs(s[i] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i - 1] - y), abs(t[j] - y)) + max(abs(s[i - 1] - y), abs(t[j] - y))
)
print(ans)
|
from bisect import bisect
A, B, Q = list(map(int, input().split()))
s = [-10**15] + [int(eval(input())) for i in range(A)] + [10**15]
t = [-10**15] + [int(eval(input())) for i in range(B)] + [10**15]
# s = [-10**15]
# t = [-10**15]
# for _ in range(A):
# s.append(int(input()))
# s.append(10**15)
# for _ in range(B):
# t.append(int(input()))
# t.append(10**15)
x = list(map(int, (eval(input()) for _ in range(Q))))
for y in x:
i = bisect(s, y)
j = bisect(t, y)
ans = min(
max(abs(s[i] - y), abs(t[j] - y)),
max(abs(s[i - 1] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i] - y), abs(t[j - 1] - y)) + max(abs(s[i] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i - 1] - y), abs(t[j] - y)) + max(abs(s[i - 1] - y), abs(t[j] - y))
)
print(ans)
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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 = 10**18
s = [-INF]
t = [-INF]
for _ in range(A):
s.append(int(eval(input())))
s.append(INF)
for _ in range(B):
t.append(int(eval(input())))
t.append(INF)
x = list(map(int, (eval(input()) for _ in range(Q))))
for y in x:
i = bisect_right(s, y)
j = bisect_right(t, y)
# ans = INF
# for S in [s[i - 1], s[i]]:
# for T in [t[j - 1], t[j]]:
# d1, d2 = abs(S - y) + abs(T - S), abs(T - y) + abs(S - T)
# ans = min(ans, d1, d2)
ans = min(
max(abs(s[i] - y), abs(t[j] - y)),
max(abs(s[i - 1] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i] - y), abs(t[j - 1] - y)) + max(abs(s[i] - y), abs(t[j - 1] - y)),
2 * min(abs(s[i - 1] - y), abs(t[j] - y)) + max(abs(s[i - 1] - y), abs(t[j] - y))
)
print(ans)
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF]
t = [-INF]
for _ in range(A):
s.append(int(eval(input())))
s.append(INF)
for _ in range(B):
t.append(int(eval(input())))
t.append(INF)
for q in range(Q):
x = int(eval(input()))
i, j = bisect.bisect_right(s, x), bisect.bisect_right(t, x)
ans = min(
max(abs(s[i] - x), abs(t[j] - x)),
max(abs(s[i - 1] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i] - x), abs(t[j - 1] - x)) + max(abs(s[i] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i - 1] - x), abs(t[j] - x)) + max(abs(s[i - 1] - x), abs(t[j] - x))
)
print(ans)
|
from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(eval(input())) for i in range(Q)]
for x in xs:
b, d = bisect_right(s, x), 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)
|
p03112
|
from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(eval(input())) for i in range(Q)]
for x in xs:
b, d = bisect_right(s, x), 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()))
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 ** 18
S = [-INF] + s + [INF]
T = [-INF] + t + [INF]
# 指定した変位に対する問に二分探索を用いて回答
def f(y):
i = bisect_right(S, y)
j = bisect_right(T, y)
return min(
abs(b - a) + min(abs(a - y), abs(b - y))
for a in (S[i - 1], S[i])
for b in (T[j - 1], T[j])
)
# 各問に対して、fにより解を得る
ans = '\n'.join(map(str, list(map(f, x))))
# 出力
print(ans)
|
p03112
|
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import math
import bisect
import random
def LI(): return list(map(int, input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return list(eval(input()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
mod = 1000000007
#A
#B
#C
"""
n,a,b,c = LI()
l = IR(n)
f = [True for i in range(3)]
ans = 0
for i in range(n):
for d in range(3):
if abs(l[i]-[a,b,c][d]) <= 10 and f[d]:
ans += abs(l[i]-[a,b,c][d])
f[d] = False
l[i] = -float("inf")
k = False
for i in f:
if i:
k = True
break
if not k:
print(ans)
quit()
"""
#D
a,b,q = LI()
s = IR(a)
t = IR(b)
for i in range(q):
x = I()
c = bisect.bisect_left(s,x)
ans = float("inf")
if c == a:
k = abs(x-s[-1])
y = s[-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
else:
k = abs(x-s[c-1])
y = s[c-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
k = abs(x-s[c])
y = s[c]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
c = bisect.bisect_left(t,x)
if c == b:
k = abs(x-t[-1])
y = t[-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
else:
k = abs(x-t[c-1])
y = t[c-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
k = abs(x-t[c])
y = t[c]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
#!usr/bin/env python3
import sys
from collections import defaultdict
from heapq import heappush, heappop
import math
import bisect
import random
def LI(): return list(map(int, input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return list(eval(input()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
mod = 1000000007
#A
#B
#C
"""
n,a,b,c = LI()
l = IR(n)
f = [True for i in range(3)]
ans = 0
for i in range(n):
for d in range(3):
if abs(l[i]-[a,b,c][d]) <= 10 and f[d]:
ans += abs(l[i]-[a,b,c][d])
f[d] = False
l[i] = -float("inf")
k = False
for i in f:
if i:
k = True
break
if not k:
print(ans)
quit()
"""
#D
a,b,q = LI()
s = IR(a)
t = IR(b)
for i in range(q):
x = int(sys.stdin.readline())
c = bisect.bisect_left(s,x)
ans = float("inf")
if c == a:
k = abs(x-s[-1])
y = s[-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
else:
k = abs(x-s[c-1])
y = s[c-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
k = abs(x-s[c])
y = s[c]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
c = bisect.bisect_left(t,x)
if c == b:
k = abs(x-t[-1])
y = t[-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
else:
k = abs(x-t[c-1])
y = t[c-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
k = abs(x-t[c])
y = t[c]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
p03112
|
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return list(sys.stdin.readline())
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
mod = 1000000007
#A
#B
#C
"""
n,a,b,c = LI()
l = IR(n)
f = [True for i in range(3)]
ans = 0
for i in range(n):
for d in range(3):
if abs(l[i]-[a,b,c][d]) <= 10 and f[d]:
ans += abs(l[i]-[a,b,c][d])
f[d] = False
l[i] = -float("inf")
k = False
for i in f:
if i:
k = True
break
if not k:
print(ans)
quit()
"""
#D
a,b,q = LI()
s = IR(a)
t = IR(b)
for i in range(q):
x = I()
c = bisect.bisect_left(s,x)
ans = float("inf")
if c == a:
k = abs(x-s[-1])
y = s[-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
else:
k = abs(x-s[c-1])
y = s[c-1]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
k = abs(x-s[c])
y = s[c]
d = bisect.bisect_left(t,y)
if d == b:
k += abs(y-t[-1])
else:
if abs(y-t[d-1]) < abs(y-t[d]):
k += abs(y-t[d-1])
else:
k += abs(y-t[d])
ans = min(k,ans)
c = bisect.bisect_left(t,x)
if c == b:
k = abs(x-t[-1])
y = t[-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
else:
k = abs(x-t[c-1])
y = t[c-1]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
k = abs(x-t[c])
y = t[c]
d = bisect.bisect_left(s,y)
if d == a:
k += abs(y-s[-1])
else:
if abs(y-s[d-1]) < abs(y-s[d]):
k += abs(y-s[d-1])
else:
k += abs(y-s[d])
ans = min(k,ans)
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
a,b,q = LI()
s = IR(a)
t = IR(b)
X = IR(q)
for x in X:
i = bisect.bisect_right(s,x)-1
j = bisect.bisect_right(t,x)-1
res = float("inf")
if i >= 0:
si = s[i]
if j >= 0:
tj = t[j]
res = x-min(si,tj)
if j+1 < b:
tj = t[j+1]
m = min(abs(si-x),abs(tj-x))+abs(tj-si)
if m < res:
res = m
if i+1 < a:
si = s[i+1]
if j >= 0:
tj = t[j]
m = min(abs(si-x),abs(tj-x))+abs(si-tj)
if m < res:
res = m
if j+1 < b:
tj = t[j+1]
res = min(res,max(si,tj)-x)
print(res)
return
#Solve
if __name__ == "__main__":
solve()
|
p03112
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
A,B,Q=MAP()
S=[0]*(A+2)
for i in range(A):
S[i+1]=INT()
T=[0]*(B+2)
for i in range(B):
T[i+1]=INT()
S[-1]=T[-1]=INF
# Si番目の神社から左に一番近い寺
L1=[INF]*(A+2)
# Si番目の神社から右に一番近い寺
R1=[INF]*(A+2)
for i in range(1, A+1):
idx=bisect_right(T, S[i])-1
if T[idx]!=0:
L1[i]=S[i]-T[idx]
idx=bisect_left(T, S[i])
if T[idx]!=INF:
R1[i]=T[idx]-S[i]
# Ti番目の寺から左に一番近い神社
L2=[INF]*(B+2)
# Ti番目の寺から右に一番近い神社
R2=[INF]*(B+2)
for i in range(1, B+1):
idx=bisect_right(S, T[i])-1
if S[idx]!=0:
L2[i]=T[i]-S[idx]
idx=bisect_left(S, T[i])
if S[idx]!=INF:
R2[i]=S[idx]-T[i]
for i in range(Q):
dist1=dist2=dist3=dist4=INF
x=INT()
# 地点xから左に一番近い神社
idx=bisect_right(S, x)-1
if S[idx]!=0:
# idx番目の神社に行く
dist1=x-S[idx]
# idx番目の神社から一番近い寺に行く
dist1+=min(L1[idx], R1[idx])
idx=bisect_left(S, x)
if S[idx]!=INF:
dist2=S[idx]-x
dist2+=min(L1[idx], R1[idx])
idx=bisect_right(T, x)-1
if T[idx]!=0:
dist3=x-T[idx]
dist3+=min(L2[idx], R2[idx])
idx=bisect_left(T, x)
if T[idx]!=INF:
dist4=T[idx]-x
dist4+=min(L2[idx], R2[idx])
print((min(dist1, dist2, dist3, dist4)))
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
A,B,Q=MAP()
S=[-INF]*(A+2)
for i in range(A):
S[i+1]=INT()
T=[-INF]*(B+2)
for i in range(B):
T[i+1]=INT()
S[-1]=T[-1]=INF
# Si番目の神社から左に一番近い寺
L1=[INF]*(A+2)
# Si番目の神社から右に一番近い寺
R1=[INF]*(A+2)
for i in range(1, A+1):
idx=bisect_right(T, S[i])-1
if T[idx]!=0:
L1[i]=S[i]-T[idx]
idx=bisect_left(T, S[i])
if T[idx]!=INF:
R1[i]=T[idx]-S[i]
# Ti番目の寺から左に一番近い神社
L2=[INF]*(B+2)
# Ti番目の寺から右に一番近い神社
R2=[INF]*(B+2)
for i in range(1, B+1):
idx=bisect_right(S, T[i])-1
if S[idx]!=0:
L2[i]=T[i]-S[idx]
idx=bisect_left(S, T[i])
if S[idx]!=INF:
R2[i]=S[idx]-T[i]
for i in range(Q):
dist1=dist2=dist3=dist4=INF
x=INT()
# 地点xから左に一番近い神社
idx=bisect_right(S, x)-1
# idx番目の神社に行く
dist1=x-S[idx]
# idx番目の神社から一番近い寺に行く
dist1+=min(L1[idx], R1[idx])
idx=bisect_left(S, x)
dist2=S[idx]-x
dist2+=min(L1[idx], R1[idx])
idx=bisect_right(T, x)-1
dist3=x-T[idx]
dist3+=min(L2[idx], R2[idx])
idx=bisect_left(T, x)
dist4=T[idx]-x
dist4+=min(L2[idx], R2[idx])
print((min(dist1, dist2, dist3, dist4)))
|
p03112
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
A,B,Q=MAP()
S=[-INF]*(A+2)
for i in range(A):
S[i+1]=INT()
T=[-INF]*(B+2)
for i in range(B):
T[i+1]=INT()
S[-1]=T[-1]=INF
# Si番目の神社から左に一番近い寺
L1=[INF]*(A+2)
# Si番目の神社から右に一番近い寺
R1=[INF]*(A+2)
for i in range(1, A+1):
idx=bisect_right(T, S[i])-1
if T[idx]!=0:
L1[i]=S[i]-T[idx]
idx=bisect_left(T, S[i])
if T[idx]!=INF:
R1[i]=T[idx]-S[i]
# Ti番目の寺から左に一番近い神社
L2=[INF]*(B+2)
# Ti番目の寺から右に一番近い神社
R2=[INF]*(B+2)
for i in range(1, B+1):
idx=bisect_right(S, T[i])-1
if S[idx]!=0:
L2[i]=T[i]-S[idx]
idx=bisect_left(S, T[i])
if S[idx]!=INF:
R2[i]=S[idx]-T[i]
for i in range(Q):
dist1=dist2=dist3=dist4=INF
x=INT()
# 地点xから左に一番近い神社
idx=bisect_right(S, x)-1
# idx番目の神社に行く
dist1=x-S[idx]
# idx番目の神社から一番近い寺に行く
dist1+=min(L1[idx], R1[idx])
idx=bisect_left(S, x)
dist2=S[idx]-x
dist2+=min(L1[idx], R1[idx])
idx=bisect_right(T, x)-1
dist3=x-T[idx]
dist3+=min(L2[idx], R2[idx])
idx=bisect_left(T, x)
dist4=T[idx]-x
dist4+=min(L2[idx], R2[idx])
print((min(dist1, dist2, dist3, dist4)))
|
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc119/editorial.pdf
"""
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
A,B,Q=MAP()
S=[-INF]*(A+2)
for i in range(A):
S[i+1]=INT()
T=[-INF]*(B+2)
for i in range(B):
T[i+1]=INT()
S[-1]=T[-1]=INF
for i in range(Q):
dist1=dist2=dist3=dist4=INF
x=INT()
# 地点xから左に一番近い神社
idx1=bisect_right(S, x)-1
# 右に一番近い神社
idx2=bisect_left(S, x)
idx3=bisect_right(T, x)-1
idx4=bisect_left(T, x)
# idx番目の神社に行く
dist1=x-S[idx1]
# idx番目の神社から一番近い寺に行く
dist1+=min(abs(S[idx1]-T[idx3]), abs(S[idx1]-T[idx4]))
dist2=S[idx2]-x
dist2+=min(abs(S[idx2]-T[idx3]), abs(S[idx2]-T[idx4]))
dist3=x-T[idx3]
dist3+=min(abs(T[idx3]-S[idx1]), abs(T[idx3]-S[idx2]))
dist4=T[idx4]-x
dist4+=min(abs(T[idx4]-S[idx1]), abs(T[idx4]-S[idx2]))
print((min(dist1, dist2, dist3, dist4)))
|
p03112
|
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc119/editorial.pdf
・前計算しないで直接やる版
・INFがfloat('inf')だとダメで10**18にしたらいけた。INF-INFがnanになるからだった。
・上記を考慮して修正版
"""
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
A,B,Q=MAP()
S=[-INF]*(A+2)
for i in range(A):
S[i+1]=INT()
T=[-INF]*(B+2)
for i in range(B):
T[i+1]=INT()
S[-1]=T[-1]=INF
for i in range(Q):
dist1=dist2=dist3=dist4=INF
x=INT()
# 地点xから左に一番近い神社
idx1=bisect_right(S, x)-1
# 右に一番近い神社
idx2=bisect_left(S, x)
idx3=bisect_right(T, x)-1
idx4=bisect_left(T, x)
# idx1番目の神社に行く
dist1=x-S[idx1]
# idx1番目の神社から、xから右か左に一番近かった寺に行く
if dist1!=INF: dist1+=min(abs(S[idx1]-T[idx3]), abs(S[idx1]-T[idx4]))
dist2=S[idx2]-x
if dist2!=INF: dist2+=min(abs(S[idx2]-T[idx3]), abs(S[idx2]-T[idx4]))
dist3=x-T[idx3]
if dist3!=INF: dist3+=min(abs(T[idx3]-S[idx1]), abs(T[idx3]-S[idx2]))
dist4=T[idx4]-x
if dist4!=INF: dist4+=min(abs(T[idx4]-S[idx1]), abs(T[idx4]-S[idx2]))
print((min(dist1, dist2, dist3, dist4)))
|
# -*- coding: utf-8 -*-
import sys
from bisect import bisect_left, bisect_right
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, M, Q = MAP()
A = [0] * N
for i in range(N):
A[i] = INT()
B = [0] * M
for i in range(M):
B[i] = INT()
A.sort()
B.sort()
A = [-INF] + A + [INF]
B = [-INF] + B + [INF]
for i in range(Q):
q = INT()
# q以下で最大
al = bisect_right(A, q) - 1
bl = bisect_right(B, q) - 1
# q以上で最小
ar = bisect_left(A, q)
br = bisect_left(B, q)
# 両方左
a = max(q-A[al], q-B[bl])
# 両方右
b = max(A[ar]-q, B[br]-q)
# 左の神社、右の寺
c = min(q-A[al], B[br]-q) * 2 + max(q-A[al], B[br]-q)
# 右の神社、左の寺
d = min(A[ar]-q, q-B[bl]) * 2 + max(A[ar]-q, q-B[bl])
ans = min(a, b, c, d)
print(ans)
|
p03112
|
from bisect import bisect_left, bisect_right
a, b, q = list(map(int, input().split()))
inf = 10**18
shrine = [-inf] + [int(eval(input())) for _ in range(a)] + [inf]
temple = [-inf] + [int(eval(input())) for _ in range(b)] + [inf]
for _ in range(q):
ans = inf
x = int(eval(input()))
index_s = bisect_left(shrine, x)
index_t = bisect_right(temple, x)
for i in range(index_s-1, index_s+1):
s = shrine[i]
i_t = bisect_left(temple, s)
t0, t1 = temple[i_t-1], temple[i_t]
ans = min(
ans,
abs(x - s) + abs(s - t0),
abs(x - s) + abs(s - t1),
)
for i in range(index_t-1, index_t+1):
t = temple[i]
i_s = bisect_left(shrine, t)
s0 = shrine[i_s - 1]
s1 = shrine[i_s]
ans = min(
ans,
abs(x - t) + abs(t - s0),
abs(x - t) + abs(t - s1),
)
print(ans)
|
from bisect import bisect_left, bisect_right
a, b, q = list(map(int, input().split()))
inf = 10**18
shrine = [-inf] + [int(eval(input())) for _ in range(a)] + [inf]
temple = [-inf] + [int(eval(input())) for _ in range(b)] + [inf]
for _ in range(q):
ans = inf
x = int(eval(input()))
index_s = bisect_left(shrine, x)
index_t = bisect_right(temple, x)
for i in range(index_s-1, index_s+1):
s = shrine[i]
i_t = index_t
t0, t1 = temple[i_t-1], temple[i_t]
ans = min(
ans,
abs(x - s) + abs(s - t0),
abs(x - s) + abs(s - t1),
)
for i in range(index_t-1, index_t+1):
t = temple[i]
i_s = index_s
s0 = shrine[i_s - 1]
s1 = shrine[i_s]
ans = min(
ans,
abs(x - t) + abs(t - s0),
abs(x - t) + abs(t - s1),
)
print(ans)
|
p03112
|
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
# aとbの最大公約数
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
# aとbの最小公倍数
def lcm(a, b):
g = gcd(a, b)
return a / g * b
class BisectWrapper:
try:
from typing import List
except:
List = list
from bisect import bisect, bisect_left, bisect_right
def __init__(self):
pass
# aにxが存在するか
@staticmethod
def exist(a: List, x: int):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return True
return False
# xのindex(なければ-1)
@staticmethod
def index(a: List, x: int):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
return -1
# y < xのようなyの中でもっとも右のindex
@staticmethod
def index_lt(a: List, x: int):
i = bisect_left(a, x)
if i:
return i - 1
return -1
# y < xのようなyの個数
@staticmethod
def num_lt(a: List, x: int):
return bisect_left(a, x)
# y <= xのようなyの中でもっとも右のindex
@staticmethod
def index_lte(a: List, x: int):
i = bisect_right(a, x)
if i:
return i - 1
return -1
# y < xのようなyの個数
@staticmethod
def num_lte(a: List, x: int):
return bisect_right(a, x)
# y > xのようなyの中でもっとも左のindex
@staticmethod
def index_gt(a: List, x: int):
i = bisect_right(a, x)
if i != len(a):
return i
return -1
# y > xのようなyの個数
@staticmethod
def num_gt(a: List, x: int):
return len(a) - bisect_right(a, x)
# y >= xのようなyの中でもっとも左のindex
@staticmethod
def index_gte(a: List, x: int):
i = bisect_left(a, x)
if i != len(a):
return i
return -1
# y >= xのようなyの個数
@staticmethod
def num_gte(a: List, x: int):
return len(a) - bisect_left(a, x)
def near(A, x):
l = BisectWrapper.index_lte(A, x)
r = BisectWrapper.index_gte(A, x)
if l == -1:
return abs(x - A[r])
if r == -1:
return abs(x - A[l])
return min(abs(x - A[r]), abs(x - A[l]))
def main():
A, B, Q = list(map(int, input().split()))
S = list(sorted([int(eval(input())) for _ in range(A)]))
T = list(sorted([int(eval(input())) for _ in range(B)]))
for _ in range(Q):
x = int(eval(input()))
ans = INF
s_l = BisectWrapper.index_lte(S, x)
if s_l != -1:
s = S[s_l]
ans = min(ans, abs(x - s) + near(T, s))
s_r = BisectWrapper.index_gte(S, x)
if s_r != -1:
s = S[s_r]
ans = min(ans, abs(x - s) + near(T, s))
t_l = BisectWrapper.index_lte(T, x)
if t_l != -1:
t = T[t_l]
ans = min(ans, abs(x - t) + near(S, t))
t_r = BisectWrapper.index_gte(T, x)
if t_r != -1:
t = T[t_r]
ans = min(ans, abs(x - t) + near(S, t))
print(ans)
if __name__ == '__main__':
main()
|
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
# aとbの最大公約数
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
# aとbの最小公倍数
def lcm(a, b):
g = gcd(a, b)
return a / g * b
class BisectWrapper:
try:
from typing import List
except:
List = list
from bisect import bisect, bisect_left, bisect_right
def __init__(self):
pass
# aにxが存在するか
@staticmethod
def exist(a: List, x: int):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return True
return False
# xのindex(なければ-1)
@staticmethod
def index(a: List, x: int):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
return -1
# y < xのようなyの中でもっとも右のindex
@staticmethod
def index_lt(a: List, x: int):
i = bisect_left(a, x)
if i:
return i - 1
return -1
# y < xのようなyの個数
@staticmethod
def num_lt(a: List, x: int):
return bisect_left(a, x)
# y <= xのようなyの中でもっとも右のindex
@staticmethod
def index_lte(a: List, x: int):
i = bisect_right(a, x)
if i:
return i - 1
return -1
# y < xのようなyの個数
@staticmethod
def num_lte(a: List, x: int):
return bisect_right(a, x)
# y > xのようなyの中でもっとも左のindex
@staticmethod
def index_gt(a: List, x: int):
i = bisect_right(a, x)
if i != len(a):
return i
return -1
# y > xのようなyの個数
@staticmethod
def num_gt(a: List, x: int):
return len(a) - bisect_right(a, x)
# y >= xのようなyの中でもっとも左のindex
@staticmethod
def index_gte(a: List, x: int):
i = bisect_left(a, x)
if i != len(a):
return i
return -1
# y >= xのようなyの個数
@staticmethod
def num_gte(a: List, x: int):
return len(a) - bisect_left(a, x)
def near(A, x):
l = BisectWrapper.index_lte(A, x)
r = l + 1
if l == -1:
return abs(x - A[r])
if r >= len(A):
return abs(x - A[l])
return min(abs(x - A[r]), abs(x - A[l]))
def main():
A, B, Q = list(map(int, input().split()))
S = [int(eval(input())) for _ in range(A)]
T = [int(eval(input())) for _ in range(B)]
for _ in range(Q):
x = int(eval(input()))
ans = INF
s_l = BisectWrapper.index_lte(S, x)
if s_l != -1:
s = S[s_l]
ans = min(ans, abs(x - s) + near(T, s))
s_r = s_l + 1
if s_r < len(S):
s = S[s_r]
ans = min(ans, abs(x - s) + near(T, s))
t_l = BisectWrapper.index_lte(T, x)
if t_l != -1:
t = T[t_l]
ans = min(ans, abs(x - t) + near(S, t))
t_r = t_l + 1
if t_r < len(T):
t = T[t_r]
ans = min(ans, abs(x - t) + near(S, t))
print(ans)
if __name__ == '__main__':
main()
|
p03112
|
import bisect
A,B,Q=list(map(int,input().split()))
INF=10**18
S=[-INF]+[int(eval(input())) for i in range(A)]+[INF]
T=[-INF]+[int(eval(input())) for i in range(B)]+[INF]
for q in range(Q):
x=int(eval(input()))
s=bisect.bisect_right(S,x)
t=bisect.bisect_right(T,x)
d=INF
for i in [S[s-1],S[s]]:
for j in [T[t-1],T[t]]:
ds=abs(i-x)+abs(i-j)
dt=abs(j-x)+abs(i-j)
d=min(d,ds,dt)
print(d)
|
import bisect
A,B,Q=list(map(int,input().split()))
INF=10**18
S=[-INF]+[int(eval(input())) for i in range(A)]+[INF]
T=[-INF]+[int(eval(input())) for i in range(B)]+[INF]
for q in range(Q):
x=int(eval(input()))
i=bisect.bisect_left(S,x)
j=bisect.bisect_left(T,x)
ans=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)
ans=min(ans,d1,d2)
print(ans)
|
p03112
|
import bisect
import itertools
A, B, Q = list(map(int, input().split()))
INF = 10 ** 15
S = [-INF] + [int(eval(input())) for _ in range(A)] + [INF]
T = [-INF] + [int(eval(input())) for _ in range(B)] + [INF]
for _ in range(Q):
answer = INF
x = int(eval(input()))
si = bisect.bisect_left(S, x)
ti = bisect.bisect_left(T, x)
for s, t in itertools.product(S[si-1:si+1], T[ti-1:ti+1]):
d = min(abs(s-x), abs(t-x)) + abs(t-s)
answer = min(answer, d)
print(answer)
|
import bisect
import itertools
A,B,Q = list(map(int,input().split()))
# 簡略化のため常に左右に存在するようにしておく
INF = 10 ** 15
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)]
def solve(x):
# xの位置
i = bisect.bisect_left(S, x)
j = bisect.bisect_left(T, x)
result = INF
# どの2つを目指すのか
for s,t in itertools.product(S[i-1:i+1], T[j-1:j+1]):
d = min(abs(s-x),abs(t-x)) + abs(t-s)
result = min(result,d)
return result
for x in X:
answer = solve(x)
print(answer)
|
p03112
|
import bisect
import itertools
A,B,Q = list(map(int,input().split()))
# 簡略化のため常に左右に存在するようにしておく
INF = 10 ** 15
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)]
def solve(x):
# xの位置
i = bisect.bisect_left(S, x)
j = bisect.bisect_left(T, x)
result = INF
# どの2つを目指すのか
for s,t in itertools.product(S[i-1:i+1], T[j-1:j+1]):
d = min(abs(s-x),abs(t-x)) + abs(t-s)
result = min(result,d)
return result
for x in X:
answer = solve(x)
print(answer)
|
# coding: utf-8
import sys
from bisect import bisect_left
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 番兵を左右に置いて、4通り試す
A, B, Q = lr()
INF = 10 ** 12
S = [-INF] + [ir() for _ in range(A)] + [INF]
T = [-INF] + [ir() for _ in range(B)] + [INF]
S.sort(); T.sort()
for _ in range(Q):
x = ir()
si = bisect_left(S, x)
ti = bisect_left(T, x)
temp = []
temp.append(max(S[si], T[ti]) - x)
y = abs(S[si] - x)
z = abs(T[ti-1] - x)
temp.append(min(y, z) * 2 + max(y, z))
y = abs(S[si-1] - x)
z = abs(T[ti] - x)
temp.append(min(y, z) * 2 + max(y, z))
temp.append(x - min(S[si-1], T[ti-1]))
print((min(temp)))
# 46
|
p03112
|
#!/usr/bin/env python3
import sys
from bisect import bisect_right
def solve(A: int, B: int, Q: int, s: "List[int]", t: "List[int]", x: "List[int]"):
b, d = bisect_right(s, x), bisect_right(t, x)
ret = 10e18
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)
ret = min(ret, d1, d2)
print(ret)
# Generated by 1.1.3 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()
INF = 10e18
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
s = [-INF] + [int(next(tokens)) for _ in range(A)] + [INF] # type: "List[int]"
t = [-INF] + [int(next(tokens)) for _ in range(B)] + [INF] # type: "List[int]"
for x in range(Q):
x = int(eval(input()))
solve(A, B, Q, s, t, x)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
from bisect import bisect_right
INF = 10e11
def solve(A: int, B: int, Q: int, s: "List[int]", t: "List[int]", x: "List[int]"):
b, d = bisect_right(s, x), bisect_right(t, x)
ret = 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)
ret = min(ret, d1, d2)
print(ret)
# Generated by 1.1.3 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()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
s = [-INF] + [int(next(tokens)) for _ in range(A)] + [INF] # type: "List[int]"
t = [-INF] + [int(next(tokens)) for _ in range(B)] + [INF] # type: "List[int]"
for x in range(Q):
x = int(eval(input()))
solve(A, B, Q, s, t, x)
if __name__ == "__main__":
main()
|
p03112
|
INF = 1e20
A, B, Q = [int(i) for i 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)]
from bisect import bisect_left
for x in X:
s = bisect_left(S, x)
t = bisect_left(T, x)
mi = INF
for ss in [S[s], S[s - 1]]:
for tt in [T[t], T[t - 1]]:
mi = min(mi, abs(ss - x) + abs(tt - ss), abs(tt - x) + abs(ss - tt))
print(mi)
|
INF = 1e20
A, B, Q = [int(i) for i 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)]
from bisect import bisect_left
mins = []
for x in X:
s = bisect_left(S, x)
t = bisect_left(T, x)
mi = INF
for ss in [S[s], S[s - 1]]:
for tt in [T[t], T[t - 1]]:
mi = min(mi, abs(ss - x) + abs(tt - ss), abs(tt - x) + abs(ss - tt))
mins.append(str(mi))
print(("\n".join(mins)))
|
p03112
|
from bisect import bisect
A, B, Q = list(map(int, input().split()))
S, T =[None] * (A+2), [None] * (B+2)
S[0], T[0] = -10**20, -10**20
for i in range(A):
S[i+1] = int(eval(input()))
for i in range(B):
T[i+1] = int(eval(input()))
S[A+1] = 10**20
T[B+1] = 10**20
lenS, lenT = len(S), len(T)
for _ in range(Q):
x = int(eval(input()))
si, ti = bisect(S, x, 0, lenS), bisect(T, x, 0, lenT)
sLength0, sLength1 = x - S[si-1], S[si] - x
tLength0, tLength1 = x - T[ti-1], T[ti] - x
Ans = (max(sLength0, tLength0), max(sLength1, tLength1), sLength0 + tLength1 + min(sLength0, tLength1), sLength1 + tLength0 + min(sLength1, tLength0))
print((min(Ans)))
|
import sys
from bisect import bisect
F = sys.stdin
A, B, Q = list(map(int, F.readline().strip("\n").split(" ")))
S, T =[None] * (A+2), [None] * (B+2)
S[0], T[0] = -10**20, -10**20
for i in range(A):
S[i+1] = int(F.readline().strip("\n"))
for i in range(B):
T[i+1] = int(F.readline().strip("\n"))
S[A+1] = 10**20
T[B+1] = 10**20
lenS, lenT = len(S), len(T)
for _ in range(Q):
x = int(F.readline().strip("\n"))
si, ti = bisect(S, x, 0, lenS), bisect(T, x, 0, lenT)
sLength0, sLength1 = x - S[si-1], S[si] - x
tLength0, tLength1 = x - T[ti-1], T[ti] - x
Ans = (max(sLength0, tLength0), max(sLength1, tLength1), sLength0 + tLength1 + min(sLength0, tLength1), sLength1 + tLength0 + min(sLength1, tLength0))
print((min(Ans)))
|
p03112
|
A, B, Q = list(map(int, input().split()))
INF = 10 ** 11 + 1
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)]
def bsr(a, v):
lo, hi = 0, len(a) - 1
while lo <= hi:
mi = (lo + hi) // 2
if v < a[mi]:
hi = mi - 1
else:
lo = mi + 1
return lo
for x in X:
sr = bsr(S, x)
sl = sr - 1
tr = bsr(T, x)
tl = tr - 1
cost = []
for m in [S[sr], S[sl]]:
for n in [T[tr], T[tl]]:
cost += [abs(x - m) + abs(m - n), abs(x - n) + abs(m - n)]
print((min(cost)))
|
A, B, Q = list(map(int, input().split()))
INF = 10 ** 11 + 1
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)]
def bsr(a, v):
lo, hi = 0, len(a)
while lo < hi:
mi = (lo + hi) // 2
if v < a[mi]:
hi = mi
else:
lo = mi + 1
return lo
for x in X:
sr = bsr(S, x)
sl = sr - 1
tr = bsr(T, x)
tl = tr - 1
cost = []
for m in [S[sr], S[sl]]:
for n in [T[tr], T[tl]]:
cost += [abs(x - m) + abs(m - n), abs(x - n) + abs(m - n)]
print((min(cost)))
|
p03112
|
import bisect
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 bsr(a, v, lo=0, hi=None):
if None == hi:
hi = len(a) - 1
while lo <= hi:
mi = (lo + hi) // 2
if a[mi] <= v:
lo = mi + 1
else:
hi = mi - 1
return lo
"""
bsr = bisect.bisect_right
INF = 10 ** 18
s = [-INF] + S + [INF]
t = [-INF] + T + [INF]
for x in X:
sp = bsr(s, x)
tp = bsr(t, x)
cost = []
cost += [abs(s[sp - 0] - x) + abs(s[sp - 0] - t[tp - 0])]
cost += [abs(s[sp - 1] - x) + abs(s[sp - 1] - t[tp - 0])]
cost += [abs(s[sp - 0] - x) + abs(s[sp - 0] - t[tp - 1])]
cost += [abs(s[sp - 1] - x) + abs(s[sp - 1] - t[tp - 1])]
cost += [abs(t[tp - 0] - x) + abs(s[sp - 0] - t[tp - 0])]
cost += [abs(t[tp - 1] - x) + abs(s[sp - 0] - t[tp - 1])]
cost += [abs(t[tp - 0] - x) + abs(s[sp - 1] - t[tp - 0])]
cost += [abs(t[tp - 1] - x) + abs(s[sp - 1] - t[tp - 1])]
print((min(cost)))
|
# お約束
INF = float("inf")
MOD = int(1e9 + 7)
def int1(n):
return int(n) - 1
def parse(args, *params):
return tuple(p(v) for p, v in zip(params, next(args).split()))
from bisect import bisect_right as bsr
# エントリーポイント
def main(args):
A, B, Q = parse(args, int, int, int)
S = list(int(next(args)) for _ in range(A))
T = list(int(next(args)) for _ in range(B))
X = tuple(int(next(args)) for _ in range(Q))
s = [-INF] + S + [INF]
t = [-INF] + T + [INF]
for x in X:
sr = bsr(s, x)
sl = sr - 1
tr = bsr(t, x)
tl = tr - 1
min_cost = INF
for st in [s[sl], s[sr]]:
for tt in [t[tl], t[tr]]:
min_cost = min(min_cost, abs(st - x) + abs(tt - st))
min_cost = min(min_cost, abs(tt - x) + abs(tt - st))
print(min_cost)
import sys
if __name__ == '__main__':
main(iter(sys.stdin.read().split("\n")))
|
p03112
|
import bisect
A, B, Q = list(map(int,input().split()))
s = [-10**20] + [int(eval(input())) for k in range(A)] + [10**20,10**20]
t = [-10**20] + [int(eval(input())) for k in range(B)] + [10**20,10**20]
for _ in range(Q):
x = int(eval(input()))
print((min(
max(s[bisect.bisect_left(s,x)],t[bisect.bisect_left(t,x)])-x,
x-min(s[bisect.bisect_left(s,x)-1],t[bisect.bisect_left(t,x)-1]),
s[bisect.bisect_left(s,x)]-x + s[bisect.bisect_left(s,x)]-t[bisect.bisect_left(t,x)-1],
t[bisect.bisect_left(t,x)]-x + t[bisect.bisect_left(t,x)]-s[bisect.bisect_left(s,x)-1],
x-s[bisect.bisect_left(s,x)-1] + t[bisect.bisect_left(t,x)]-s[bisect.bisect_left(s,x)-1],
x-t[bisect.bisect_left(t,x)-1] + s[bisect.bisect_left(s,x)]-t[bisect.bisect_left(t,x)-1])))
|
import bisect
A, B, Q = list(map(int,input().split()))
s = [-10**20] + [int(eval(input())) for k in range(A)] + [10**20,10**20]
t = [-10**20] + [int(eval(input())) for k in range(B)] + [10**20,10**20]
for _ in range(Q):
x = int(eval(input()))
S = bisect.bisect_left(s,x)
T = bisect.bisect_left(t,x)
print((min(
max(s[S],t[T])-x,
x-min(s[S-1],t[T-1]),
s[S]-x + s[S]-t[T-1],
t[T]-x + t[T]-s[S-1],
x-s[S-1] + t[T]-s[S-1],
x-t[T-1] + s[S]-t[T-1])))
|
p03112
|
import bisect
A, B, Q = list(map(int,input().split()))
s = [-10**20] + [int(eval(input())) for k in range(A)] + [10**20,10**20]
t = [-10**20] + [int(eval(input())) for k in range(B)] + [10**20,10**20]
for _ in range(Q):
x = int(eval(input()))
S = bisect.bisect_left(s,x)
T = bisect.bisect_left(t,x)
print((min(
max(s[S],t[T])-x,
x-min(s[S-1],t[T-1]),
s[S]-x + s[S]-t[T-1],
t[T]-x + t[T]-s[S-1],
x-s[S-1] + t[T]-s[S-1],
x-t[T-1] + s[S]-t[T-1])))
|
import bisect
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
A, B, Q = list(map(int,input().split()))
s = [-10**20] + [int(eval(input())) for k in range(A)] + [10**20,10**20]
t = [-10**20] + [int(eval(input())) for k in range(B)] + [10**20,10**20]
for _ in range(Q):
x = int(eval(input()))
S = bisect.bisect_left(s,x)
T = bisect.bisect_left(t,x)
print((min(
max(s[S],t[T])-x,
x-min(s[S-1],t[T-1]),
s[S]-x + s[S]-t[T-1],
t[T]-x + t[T]-s[S-1],
x-s[S-1] + t[T]-s[S-1],
x-t[T-1] + s[S]-t[T-1])))
if __name__ == '__main__':
main()
|
p03112
|
import bisect
A,B,Q=list(map(int,input().split()))
Z=[-10**10]
T=[-10**10]
for i in range(A):
s=int(eval(input()))
Z.append(s)
Z.append(10**11)
for i in range(B):
t=int(eval(input()))
T.append(t)
T.append(10**11)
for i in range(Q):
x=int(eval(input()))
a=max(Z[bisect.bisect_left(Z,x)],T[bisect.bisect_left(T,x)])-x
b=x-min(Z[bisect.bisect_left(Z,x)-1],T[bisect.bisect_left(T,x)-1])
c=Z[bisect.bisect_left(Z,x)]-T[bisect.bisect_left(T,x)-1]+(x-T[bisect.bisect_left(T,x)-1])
d=Z[bisect.bisect_left(Z,x)]-T[bisect.bisect_left(T,x)-1]+(Z[bisect.bisect_left(Z,x)]-x)
e=T[bisect.bisect_left(T,x)]-Z[bisect.bisect_left(Z,x)-1]+(x-Z[bisect.bisect_left(Z,x)-1])
f=T[bisect.bisect_left(T,x)]-Z[bisect.bisect_left(Z,x)-1]+(T[bisect.bisect_left(T,x)]-x)
print((min(a,b,c,d,e,f)))
|
import bisect
import sys
input = sys.stdin.readline
A,B,Q=list(map(int,input().split()))
Z=[-10**10]
T=[-10**10]
for i in range(A):
s=int(eval(input()))
Z.append(s)
Z.append(10**11)
for i in range(B):
t=int(eval(input()))
T.append(t)
T.append(10**11)
for i in range(Q):
x=int(eval(input()))
a=max(Z[bisect.bisect_left(Z,x)],T[bisect.bisect_left(T,x)])-x
b=x-min(Z[bisect.bisect_left(Z,x)-1],T[bisect.bisect_left(T,x)-1])
c=Z[bisect.bisect_left(Z,x)]-T[bisect.bisect_left(T,x)-1]+(x-T[bisect.bisect_left(T,x)-1])
d=Z[bisect.bisect_left(Z,x)]-T[bisect.bisect_left(T,x)-1]+(Z[bisect.bisect_left(Z,x)]-x)
e=T[bisect.bisect_left(T,x)]-Z[bisect.bisect_left(Z,x)-1]+(x-Z[bisect.bisect_left(Z,x)-1])
f=T[bisect.bisect_left(T,x)]-Z[bisect.bisect_left(Z,x)-1]+(T[bisect.bisect_left(T,x)]-x)
print((min(a,b,c,d,e,f)))
|
p03112
|
a,b,q=(input().split())
a,b,q=int(a),int(b),int(q)
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)]
dist=['' for i in range(8)]
dist1=['' for i in range(2)]
dist2=['' for i in range(4)]
sp1=['' for i in range(2)]
tp1=['' for i in range(4)]
import bisect
for k in range(q):
p1=bisect.bisect_left(s,x[k])
if p1==0:
dist1[0]=s[0]-x[k]
dist1[1]=s[0]-x[k]
sp1[0]=s[0]
sp1[1]=s[0]
elif p1==a:
dist1[0]=x[k]-s[a-1]
dist1[1]=x[k]-s[a-1]
sp1[0]=s[a-1]
sp1[1]=s[a-1]
else:
dist1[0]=x[k]-s[p1-1]
dist1[1]=s[p1]-x[k]
sp1[0]=s[p1-1]
sp1[1]=s[p1]
p11=bisect.bisect_left(t,sp1[0])
if p11==0:
dist2[0]=t[0]-sp1[0]
dist2[1]=t[0]-sp1[0]
elif p11==b:
dist2[0]=sp1[0]-t[b-1]
dist2[1]=sp1[0]-t[b-1]
else:
dist2[0]=sp1[0]-t[p11-1]
dist2[1]=t[p11]-sp1[0]
p11=bisect.bisect_left(t,sp1[1])
if p11==0:
dist2[2]=t[0]-sp1[1]
dist2[3]=t[0]-sp1[1]
elif p11==b:
dist2[2]=sp1[1]-t[b-1]
dist2[3]=sp1[1]-t[b-1]
else:
dist2[2]=sp1[1]-t[p11-1]
dist2[3]=t[p11]-sp1[1]
dist[0]=dist1[0]+dist2[0]
dist[1]=dist1[0]+dist2[1]
dist[2]=dist1[1]+dist2[2]
dist[3]=dist1[1]+dist2[3]
p1=bisect.bisect_left(t,x[k])
if p1==0:
sp1[0]=t[0]
sp1[1]=t[0]
elif p1==b:
sp1[0]=t[b-1]
sp1[1]=t[b-1]
else:
sp1[0]=t[p1-1]
sp1[1]=t[p1]
for i in range(2):
p11=bisect.bisect_left(s,sp1[i])
if p11==0:
tp1[0+2*i]=s[0]
tp1[1+2*i]=s[0]
elif p11==a:
tp1[0+2*i]=s[a-1]
tp1[1+2*i]=s[a-1]
else:
tp1[0+2*i]=s[p11-1]
tp1[1+2*i]=s[p11]
dist[4]=abs(x[k]-sp1[0])+abs(sp1[0]-tp1[0])
dist[5]=abs(x[k]-sp1[0])+abs(sp1[0]-tp1[1])
dist[6]=abs(x[k]-sp1[1])+abs(sp1[1]-tp1[2])
dist[7]=abs(x[k]-sp1[1])+abs(sp1[1]-tp1[3])
ans=min(dist[0],dist[1],dist[2],dist[3],dist[4],dist[5],dist[6],dist[7])
print(ans)
|
a,b,q=(input().split())
a,b,q=int(a),int(b),int(q)
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)]
dist=['' for i in range(8)]
dist1=['' for i in range(2)]
dist2=['' for i in range(4)]
sp1=['' for i in range(2)]
tp1=['' for i in range(4)]
import bisect
for k in range(q):
p1=bisect.bisect_left(s,x[k])
if p1==0:
dist1[0]=s[0]-x[k]
dist1[1]=s[0]-x[k]
sp1[0]=s[0]
sp1[1]=s[0]
elif p1==a:
dist1[0]=x[k]-s[a-1]
dist1[1]=x[k]-s[a-1]
sp1[0]=s[a-1]
sp1[1]=s[a-1]
else:
dist1[0]=x[k]-s[p1-1]
dist1[1]=s[p1]-x[k]
sp1[0]=s[p1-1]
sp1[1]=s[p1]
p11=bisect.bisect_left(t,sp1[0])
if p11==0:
dist2[0]=t[0]-sp1[0]
dist2[1]=t[0]-sp1[0]
elif p11==b:
dist2[0]=sp1[0]-t[b-1]
dist2[1]=sp1[0]-t[b-1]
else:
dist2[0]=sp1[0]-t[p11-1]
dist2[1]=t[p11]-sp1[0]
p11=bisect.bisect_left(t,sp1[1])
if p11==0:
dist2[2]=t[0]-sp1[1]
dist2[3]=t[0]-sp1[1]
elif p11==b:
dist2[2]=sp1[1]-t[b-1]
dist2[3]=sp1[1]-t[b-1]
else:
dist2[2]=sp1[1]-t[p11-1]
dist2[3]=t[p11]-sp1[1]
dist[0]=dist1[0]+dist2[0]
dist[1]=dist1[0]+dist2[1]
dist[2]=dist1[1]+dist2[2]
dist[3]=dist1[1]+dist2[3]
p1=bisect.bisect_left(t,x[k])
if p1==0:
sp1[0]=t[0]
sp1[1]=t[0]
dist1[0]=t[0]-x[k]
dist1[1]=t[0]-x[k]
elif p1==b:
sp1[0]=t[b-1]
sp1[1]=t[b-1]
dist1[0]=x[k]-t[b-1]
dist1[1]=x[k]-t[b-1]
else:
sp1[0]=t[p1-1]
sp1[1]=t[p1]
dist1[0]=x[k]-t[p1-1]
dist1[1]=t[p1]-x[k]
p11=bisect.bisect_left(s,sp1[0])
if p11==0:
dist2[0]=s[0]-sp1[0]
dist2[1]=s[0]-sp1[0]
elif p11==a:
dist2[0]=sp1[0]-s[a-1]
dist2[1]=sp1[0]-s[a-1]
else:
dist2[0]=sp1[0]-s[p11-1]
dist2[1]=s[p11]-sp1[0]
p11=bisect.bisect_left(s,sp1[1])
if p11==0:
dist2[2]=s[0]-sp1[1]
dist2[3]=s[0]-sp1[1]
elif p11==a:
dist2[2]=sp1[1]-s[a-1]
dist2[3]=sp1[1]-s[a-1]
else:
dist2[2]=sp1[1]-s[p11-1]
dist2[3]=s[p11]-sp1[1]
dist[4]=dist1[0]+dist2[0]
dist[5]=dist1[0]+dist2[1]
dist[6]=dist1[1]+dist2[2]
dist[7]=dist1[1]+dist2[3]
ans=min(dist[0],dist[1],dist[2],dist[3],dist[4],dist[5],dist[6],dist[7])
print(ans)
|
p03112
|
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_char_list():
return list(input().strip())
# inputs
A, B, Q = 0, 0, 0
S = []
T = []
X = []
def set_inputs():
global A, B, Q, S, T, X
A, B, Q = get_list_of_int()
for _ in range(A):
S.append(get_int())
for _ in range(B):
T.append(get_int())
for _ in range(Q):
X.append(get_int())
def main():
set_inputs()
for i in range(Q):
ns = abs(max([S[j] - X[i] for j in range(A) if S[j] - X[i] <= 0] + [-inf]))
ps = abs(min([S[j] - X[i] for j in range(A) if S[j] - X[i] >= 0] + [inf]))
nt = abs(max([T[j] - X[i] for j in range(B) if T[j] - X[i] <= 0] + [-inf]))
pt = abs(min([T[j] - X[i] for j in range(B) if T[j] - X[i] >= 0] + [inf]))
print((min(max(ns, nt), max(ps, pt), ns * 2 + pt, ns + pt * 2, nt * 2 + ps, nt + ps * 2)))
if __name__ == '__main__':
main()
|
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_char_list():
return list(input().strip())
# inputs
A, B, Q = 0, 0, 0
S = []
T = []
X = []
def set_inputs():
global A, B, Q, S, T, X
A, B, Q = get_list_of_int()
for _ in range(A):
S.append(get_int())
for _ in range(B):
T.append(get_int())
for _ in range(Q):
X.append(get_int())
def main():
set_inputs()
for i in range(Q):
nsi = bisect_left(S, X[i])
if nsi == 0:
ns = inf
else:
ns = X[i] - S[nsi-1]
psi = bisect_left(S, X[i])
if psi == A:
ps = inf
else:
ps = S[nsi] - X[i]
nti = bisect_left(T, X[i])
if nti == 0:
nt = inf
else:
nt = X[i] - T[nti-1]
pti = bisect_left(T, X[i])
if pti == B:
pt = inf
else:
pt = T[nti] - X[i]
print((min(max(ns, nt), max(ps, pt), ns * 2 + pt, ns + pt * 2, nt * 2 + ps, nt + ps * 2)))
if __name__ == '__main__':
main()
|
p03112
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
a,b,q = LI()
sa = [-inf] + [I() for _ in range(a)] + [inf, inf]
ta = [-inf] + [I() for _ in range(b)] + [inf, inf]
xa = [I() for _ in range(q)]
r = []
for x in xa:
si = bisect.bisect_left(sa, x)
ti = bisect.bisect_left(ta, x)
t = inf
k = x - sa[si-1]
for i in range(ti,-1,-1):
u = k + abs(sa[si-1] - ta[i])
if t > u:
t = u
if ta[i] <= sa[si-1]:
break
k = sa[si] - x
for i in range(ti-1,b+2):
u = k + abs(sa[si] - ta[i])
if t > u:
t = u
if ta[i] >= sa[si]:
break
k = x - ta[ti-1]
for i in range(si,-1,-1):
u = k + abs(ta[ti-1] - sa[i])
if t > u:
t = u
if sa[i] <= ta[ti-1]:
break
k = ta[ti] - x
for i in range(si-1,a+2):
u = k + abs(ta[ti] - sa[i])
if t > u:
t = u
if sa[i] >= ta[ti]:
break
r.append(t)
return JA(r, "\n")
print(main())
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
a,b,q = LI()
sa = [-inf,-inf] + [I() for _ in range(a)] + [inf, inf]
ta = [-inf,-inf] + [I() for _ in range(b)] + [inf, inf]
xa = [I() for _ in range(q)]
r = []
for x in xa:
si = bisect.bisect_left(sa, x)
ti = bisect.bisect_left(ta, x)
l = sa[si-1]
k = x - l
ti2 = bisect.bisect_left(ta, l)
t = inf
if ti2 > 0 and t > k + l - ta[ti2-1]:
t = k + l - ta[ti2-1]
if t > k + ta[ti2] - l:
t = k + ta[ti2] - l
l = sa[si]
k = l - x
ti2 = bisect.bisect_left(ta, l)
if ti2 > 0 and t > k + l - ta[ti2-1]:
t = k + l - ta[ti2-1]
if t > k + ta[ti2] - l:
t = k + ta[ti2] - l
l = ta[ti-1]
k = x - l
si2 = bisect.bisect_left(sa, l)
if si2 > 0 and t > k + l - sa[si2-1]:
t = k + l - sa[si2-1]
if t > k + sa[si2] - l:
t = k + sa[si2] - l
l = ta[ti]
k = l - x
si2 = bisect.bisect_left(sa, l)
if si2 > 0 and t > k + l - sa[si2-1]:
t = k + l - sa[si2-1]
if t > k + sa[si2] - l:
t = k + sa[si2] - l
r.append(t)
return JA(r, "\n")
print(main())
|
p03112
|
import bisect
a, b, q = list(map(int, input().split()))
s = sorted([int(eval(input())) for _ in range(a)])
t = sorted([int(eval(input())) for _ in range(b)])
for _ in range(q):
x = int(eval(input()))
s_i = bisect.bisect_left(s, x)
t_i = bisect.bisect_left(t, x)
s0, s1, t0, t1 = None, None, None, None
ans = 10 ** 11
if s_i > 0:
s0 = x - s[s_i-1]
if s_i < a:
s1 = s[s_i] - x
if t_i > 0:
t0 = x - t[t_i-1]
if t_i < b:
t1 = t[t_i] - x
if s0 is not None and t0 is not None:
ans = min(ans, max(s0, t0))
if s1 is not None and t1 is not None:
ans = min(ans, max(s1, t1))
if s0 is not None and t1 is not None:
ans = min(ans, s0*2 + t1, t1*2 + s0)
if s1 is not None and t0 is not None:
ans = min(ans, s1*2 + t0, t0*2 + s1)
print(ans)
|
import bisect
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
a, b, q = list(map(int, input().split()))
s = sorted([int(eval(input())) for _ in range(a)])
t = sorted([int(eval(input())) for _ in range(b)])
for _ in range(q):
x = int(eval(input()))
s_i = bisect.bisect_left(s, x)
t_i = bisect.bisect_left(t, x)
s0, s1, t0, t1 = None, None, None, None
ans = 10 ** 11
if s_i > 0:
s0 = x - s[s_i-1]
if s_i < a:
s1 = s[s_i] - x
if t_i > 0:
t0 = x - t[t_i-1]
if t_i < b:
t1 = t[t_i] - x
if s0 is not None and t0 is not None:
ans = min(ans, max(s0, t0))
if s1 is not None and t1 is not None:
ans = min(ans, max(s1, t1))
if s0 is not None and t1 is not None:
ans = min(ans, s0*2 + t1, t1*2 + s0)
if s1 is not None and t0 is not None:
ans = min(ans, s1*2 + t0, t0*2 + s1)
print(ans)
|
p03112
|
# D
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)]
def route(start, mid, end):
return abs(start-mid) + abs(mid-end)
for i in range(q):
ans = 10000000000000000000000000
# jinja
j_list = [jin-x[i] for jin in s if (jin-x[i])<= 0]
if len(j_list) != 0:
j_w = j_list[-1] + x[i]
t_list = [ter-j_w for ter in t if ter-j_w<=0]
if len(t_list) != 0:
t_w = t_list[-1] + j_w
ans = min(route(x[i], j_w,t_w), ans)
t_list = [ter-j_w for ter in t if ter-j_w>0]
if len(t_list) != 0:
t_e = t_list[0] + j_w
ans = min(route(x[i], j_w,t_e), ans)
j_list = [jin-x[i] for jin in s if (jin-x[i]) > 0]
if len(j_list) != 0:
j_e = j_list[0] + x[i]
t_list = [ter-j_e for ter in t if ter-j_e <= 0]
if len(t_list) != 0:
t_w = t_list[-1] + j_e
ans = min(route(x[i], j_e,t_w), ans)
t_list = [ter-j_e for ter in t if ter-j_e > 0]
if len(t_list) != 0:
t_e = t_list[0] + j_e
ans = min(route(x[i], j_e,t_e), ans)
t_list = [ter-x[i] for ter in t if ter-x[i]<=0]
if len(t_list) != 0:
t_w = t_list[-1] + x[i]
j_list = [jin-t_w for jin in s if jin-t_w<=0]
if len(j_list) != 0:
j_w = j_list[-1] + t_w
ans = min(route(x[i], t_w,j_w), ans)
j_list = [jin-t_w for jin in s if jin-t_w>0]
if len(j_list) != 0:
j_e = j_list[0] + t_w
ans = min(route(x[i], t_w,j_e), ans)
t_list = [ter-x[i] for ter in t if ter-x[i]>0]
if len(t_list) != 0:
t_e = t_list[0] + x[i]
j_list = [jin-t_e for jin in s if jin-t_e<=0]
if len(j_list) != 0:
j_w = j_list[-1] + t_e
ans = min(route(x[i], t_e,j_w), ans)
j_list = [jin-t_e for jin in s if jin-t_e>0]
if len(j_list) != 0:
j_e = j_list[0] + t_e
ans = min(route(x[i], t_e,j_e), ans)
print(ans)
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
p03112
|
import bisect
def calc_distance(frm, x, y):
#frmからx, yのに地点を通るのに必要な距離を計算する
return min(abs(frm - x), abs(frm - y) ) + abs(x - y)
def calc_both_end(frm, us):
#地点frmに囲まれた2点を返す。
#片側しか囲われていない場合は最寄の2点
if len(us) == 1:
return us[0], us[0]
idx = bisect.bisect_left(us, frm)
if idx == 0:
return us[0], us[1]
elif idx == len(us):
return us[len(us) - 2], us[len(us) - 1]
else:
return us[idx - 1], us[idx]
def find(ss, ts, x):
s1, s2 = calc_both_end(x, ss)
t1, t2 = calc_both_end(x, ts)
ans = min(calc_distance(x, s1, t1), calc_distance(x, s1, t2), calc_distance(x, s2, t1), calc_distance(x, s2, t2))
return ans
a, b, q = list(map(int, input().split()))
ss = [int(eval(input())) for _ in range(a)]
ts = [int(eval(input())) for _ in range(b)]
xs = [int(eval(input())) for _ in range(q)]
for x in xs:
print((find(ss, ts, x)))
|
import bisect
def calc_distance(frm, x, y):
return min(abs(frm - x), abs(frm - y) ) + abs(x - y)
def calc_2points(frm, us):
idx = bisect.bisect_left(us, frm)
return us[idx - 1], us[idx]
def calc_min(ss, ts, x):
s1, s2 = calc_2points(x, ss)
t1, t2 = calc_2points(x, ts)
ans = min(calc_distance(x, s1, t1), calc_distance(x, s1, t2), calc_distance(x, s2, t1), calc_distance(x, s2, t2))
return ans
INF = 10 ** 20
a, b, q = list(map(int, input().split()))
ss = [-INF] + [int(eval(input())) for _ in range(a)] + [INF]
ts = [-INF] + [int(eval(input())) for _ in range(b)] + [INF]
xs = [int(eval(input())) for _ in range(q)]
for x in xs:
print((calc_min(ss, ts, x)))
|
p03112
|
import bisect
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
lis = []
lis.append(x - min(s[idxs - 1], t[idxt -1]))
lis.append(x - s[idxs - 1] + (t[idxt] - s[idxs - 1]))
lis.append(t[idxt] - x + (t[idxt] - s[idxs - 1]))
lis.append(x - t[idxt - 1] + (s[idxs] - t[idxt - 1]))
lis.append(s[idxs] - x + (s[idxs] - t[idxt - 1]))
lis.append(max(s[idxs], t[idxt]) - x)
ans.append(min(lis))
for i in range(q):
print((ans[i]))
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
lis = []
lis.append(x - min(s[idxs - 1], t[idxt -1]))
lis.append(x - s[idxs - 1] + (t[idxt] - s[idxs - 1]))
lis.append(t[idxt] - x + (t[idxt] - s[idxs - 1]))
lis.append(x - t[idxt - 1] + (s[idxs] - t[idxt - 1]))
lis.append(s[idxs] - x + (s[idxs] - t[idxt - 1]))
lis.append(max(s[idxs], t[idxt]) - x)
ans.append(min(lis))
for i in range(q):
print((ans[i]))
|
p03112
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
lis = []
lis.append(x - min(s[idxs - 1], t[idxt -1]))
lis.append(x - s[idxs - 1] + (t[idxt] - s[idxs - 1]))
lis.append(t[idxt] - x + (t[idxt] - s[idxs - 1]))
lis.append(x - t[idxt - 1] + (s[idxs] - t[idxt - 1]))
lis.append(s[idxs] - x + (s[idxs] - t[idxt - 1]))
lis.append(max(s[idxs], t[idxt]) - x)
ans.append(min(lis))
for i in range(q):
print((ans[i]))
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
ans.append(min(x - min(s[idxs - 1], t[idxt -1]),
x - s[idxs - 1] + (t[idxt] - s[idxs - 1]),
t[idxt] - x + (t[idxt] - s[idxs - 1]),
x - t[idxt - 1] + (s[idxs] - t[idxt - 1]),
s[idxs] - x + (s[idxs] - t[idxt - 1]),
max(s[idxs], t[idxt]) - x,
x - min(s[idxs - 1], t[idxt -1])))
for i in range(q):
print((ans[i]))
|
p03112
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
ans.append(min(x - min(s[idxs - 1], t[idxt -1]),
x - s[idxs - 1] + (t[idxt] - s[idxs - 1]),
t[idxt] - x + (t[idxt] - s[idxs - 1]),
x - t[idxt - 1] + (s[idxs] - t[idxt - 1]),
s[idxs] - x + (s[idxs] - t[idxt - 1]),
max(s[idxs], t[idxt]) - x,
x - min(s[idxs - 1], t[idxt -1])))
for i in range(q):
print((ans[i]))
|
import bisect
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(a)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(b)] + [INF]
ans = []
for i in range(q):
x = int(eval(input()))
idxs = bisect.bisect(s, x)
idxt = bisect.bisect(t, x)
ans.append(str(min(x - min(s[idxs - 1], t[idxt -1]),
x - s[idxs - 1] + (t[idxt] - s[idxs - 1]),
t[idxt] - x + (t[idxt] - s[idxs - 1]),
x - t[idxt - 1] + (s[idxs] - t[idxt - 1]),
s[idxs] - x + (s[idxs] - t[idxt - 1]),
max(s[idxs], t[idxt]) - x,
x - min(s[idxs - 1], t[idxt -1]))))
print(('\n'.join(ans)))
|
p03112
|
import bisect
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 dis(x,p,q):
return min(abs(x-s[p])+abs(s[p]-t[q]),abs(x-t[q])+abs(s[p]-t[q]))
def kai(x):
res = INF
s1 = bisect.bisect_right(s,x)
ls = [s1,s1 - 1]
t1 = bisect.bisect_right(t,x)
lt = [t1,t1 - 1]
for ss in ls:
for st in lt:
res = min(res,dis(x,ss,st))
return res
for _ in range(q):
x = int(eval(input()))
print((kai(x)))
|
import bisect
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 kai(x):
res = INF
s1 = bisect.bisect_right(s,x)
ls = [s1,s1 - 1]
t1 = bisect.bisect_right(t,x)
lt = [t1,t1 - 1]
for ss in ls:
for st in lt:
res = min(res,abs(x-s[ss])+abs(s[ss]-t[st]),abs(x-t[st])+abs(s[ss]-t[st]))
return res
lx = [int(eval(input())) for _ in range(q)]
for x in lx:
print((kai(x)))
|
p03112
|
a, b, q = [int(i) for i in input().split()]
s = [-float('inf')] + [int(eval(input())) for _ in range(a)] + [float('inf')]
t = [-float('inf')] + [int(eval(input())) for _ in range(b)] + [float('inf')]
x = [int(eval(input())) for _ in range(q)]
for xx in x:
low = 0
high = len(s)-1
mid = (low+high)//2
while low<=high:
tmp = [i-xx for i in s[mid:mid+2]]
if tmp[0] <= 0 and 0 <= tmp[1]:
s_l = abs(tmp[0])
s_r = abs(tmp[1])
break
elif tmp[0] > 0:
high = mid
mid = (low+high)//2
else:
low = mid
mid = (low+high)//2
low = 0
high = len(t)-1
mid = (low+high)//2
while low<=high:
tmp = [i-xx for i in t[mid:mid+2]]
if tmp[0] <= 0 and 0 <= tmp[1]:
t_l = abs(tmp[0])
t_r = abs(tmp[1])
break
elif tmp[0] > 0:
high = mid
mid = (low+high)//2
else:
low = mid
mid = (low+high)//2
#print(s_l,s_r,t_l,t_r)
#l = max(s_l,t_l)
#r = max(s_r,t_r)
if s_l <= t_l:
l = t_l
lr = s_l*2 + t_r
else:
l = s_l
lr = t_l*2 + s_r
if s_r <= t_r:
r = t_r
rl = s_r*2 + t_l
else:
r = s_r
rl = t_r*2 + s_l
ans = min(l,r,lr,rl)
print(ans)
|
def search(x,r):
low = 0
high = len(r) - 1
while low < high:
mid = (low+high)//2
if x < r[mid]:
high = mid
else:
low = mid + 1
return(abs(r[low-1]-x),abs(r[low]-x))
a, b, q = [int(i) for i in input().split()]
s = [-float('inf')] + [int(eval(input())) for _ in range(a)] + [float('inf')]
t = [-float('inf')] + [int(eval(input())) for _ in range(b)] + [float('inf')]
x = [int(eval(input())) for _ in range(q)]
for xx in x:
s_l,s_r=search(xx,s)
t_l,t_r=search(xx,t)
if s_l <= t_l:
l = t_l
lr = s_l*2 + t_r
else:
l = s_l
lr = t_l*2 + s_r
if s_r <= t_r:
r = t_r
rl = s_r*2 + t_l
else:
r = s_r
rl = t_r*2 + s_l
ans = min(l,r,lr,rl)
print(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)]
def find_left_and_right(st, pos):
for i, s_i in enumerate(st):
if s_i - pos > 0:
return (i-1, i)
return (len(st) - 1, -1)
def find_optimum(ss, ts, pos):
(sl_index, sr_index) = find_left_and_right(ss, pos)
(tl_index, tr_index) = find_left_and_right(ts, pos)
penalty = 9999999999999
s_left = s[sl_index] if 0 <= sl_index else penalty
s_right = s[sr_index] if 0 <= sr_index else penalty
t_left = t[tl_index] if 0 <= tl_index else penalty
t_right = t[tr_index] if 0 <= tr_index else penalty
dist0 = abs(s_left - pos) + min(abs(t_left - s_left), abs(t_right - s_left))
dist1 = abs(s_right - pos) + min(abs(t_left - s_right), abs(t_right - s_right))
dist2 = abs(t_left - pos) + min(abs(s_left - t_left), abs(s_right - t_left))
dist3 = abs(t_right - pos) + min(abs(s_left - t_right), abs(s_right - t_right))
return min([dist0, dist1, dist2, dist3])
for x_i in x:
print((find_optimum(s, t, x_i)))
|
import bisect
(a, b, q) = list(map(int, input().split()))
s = [-10 ** 19]
for _ in range(a):
s.append(int(eval(input())))
s.append(10 ** 19)
t = [-10 ** 19]
for _ in range(b):
t.append(int(eval(input())))
t.append(10 ** 19)
x = [int(eval(input())) for _ in range(q)]
for x_i in x:
ss = bisect.bisect_left(s, x_i)
tt = bisect.bisect_left(t, x_i)
sc = [ss - 1, ss]
tc = [tt - 1, tt]
optimum = 10 ** 19
for s_i in sc:
for t_i in tc:
dist = abs(s[s_i] - x_i) + abs(s[s_i] - t[t_i])
if dist < optimum:
optimum = dist
dist = abs(t[t_i] - x_i) + abs(t[t_i] - s[s_i])
if dist < optimum:
optimum = dist
print(optimum)
|
p03112
|
import sys
from bisect import bisect_left
inpurt = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 11
s = [-INF]
for i in range(a):
si = int(eval(input()))
s.append(si)
s.append(INF)
t = [-INF]
for i in range(b):
ti = int(eval(input()))
t.append(ti)
t.append(INF)
x = []
for i in range(q):
xi = int(eval(input()))
x.append(xi)
for xi in x:
index_s = bisect_left(s, xi)
s1 = abs(xi - s[index_s - 1])
s2 = abs(xi - s[index_s])
index_t = bisect_left(t, xi)
t1 = abs(xi - t[index_t - 1])
t2 = abs(xi - t[index_t])
print((min(max(s1, t1), max(s2, t2), min(s1, t2) * 2 + max(s1, t2), min(s2, t1) * 2 + max(s2, t1))))
|
import sys
from bisect import bisect_left
inpurt = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 11
s = [-INF]
s_append = s.append
for i in range(a):
si = int(eval(input()))
s_append(si)
s_append(INF)
t = [-INF]
t_append = t.append
for i in range(b):
ti = int(eval(input()))
t_append(ti)
t_append(INF)
x = []
x_append = x.append
for i in range(q):
xi = int(eval(input()))
x_append(xi)
for xi in x:
index_s = bisect_left(s, xi)
s1 = abs(xi - s[index_s - 1])
s2 = abs(xi - s[index_s])
index_t = bisect_left(t, xi)
t1 = abs(xi - t[index_t - 1])
t2 = abs(xi - t[index_t])
print((min(max(s1, t1), max(s2, t2), min(s1, t2) * 2 + max(s1, t2), min(s2, t1) * 2 + max(s2, t1))))
|
p03112
|
import sys
from bisect import bisect_left
inpurt = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 11
s = [-INF]
s_append = s.append
for i in range(a):
si = int(eval(input()))
s_append(si)
s_append(INF)
t = [-INF]
t_append = t.append
for i in range(b):
ti = int(eval(input()))
t_append(ti)
t_append(INF)
x = []
x_append = x.append
for i in range(q):
xi = int(eval(input()))
x_append(xi)
for xi in x:
index_s = bisect_left(s, xi)
s1 = xi - s[index_s - 1]
s2 = s[index_s] - xi
index_t = bisect_left(t, xi)
t1 = xi - t[index_t - 1]
t2 = t[index_t] -xi
print((min(max(s1, t1), max(s2, t2), min(s1, t2) * 2 + max(s1, t2), min(s2, t1) * 2 + max(s2, t1))))
|
import sys
from bisect import bisect_left
inpurt = sys.stdin.readline
a, b, q = list(map(int, input().split()))
INF = 10 ** 11
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 xi in x:
index_s = bisect_left(s, xi)
s1 = xi - s[index_s - 1]
s2 = s[index_s] - xi
index_t = bisect_left(t, xi)
t1 = xi - t[index_t - 1]
t2 = t[index_t] -xi
print((min(max(s1, t1), max(s2, t2), min(s1, t2) * 2 + max(s1, t2), min(s2, t1) * 2 + max(s2, t1))))
|
p03112
|
A=list(map(int,input().split()))
S,T,X=[[int(eval(input())) for i in range(A[j])] for j in range(3)]
def binary(a,l,):
low=0
high=len(l)-1
while high-low>1:
mid=(low+high)//2
if l[mid]<a:
low=mid
else:
high=mid
return [l[high],l[low]]
for x in X:
s=set(binary(x,S))
t=set(binary(x,T))
Min=20000000000
for i in s:
for j in t:
Min=min(Min,min(abs(x-i),abs(x-j))+abs(i-j))
print(Min)
|
import sys
input=sys.stdin.readline
A=list(map(int,input().split()))
S,T,X=[[int(eval(input())) for i in range(A[j])] for j in range(3)]
def binary(a,l,):
low=0
high=len(l)-1
while high-low>1:
mid=(low+high)//2
if l[mid]<a:
low=mid
else:
high=mid
return [l[high],l[low]]
for x in X:
s=set(binary(x,S))
t=set(binary(x,T))
Min=20000000000
for i in s:
for j in t:
Min=min(Min,min(abs(x-i),abs(x-j))+abs(i-j))
print(Min)
|
p03112
|
from bisect import bisect_left
A, B, Q = list(map(int, input().split()))
S = [int(eval(input())) for _ in range(A)]
T = [int(eval(input())) for _ in range(B)]
Q = [int(eval(input())) for _ in range(Q)]
for q in Q:
ps = bisect_left(S, q)
if ps == len(S):
s1, s2 = S[ps - 1], S[ps - 1]
elif ps == 0:
s1, s2 = S[ps], S[ps]
else:
s1, s2 = S[ps - 1], S[ps]
pt = bisect_left(T, q)
if pt == len(T):
t1, t2 = T[pt - 1], T[pt - 1]
elif pt == 0:
t1, t2 = T[pt], T[pt]
else:
t1, t2 = T[pt - 1], T[pt]
ans = 10 ** 11
for s in (s1, s2):
for t in (t1, t2):
path1 = abs(q - s) + abs(s - t)
path2 = abs(q - t) + abs(s - t)
ans = min(ans, path1, path2)
print(ans)
|
from bisect import bisect_left
INF = 10 ** 12
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]
Q = [int(eval(input())) for _ in range(Q)]
for q in Q:
ps = bisect_left(S, q)
s1, s2 = S[ps - 1], S[ps]
pt = bisect_left(T, q)
t1, t2 = T[pt - 1], T[pt]
ans = INF
for s in (s1, s2):
for t in (t1, t2):
path1 = abs(q - s) + abs(s - t)
path2 = abs(q - t) + abs(s - t)
ans = min(ans, path1, path2)
print(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)]
inf = 10 ** 18
s = [-inf] + s + [inf]
t = [-inf] + t + [inf]
ans_Q = [None] * Q
i_last = j_last = 0
for idx, x_tmp in sorted(enumerate(x), key=lambda x: x[1]):
i_l, i_r = i_last, A + 2
while i_r - i_l > 1:
m = i_l + (i_r - i_l) // 2
# print("##", i_l, i_r, (m, s[m]), x_tmp)
if s[m] <= x_tmp:
i_l = m
else:
i_r = m
#
j_l, j_r = j_last, B + 2
while j_r - j_l > 1:
m = j_l + (j_r - j_l) // 2
# print("##", j_l, j_r, (m, t[m]), x_tmp)
if t[m] <= x_tmp:
j_l = m
else:
j_r = m
#
ans = inf
for i, j in ((i_l, j_l), (i_l + 1, j_l), (i_l, j_l + 1), (i_l + 1, j_l + 1)):
if i < 1 or A < i: continue
if j < 1 or B < j: continue
ans_tmp_s = abs(x_tmp - s[i]) + abs(s[i] - t[j])
ans_tmp_t = abs(x_tmp - t[j]) + abs(s[i] - t[j])
ans_tmp = min(ans_tmp_s, ans_tmp_t)
# print("#", x_tmp, s[i], t[j], ans_tmp)
if ans > ans_tmp:
ans = ans_tmp
#
i_last, j_last = i_l, j_l
ans_Q[idx] = ans
for ansi in ans_Q: print(ansi)
|
import sys, bisect
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 ** 18
s = [-inf] + s + [inf]
t = [-inf] + t + [inf]
ans_Q = [None] * Q
i_last = j_last = 0
for idx, x_tmp in sorted(enumerate(x), key=lambda x: x[1]):
i_l = max(0, bisect.bisect_left(s, x_tmp, lo=i_last) - 1)
j_l = max(0, bisect.bisect_left(t, x_tmp, lo=j_last) - 1)
# print("#", x_tmp, (i_l, s[i_l]), (j_l, t[j_l]))
#
ans = inf
for i, j in ((i_l, j_l), (i_l + 1, j_l), (i_l, j_l + 1), (i_l + 1, j_l + 1)):
if i < 1 or A < i: continue
if j < 1 or B < j: continue
ans_tmp_s = abs(x_tmp - s[i]) + abs(s[i] - t[j])
ans_tmp_t = abs(x_tmp - t[j]) + abs(s[i] - t[j])
ans_tmp = min(ans_tmp_s, ans_tmp_t)
# print("#", x_tmp, s[i], t[j], ans_tmp)
if ans > ans_tmp:
ans = ans_tmp
#
i_last, j_last = i_l, j_l
ans_Q[idx] = ans
for ansi in ans_Q: print(ansi)
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
s = []
for i in range(A):
s.append(int(eval(input())))
t = []
for i in range(B):
t.append(int(eval(input())))
x = []
for i in range(Q):
x.append(int(eval(input())))
for i in range(Q):
sx, tx, sy, ty = [], [], [], []
for j in s:
sx.append(abs(j - x[i]))
for j in t:
tx.append(abs(j - x[i]))
sxi = sx.index(min(sx))
txi = tx.index(min(tx))
for j in t:
ty.append(abs(j - s[sxi]))
for j in s:
sy.append(abs(j - t[txi]))
a = min(sx) + min(ty)
b = min(tx) + min(sy)
if a < b:
print((str(a)))
else:
print((str(b)))
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10**18
S = [-INF]
for i in range(A):
S.append(int(eval(input())))
S.append(INF)
T = [-INF]
for i in range(B):
T.append(int(eval(input())))
T.append(INF)
X = []
for i in range(Q):
X.append(int(eval(input())))
for x in X:
a, b = bisect.bisect_right(S, x), bisect.bisect_right(T, x)
print((min(abs(s-t) + min(abs(s-x), abs(t-x))
for s in S[a-1:a+1] for t in T[b-1:b+1])))
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
for q in range(Q):
x = int(eval(input()))
b, d = bisect.bisect_left(s, x), bisect.bisect_left(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)
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i 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)
|
p03112
|
from bisect import bisect
A,B,Q = map(int,input().split())
S = [int(input()) for i in range(A)]
T = [int(input()) for i in range(B)]
qs = [int(input()) for i in range(Q)]
st = []
for s in S:
ti = bisect(T,s)
if ti == 0:
st.append(abs(s-T[0]))
elif ti == B:
st.append(abs(s-T[-1]))
else:
tmp = min(abs(s-T[ti-1]), abs(s-T[ti]))
st.append(tmp)
ts = []
for t in T:
si = bisect(S,t)
if si == 0:
ts.append(abs(t-S[0]))
elif si == A:
ts.append(abs(t-S[-1]))
else:
tmp = min(abs(t-S[si-1]), abs(t-S[si]))
ts.append(tmp)
ans = []
for q in qs:
si = bisect(S,q)
if si == 0:
a = abs(q-S[0]) + st[0]
elif si == A:
a = abs(q-S[-1]) + st[-1]
else:
a = min(abs(q-S[si-1]) + st[si-1], abs(q-S[si]) + st[si])
ti = bisect(T,q)
if ti == 0:
b = abs(q-T[0]) + ts[0]
elif ti == B:
b = abs(q-T[-1]) + ts[-1]
else:
b = min(abs(q-T[ti-1]) + ts[ti-1], abs(q-T[ti]) + ts[ti])
ans.append(min(a,b))
print(*ans, sep='\n')
|
import sys
input = sys.stdin.readline
from bisect import bisect
A,B,Q = map(int,input().split())
S = [int(input()) for i in range(A)]
T = [int(input()) for i in range(B)]
X = [int(input()) for i in range(Q)]
INF = float('inf')
st = []
for s in S:
i = bisect(T,s)
x0,x1 = -INF,INF
if i > 0: x0 = T[i-1]
if i < B: x1 = T[i]
st.append(min(s-x0, x1-s))
ts = []
for t in T:
i = bisect(S,t)
x0,x1 = -INF,INF
if i > 0: x0 = S[i-1]
if i < A: x1 = S[i]
ts.append(min(t-x0, x1-t))
ans = []
for x in X:
d0 = d1 = d2 = d3 = INF
si = bisect(S,x)
if si > 0:
d0 = x-S[si-1] + st[si-1]
if si < A:
d1 = S[si]-x + st[si]
ti = bisect(T,x)
if ti > 0:
d2 = x-T[ti-1] + ts[ti-1]
if ti < B:
d3 = T[ti]-x + ts[ti]
ans.append(min(d0,d1,d2,d3))
print(*ans, sep='\n')
|
p03112
|
import bisect
def main():
A, B, Q = list(map(int, input().split()))
s = list(int(eval(input())) for _ in range(A))
t = list(int(eval(input())) for _ in range(B))
sort_s = sorted(s)
sort_t = sorted(t)
for _ in range(Q):
x = int(eval(input()))
s_near = bisect.bisect_left(sort_s, x)
t_near = bisect.bisect_left(sort_t, x)
s_candidate = []
t_candidate = []
if s_near == 0:
s_candidate.append(sort_s[s_near])
elif s_near == A:
s_candidate.append(sort_s[s_near-1])
else:
s_candidate.append(sort_s[s_near])
s_candidate.append(sort_s[s_near-1])
if t_near == 0:
t_candidate.append(sort_t[t_near])
elif t_near == B:
t_candidate.append(sort_t[t_near-1])
else:
t_candidate.append(sort_t[t_near])
t_candidate.append(sort_t[t_near-1])
ans = float('inf')
# sを先に訪れるパターンを考える
for i in s_candidate:
for j in t_candidate:
tmp = abs(x - i) + abs(i - j)
ans = min(ans, tmp)
# tをさきに訪れるパターンを考える
for k in t_candidate:
for l in s_candidate:
tmp = abs(x - k) + abs(k - l)
ans = min(ans, tmp)
print(ans)
main()
|
import bisect
import sys
input = sys.stdin.readline
def main():
A, B, Q = list(map(int, input().split()))
s = list(int(eval(input())) for _ in range(A))
t = list(int(eval(input())) for _ in range(B))
sort_s = sorted(s)
sort_t = sorted(t)
for _ in range(Q):
x = int(eval(input()))
s_near = bisect.bisect_left(sort_s, x)
t_near = bisect.bisect_left(sort_t, x)
s_candidate = []
t_candidate = []
if s_near == 0:
s_candidate.append(sort_s[s_near])
elif s_near == A:
s_candidate.append(sort_s[s_near-1])
else:
s_candidate.append(sort_s[s_near])
s_candidate.append(sort_s[s_near-1])
if t_near == 0:
t_candidate.append(sort_t[t_near])
elif t_near == B:
t_candidate.append(sort_t[t_near-1])
else:
t_candidate.append(sort_t[t_near])
t_candidate.append(sort_t[t_near-1])
ans = float('inf')
# sを先に訪れるパターンを考える
for i in s_candidate:
for j in t_candidate:
tmp = abs(x - i) + abs(i - j)
ans = min(ans, tmp)
# tをさきに訪れるパターンを考える
for k in t_candidate:
for l in s_candidate:
tmp = abs(x - k) + abs(k - l)
ans = min(ans, tmp)
print(ans)
main()
|
p03112
|
import bisect
A, B, Q = list(map(int, input().split()))
shrines = []
for i in range(A):
shrines.append(int(eval(input())))
temples = []
for i in range(B):
temples.append(int(eval(input())))
shortest_s_to_t = {}
for shrine in shrines:
index = bisect.bisect_left(temples, shrine)
if index == 0:
distance = abs(shrine - temples[index])
shortest_s_to_t[shrine] = distance
elif index == B:
distance = abs(shrine - temples[index - 1])
shortest_s_to_t[shrine] = distance
else:
distance_left = abs(shrine - temples[index - 1])
distance_right = abs(shrine - temples[index])
shortest_s_to_t[shrine] = min(distance_left, distance_right)
shortest_t_to_s = {}
for temple in temples:
index = bisect.bisect_left(shrines, temple)
if index == 0:
distance = abs(temple - shrines[index])
shortest_t_to_s[temple] = distance
elif index == A:
distance = abs(temple - shrines[index - 1])
shortest_t_to_s[temple] = distance
else:
distance_left = abs(temple - shrines[index - 1])
distance_right = abs(temple - shrines[index])
shortest_t_to_s[temple] = min(distance_left, distance_right)
for i in range(Q):
x = int(eval(input()))
# shrine to temple
index = bisect.bisect_left(shrines, x)
ans = 10**11
if index > 0:
left_shrine = shrines[index - 1]
candidate = abs(x - left_shrine) + shortest_s_to_t[left_shrine]
ans = min(ans, candidate)
if index < A:
right_shrine = shrines[index]
candidate = abs(x - right_shrine) + shortest_s_to_t[right_shrine]
ans = min(ans, candidate)
# temple to shrine
index = bisect.bisect_left(temples, x)
if index > 0:
left_temple = temples[index - 1]
candidate = abs(x - left_temple) + shortest_t_to_s[left_temple]
ans = min(ans, candidate)
if index < B:
right_temple = temples[index]
candidate = abs(x - right_temple) + shortest_t_to_s[right_temple]
ans = min(ans, candidate)
print(ans)
|
import bisect
import sys
def input():
return sys.stdin.readline()
A, B, Q = list(map(int, input().split()))
shrines = []
for i in range(A):
shrines.append(int(eval(input())))
temples = []
for i in range(B):
temples.append(int(eval(input())))
shortest_s_to_t = {}
for shrine in shrines:
index = bisect.bisect_left(temples, shrine)
if index == 0:
distance = abs(shrine - temples[index])
shortest_s_to_t[shrine] = distance
elif index == B:
distance = abs(shrine - temples[index - 1])
shortest_s_to_t[shrine] = distance
else:
distance_left = abs(shrine - temples[index - 1])
distance_right = abs(shrine - temples[index])
shortest_s_to_t[shrine] = min(distance_left, distance_right)
shortest_t_to_s = {}
for temple in temples:
index = bisect.bisect_left(shrines, temple)
if index == 0:
distance = abs(temple - shrines[index])
shortest_t_to_s[temple] = distance
elif index == A:
distance = abs(temple - shrines[index - 1])
shortest_t_to_s[temple] = distance
else:
distance_left = abs(temple - shrines[index - 1])
distance_right = abs(temple - shrines[index])
shortest_t_to_s[temple] = min(distance_left, distance_right)
for i in range(Q):
x = int(eval(input()))
# shrine to temple
index = bisect.bisect_left(shrines, x)
ans = 10**11
if index > 0:
left_shrine = shrines[index - 1]
candidate = abs(x - left_shrine) + shortest_s_to_t[left_shrine]
ans = min(ans, candidate)
if index < A:
right_shrine = shrines[index]
candidate = abs(x - right_shrine) + shortest_s_to_t[right_shrine]
ans = min(ans, candidate)
# temple to shrine
index = bisect.bisect_left(temples, x)
if index > 0:
left_temple = temples[index - 1]
candidate = abs(x - left_temple) + shortest_t_to_s[left_temple]
ans = min(ans, candidate)
if index < B:
right_temple = temples[index]
candidate = abs(x - right_temple) + shortest_t_to_s[right_temple]
ans = min(ans, candidate)
print(ans)
|
p03112
|
# -*- coding: utf-8 -*-
"""
D - Lazy Faith
https://atcoder.jp/contests/abc119/tasks/abc119_d
"""
import sys
from bisect import bisect_left, bisect_right
def solve(x):
i = bisect_right(shrines, x)
ds = x - shrines[i-1]
j = bisect_right(temples, x)
dt = x - temples[j-1]
ans1 = max(ds, dt)
i = bisect_left(shrines, x)
ds = shrines[i] - x
j = bisect_left(temples, x)
dt = temples[j] - x
ans2 = max(ds, dt)
i = bisect_left(shrines, x)
ds = shrines[i] - x
j = bisect_right(temples, x)
dt = x - temples[j-1]
ans3 = min(ds, dt) * 2 + max(ds, dt)
i = bisect_right(shrines, x)
ds = x - shrines[i-1]
j = bisect_left(temples, x)
dt = temples[j] - x
ans4 = min(ds, dt) * 2 + max(ds, dt)
return min(ans1, ans2, ans3, ans4)
shrines = None
temples = None
def main(args):
global shrines, temples
A, B, Q = list(map(int, input().split()))
shrines = sorted([int(eval(input())) for _ in range(A)] + [float('-inf'), float('inf')])
temples = sorted([int(eval(input())) for _ in range(B)] + [float('-inf'), float('inf')])
for _ in range(Q):
x = int(eval(input()))
ans = solve(x)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
D - Lazy Faith
https://atcoder.jp/contests/abc119/tasks/abc119_d
"""
import sys
from bisect import bisect_left, bisect_right
def solve(x):
i = bisect_right(shrines, x)
s_left = x - shrines[i-1]
j = bisect_right(temples, x)
t_left = x - temples[j-1]
i = bisect_left(shrines, x)
s_right = shrines[i] - x
j = bisect_left(temples, x)
t_right = temples[j] - x
ans1 = max(s_left, t_left)
ans2 = max(s_right, t_right)
ans3 = min(s_right, t_left) * 2 + max(s_right, t_left)
ans4 = min(s_left, t_right) * 2 + max(s_left, t_right)
return min(ans1, ans2, ans3, ans4)
shrines = None
temples = None
def main(args):
global shrines, temples
A, B, Q = list(map(int, input().split()))
shrines = [float('-inf')] + [int(eval(input())) for _ in range(A)] + [float('inf')]
temples = [float('-inf')] + [int(eval(input())) for _ in range(B)] + [float('inf')]
for _ in range(Q):
x = int(eval(input()))
ans = solve(x)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
|
p03112
|
#coding:utf-8
import bisect,math
import multiprocessing
A,B,Q=list(map(int,input().split()))
s=[0]*A
t=[0]*B
for i in range(A):
s[i]=eval(input())
for i in range(B):
t[i]=eval(input())
buf=[]
def f(x):
sl=bisect.bisect_left(s,x)-1
sr=sl+1
tl=bisect.bisect_left(t,x)-1
tr=tl+1
ans=float("inf")
if sl!=-1 and tl!=-1:
A=max(s[sl],t[tl])
B=min(s[sl],t[tl])
L=abs(x-A)+abs(A-B)
ans=min(ans,L)
if sl!=-1 and tr!=len(t):
L=abs(x-s[sl])*2 + abs(t[tr]-x)
ans=min(ans,L)
ans=min(ans,abs(x-s[sl])+abs(t[tr]-x)*2)
if tl!=-1 and sr!=len(s):
ans=min(ans,abs(x-t[tl])*2+abs(s[sr]-x))
ans=min(ans,abs(x-t[tl])+abs(s[sr]-x)*2)
if tr!=len(t) and sr!=len(s):
A=min(s[sr],t[tr])
B=max(s[sr],t[tr])
L=abs(A-x)+abs(B-A)
ans=min(ans,L)
return str(ans)
I=[0]*Q
for i in range(Q):
I[i]=eval(input())
r=list(map(f,I))
print(("\n".join(r)))
|
#coding:utf-8
import bisect,sys
A,B,Q=list(map(int,input().split()))
s=[0]*A
t=[0]*B
for i in range(A):
s[i]=int(sys.stdin.readline())
for i in range(B):
t[i]=int(sys.stdin.readline())
buf=[]
def f(x):
sl=bisect.bisect_left(s,x)-1
sr=sl+1
tl=bisect.bisect_left(t,x)-1
tr=tl+1
ans=float("inf")
if sl!=-1 and tl!=-1:
A=max(s[sl],t[tl])
B=min(s[sl],t[tl])
L=abs(x-A)+abs(A-B)
ans=min(ans,L)
if sl!=-1 and tr!=len(t):
L=abs(x-s[sl])*2 + abs(t[tr]-x)
ans=min(ans,L)
ans=min(ans,abs(x-s[sl])+abs(t[tr]-x)*2)
if tl!=-1 and sr!=len(s):
ans=min(ans,abs(x-t[tl])*2+abs(s[sr]-x))
ans=min(ans,abs(x-t[tl])+abs(s[sr]-x)*2)
if tr!=len(t) and sr!=len(s):
A=min(s[sr],t[tr])
B=max(s[sr],t[tr])
L=abs(A-x)+abs(B-A)
ans=min(ans,L)
return str(ans)
I=[0]*Q
for i in range(Q):
I[i]=int(sys.stdin.readline())
r=list(map(f,I))
print(("\n".join(r)))
|
p03112
|
import bisect
import sys
A, B, Q = list(map(int,input().split()))
s = [-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*A))) + [10**18]
t = [-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*B))) + [10**18]
def solve(s,t,x):
ans = 10**18
for i in range(2):
a, b = (s, t) if i==0 else (t, s)
posX1 = bisect.bisect_left(a,x)
for j in range(2):
ax = a[posX1 -j]
posX2 = bisect.bisect_left(b,ax)
for k in range(2):
bx = b[posX2-k]
ans = min(ans, abs(x-ax)+abs(bx-ax))
return ans
for _ in range(Q):
x = int(eval(input()))
print((solve(s,t,x)))
|
import bisect
import sys
A, B, Q = list(map(int,input().split()))
s = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*A))) + [10**18])
t = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*B))) + [10**18])
def solve(s,t,x):
ans = 10**18
for i in range(2):
a, b = (s, t) if i==0 else (t, s)
posX1 = bisect.bisect_left(a,x)
for j in range(2):
ax = a[posX1 -j]
posX2 = bisect.bisect_left(b,ax)
for k in range(2):
bx = b[posX2-k]
ans = min(ans, abs(x-ax)+abs(bx-ax))
return ans
for _ in range(Q):
x = int(eval(input()))
print((solve(s,t,x)))
|
p03112
|
import bisect
import sys
A, B, Q = list(map(int,input().split()))
s = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*A))) + [10**18])
t = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*B))) + [10**18])
def solve(s,t,x):
ans = 10**18
for i in range(2):
a, b = (s, t) if i==0 else (t, s)
posX1 = bisect.bisect_left(a,x)
for j in range(2):
ax = a[posX1 -j]
posX2 = bisect.bisect_left(b,ax)
for k in range(2):
bx = b[posX2-k]
ans = min(ans, abs(x-ax)+abs(bx-ax))
return ans
for _ in range(Q):
x = int(eval(input()))
print((solve(s,t,x)))
|
import bisect
import sys
A, B, Q = map(int,input().split())
s = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*A))) + [10**18])
t = tuple([-(10**18)] + list(map(int, (sys.stdin.readline() for _ in [0]*B))) + [10**18])
def solve(s,t,x):
ans = 10**18
for i in range(2):
a, b = (s, t) if i==0 else (t, s)
posX1 = bisect.bisect_left(a,x)
for j in range(2):
ax = a[posX1 -j]
posX2 = bisect.bisect_left(b,ax)
for k in range(2):
bx = b[posX2-k]
ans = min(ans, abs(x-ax)+abs(bx-ax))
return ans
ans = [solve(s,t,x) for x in map(int,sys.stdin)]
print(*ans, sep="\n")
|
p03112
|
from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
BIG = 10**10 + 1
S = [-BIG] + [int(eval(input())) for _ in range(A)] + [BIG*2]
T = [-BIG] + [int(eval(input())) for _ in range(B)] + [BIG*2]
for _ in range(Q):
x = int(eval(input()))
shrine_b = bisect_right(S, x)
dsl = x-S[shrine_b-1]
dsr = S[shrine_b]-x
temple_b = bisect_right(T, x)
dtl = x-T[temple_b-1]
dtr = T[temple_b]-x
print((min(
dsl if dsl > dtl else dtl,
dsr if dsr > dtr else dtr,
dsl * 2 + dtr,
dsl + dtr * 2,
dsr * 2 + dtl,
dsr + dtl * 2
)))
|
from bisect import bisect_left
A, B, Q = list(map(int, input().split()))
BIG = 10**10 + 1
S = [-BIG] + sorted([int(eval(input())) for _ in range(A)]) + [BIG*2]
T = [-BIG] + sorted([int(eval(input())) for _ in range(B)]) + [BIG*2]
for _ in range(Q):
x = int(eval(input()))
shrine_b = bisect_left(S, x)
shrine_l = S[shrine_b-1]
shrine_r = S[shrine_b]
temple_b = bisect_left(T, x)
temple_l = T[temple_b-1]
temple_r = T[temple_b]
print((min(
x-shrine_l if shrine_l < temple_l else x-temple_l,
shrine_r-x if shrine_r > temple_r else temple_r-x,
(x-shrine_l) * 2 + temple_r-x,
x-shrine_l + (temple_r-x) * 2,
(shrine_r-x) * 2 + x-temple_l,
shrine_r-x + (x-temple_l) * 2
)))
|
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)]
for x in X:
s_min = A-1
for i in range(A):
if s[i] > x:
s_min = i-1
break
t_min = B-1
for i in range(B):
if t[i] > x:
t_min = i-1
break
if s_min == -1:
if t_min == -1:
print((max(s[0]-x, t[0]-x)))
elif t_min == B-1:
print((s[0]-t[t_min]+min(s[0]-x, t[t_min]-x)))
else:
print((min(t[t_min+1]-x, s[0]-t[t_min]+min(s[0]-x, t[t_min]-x))))
elif s_min == A-1:
if t_min == -1:
print((t[0]-s[s_min] + min(t[0]-x, x-s[s_min])))
elif t_min == B-1:
print((max(x-s[s_min], x-t[t_min])))
else:
print((min(x-t[t_min], t[t_min+1]-s[s_min] + min(t[t_min+1]-x, x-s[s_min]))))
else:
if t_min == -1:
if t[0] < s[s_min+1]:
print((min(s[s_min + 1] - x, t[0] - s[s_min] + min(t[0] - x, x-s[s_min]))))
else:
print((t[0]-x))
elif t_min == B-1:
print((min(x - s[s_min], s[s_min + 1] - t[t_min] + min(s[s_min + 1] - x, x - t[t_min]))))
else:
if s[s_min] < t[t_min]:
if s[s_min+1] < t[t_min+1]:
print((min(x-s[s_min], t[t_min+1] - x, s[s_min+1] - t[t_min] + min(x-t[t_min], s[s_min+1]-x))))
else:
print((min(x-s[s_min], s[s_min+1]-x)))
else:
if s[s_min+1] < t[t_min+1]:
print((min(t[t_min+1]-x, x-t[t_min])))
else:
print((min(x-t[t_min], s[s_min+1] - x, t[t_min+1] - s[s_min] + min(x-s[s_min], t[t_min+1]-x))))
|
import bisect
A, B, Q = list(map(int, input().split()))
INF = 10**18
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:
s_min = bisect.bisect_left(s, x)
t_min = bisect.bisect_left(t, x)
cost = INF
for S in [s[s_min-1], s[s_min]]:
for T in [t[t_min-1], t[t_min]]:
cost = min(cost, abs(T-S)+abs(T-x), abs(T-S)+abs(S-x))
print(cost)
|
p03112
|
from bisect import bisect_left,bisect_right
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()))
values = []
p1 = bisect_left(S,x)
if p1 == 0:
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
elif p1 == A:
p1 -= 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
#-1
p1 -= 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
p1 += 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
p1 = bisect_left(T,x)
if p1 == 0:
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
elif p1 == B:
p1 -= 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
#-1
p1 -= 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
p1 += 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
d = min(values)
print(d)
|
from bisect import bisect_left,bisect_right
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
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()))
values = []
p1 = bisect_left(S,x)
if p1 == 0:
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
elif p1 == A:
p1 -= 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
#-1
p1 -= 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
p1 += 1
p2 = bisect_left(T,S[p1])
if p2 == 0:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
elif p2 == B:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
else:
values.append(abs(x-S[p1])+abs(S[p1]-T[p2]))
values.append(abs(x-S[p1])+abs(S[p1]-T[p2-1]))
p1 = bisect_left(T,x)
if p1 == 0:
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
elif p1 == B:
p1 -= 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
#-1
p1 -= 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
p1 += 1
p2 = bisect_left(S,T[p1])
if p2 == 0:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
elif p2 == A:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
else:
values.append(abs(x-T[p1])+abs(T[p1]-S[p2]))
values.append(abs(x-T[p1])+abs(T[p1]-S[p2-1]))
d = min(values)
print(d)
|
p03112
|
# coding: utf-8
# Your code here!
A,B,Q=list(map(int,input().split()))
def bisearch(target,lis):
low=0
high=len(lis)-1
if lis[0]>target:
return low-1
elif lis[-1]<target:
return high
while lis[low]>target or lis[low+1]<target:
mid=(low+high)//2
if lis[mid]<target:
high=mid
else:
low=mid
return low
def cand(num,lis):
N=len(lis)-1
a=max(num,0)
b=min(num+1,N)
return [lis[a],lis[b]]
god=[]
for _ in range(A):
god.append(int(eval(input())))
buddha=[]
for _ in range(B):
buddha.append(int(eval(input())))
for _ in range(Q):
q=int(eval(input()))
g_i=(bisearch(q,god))
b_i=(bisearch(q,buddha))
G=cand(g_i,god)
B=cand(b_i,buddha)
ans=10**18
ans=min(abs(q-G[0])+abs(G[0]-B[0]),abs(q-B[0])+abs(B[0]-G[0]),abs(q-G[1])+abs(G[1]-B[0]),abs(q-B[0])+abs(B[0]-G[1]),abs(q-G[0])+abs(G[0]-B[1]),abs(q-B[1])+abs(B[1]-G[0]),abs(q-G[1])+abs(G[1]-B[1]),abs(q-B[1])+abs(B[1]-G[1]))
for g in G:
for b in B:
ans=min(ans,abs(q-g)+abs(g-b),abs(q-b)+abs(b-g))
print(ans)
|
# coding: utf-8
# Your code here!
import bisect
A,B,Q=list(map(int,input().split()))
god=[-10**18]
for _ in range(A):
god.append(int(eval(input())))
god.append(10**18)
buddha=[-10**18]
for _ in range(B):
buddha.append(int(eval(input())))
buddha.append(10**18)
#print(god,buddha)
for _ in range(Q):
q=int(eval(input()))
g_i=bisect.bisect_left(god, q)
b_i=bisect.bisect_left(buddha, q)
#print(g_i,b_i)
ans=10**18
G=[god[g_i-1],god[g_i]]
B=[buddha[b_i-1],buddha[b_i]]
for g in G:
for b in B:
ans=min(ans,abs(q-g)+abs(g-b),abs(q-b)+abs(b-g))
print(ans)
|
p03112
|
A, B, Q = [int(_) for _ in input().split()]
S = [int(eval(input())) for i in range(A)]
T = [int(eval(input())) for i in range(B)]
Q = [int(eval(input())) for i in range(Q)]
#print(S, T, Q)
def calc_m(xs):
return [(a + b) / 2 for a, b in zip(xs, xs[1:])]
sm = calc_m(S)
tm = calc_m(T)
#print(sm)
#print(tm)
import bisect
def calc_nearest_0(xs, y, ym):
result = []
i = 0
for x in xs:
while i < len(ym) and x >= ym[i]:
i += 1
result.append(y[i])
return result
def calc_nearest(xs, y, ym):
result = []
for x in xs:
i = bisect.bisect(ym, x)
result.append(y[i])
return result
sn = calc_nearest(S, T, tm)
tn = calc_nearest(T, S, sm)
#print(sn)
#print(tn)
def solve(q, S, T, sn, tn):
nsp = bisect.bisect(S, q)
ntp = bisect.bisect(T, q)
rs = []
if 0 <= nsp < len(S):
rs.append(abs(S[nsp] - q) + abs(S[nsp] - sn[nsp]))
nsp -= 1
if 0 <= nsp < len(S):
rs.append(abs(S[nsp] - q) + abs(S[nsp] - sn[nsp]))
if 0 <= ntp < len(T):
rs.append(abs(T[ntp] - q) + abs(T[ntp] - tn[ntp]))
ntp -= 1
if 0 <= ntp < len(T):
rs.append(abs(T[ntp] - q) + abs(T[ntp] - tn[ntp]))
# print("Q", q, S, T, sn, tn, r1, r2)
return min(rs)
for q in Q:
print((solve(q, S, T, sn, tn)))
|
A, B, Q = [int(_) for _ in input().split()]
S = [int(eval(input())) for i in range(A)]
T = [int(eval(input())) for i in range(B)]
Q = [int(eval(input())) for i in range(Q)]
import bisect
def calc_nearest_distance(xs, ys):
result = []
for x in xs:
i = bisect.bisect(ys, x)
if i == 0:
d = abs(ys[i] - x)
elif i < len(ys):
d = min(abs(ys[i - 1] - x), abs(ys[i] - x))
else:
d = abs(ys[i - 1] - x)
result.append(d)
return result
sn = calc_nearest_distance(S, T)
tn = calc_nearest_distance(T, S)
def solve(q, S, T, sn, tn):
nsp = bisect.bisect(S, q)
ntp = bisect.bisect(T, q)
rs = []
if 0 <= nsp < len(S):
rs.append(abs(S[nsp] - q) + sn[nsp])
if 0 <= nsp - 1 < len(S):
rs.append(abs(S[nsp - 1] - q) + sn[nsp - 1])
if 0 <= ntp < len(T):
rs.append(abs(T[ntp] - q) + tn[ntp])
if 0 <= ntp - 1 < len(T):
rs.append(abs(T[ntp - 1] - q) + tn[ntp - 1])
return min(rs)
for q in Q:
print((solve(q, S, T, sn, tn)))
|
p03112
|
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 i in range(len(x)):
s_RL = most_simRL(s, x[i])
t_RL = most_simRL(t, x[i])
ans = sys.maxsize
for st in itertools.product(s_RL, t_RL):
distance = calc(st[0], st[1], x[i])
if ans > distance:
ans = distance
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]
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)
|
p03112
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.