input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
from itertools import product
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
a = []
for i, j in product(A[0:K+1], B[0:K+1]):
a.append(i + j)
ans_list = []
for i, j in product(a, C[0:K+1]):
ans_list.append(i + j)
ans_list.sort(reverse=True)
for i in range(K):
print((ans_list[i]))
|
from itertools import product
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
a = []
count = 0
for i in range(X):
for j in range(Y):
if (i+1)*(j+1) > K:
break
for k in range(Z):
if (i+1)*(j+1)*(k+1) > K:
break
a.append(A[i] + B[j] + C[k])
a.sort(reverse=True)
for i in range(K):
print((a[i]))
|
p03078
|
a, b, c, d = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
cl = list(map(int, input().split()))
al = sorted(al, reverse=True)
bl = sorted(bl, reverse=True)
cl = sorted(cl, reverse=True)
q = [[al[0] + bl[0] + cl[0], 0, 0, 0]]
ans = [[al[0] + bl[0] + cl[0], 0, 0, 0]]
c = -1
#while True:
#c += 1
for i in range(d):
#print(c)
#print(len(ans))
s, aq, bq, cq = list(map(int, q.pop()))
if len(al) > aq+1:
if [al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq] not in ans:
q.append([al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq])
ans.append([al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq])
if len(bl) > bq+1:
if [al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq] not in ans:
q.append([al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq])
ans.append([al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq])
if len(cl) > cq+1:
if [al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1] not in ans:
q.append([al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1])
ans.append([al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1])
q = sorted(q)
if len(ans) > d:
ans = sorted(ans, reverse=True)
if ans[d-1][0] > q[len(q)-1][0]:
break
ans = sorted(ans, reverse=True)
for i in range(d):
print((ans[i][0]))
|
a, b, c, d = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
cl = list(map(int, input().split()))
al = sorted(al, reverse=True)
bl = sorted(bl, reverse=True)
cl = sorted(cl, reverse=True)
q = [[al[0] + bl[0] + cl[0], 0, 0, 0]]
ans = [[al[0] + bl[0] + cl[0], 0, 0, 0]]
c = -1
#while True:
#c += 1
for i in range(d):
#print(c)
#print(len(ans))
s, aq, bq, cq = list(map(int, q.pop()))
if len(al) > aq+1:
if [al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq] not in ans:
q.append([al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq])
ans.append([al[aq+1] + bl[bq] + cl[cq], aq+1, bq, cq])
if len(bl) > bq+1:
if [al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq] not in ans:
q.append([al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq])
ans.append([al[aq] + bl[bq+1] + cl[cq], aq, bq+1, cq])
if len(cl) > cq+1:
if [al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1] not in ans:
q.append([al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1])
ans.append([al[aq] + bl[bq] + cl[cq+1], aq, bq, cq+1])
q = sorted(q)
#if len(ans) > d:
# ans = sorted(ans, reverse=True)
# if ans[d-1][0] > q[len(q)-1][0]:
# break
ans = sorted(ans, reverse=True)
for i in range(d):
print((ans[i][0]))
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
list_cake_1 = list(map(int, input().split()))
list_cake_2 = list(map(int, input().split()))
list_cake_3 = list(map(int, input().split()))
list_cake_1 = sorted(list_cake_1, reverse=True)
list_cake_2 = sorted(list_cake_2, reverse=True)
list_cake_3 = sorted(list_cake_3, reverse=True)
list_total_sum = [cake_1 + cake_2 + cake_3 for i, cake_1 in enumerate(list_cake_1, 1) for j, cake_2 in enumerate(list_cake_2, 1) for k, cake_3 in enumerate(list_cake_3, 1) if i*j*k <= K]
for element in sorted(list_total_sum, reverse=True)[:K]:
print(element)
|
import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
list_cake_1 = list(map(int, input().split()))
list_cake_2 = list(map(int, input().split()))
list_cake_3 = list(map(int, input().split()))
list_cake_1 = sorted(list_cake_1, reverse=True)
list_cake_2 = sorted(list_cake_2, reverse=True)
list_cake_3 = sorted(list_cake_3, reverse=True)
list_total_sum = []
for i, cake_1 in enumerate(list_cake_1, 1):
for j, cake_2 in enumerate(list_cake_2, 1):
for k, cake_3 in enumerate(list_cake_3, 1):
if i*j*k > K:
break
list_total_sum.append(cake_1 + cake_2 + cake_3)
for element in sorted(list_total_sum, reverse=True)[:K]:
print(element)
|
p03078
|
import heapq
X,Y,Z,K = list(map(int,input().split()))
A = sorted(list(map(int,input().split())),reverse=1)
B = sorted(list(map(int,input().split())),reverse=1)
C = sorted(list(map(int,input().split())),reverse=1)
Q = [(-A[0]-B[0]-C[0],0,0,0)]
heapq.heapify(Q)
abc = [[[1 for i in range(Z)] for j in range(Y)] for k in range(X)]
for i in range(K):
n,a,b,c = heapq.heappop(Q)
if a < X-1 and abc[a+1][b][c]:
abc[a+1][b][c] = 0
heapq.heappush(Q,(n+A[a]-A[a+1],a+1,b,c))
if b < Y-1 and abc[a][b+1][c]:
abc[a][b+1][c] = 0
heapq.heappush(Q,(n+B[b]-B[b+1],a,b+1,c))
if c < Z-1 and abc[a][b][c+1]:
abc[a][b][c+1] = 0
heapq.heappush(Q,(n+C[c]-C[c+1],a,b,c+1))
print((-n))
|
import heapq
X,Y,Z,K = list(map(int,input().split()))
A = sorted(list(map(int,input().split())),reverse=1)
B = sorted(list(map(int,input().split())),reverse=1)
C = sorted(list(map(int,input().split())),reverse=1)
Q = [(-A[0]-B[0]-C[0],0,0,0)]
heapq.heapify(Q)
abc = [(0,0,0)]
for i in range(K):
n,a,b,c = heapq.heappop(Q)
if a < X-1 and (a+1,b,c) not in abc:
abc.append((a+1,b,c))
heapq.heappush(Q,(n+A[a]-A[a+1],a+1,b,c))
if b < Y-1 and (a,b+1,c) not in abc:
abc.append((a,b+1,c))
heapq.heappush(Q,(n+B[b]-B[b+1],a,b+1,c))
if c < Z-1 and (a,b,c+1) not in abc:
abc.append((a,b,c+1))
heapq.heappush(Q,(n+C[c]-C[c+1],a,b,c+1))
print((-n))
|
p03078
|
from heapq import heappop, heappush
X, Y, Z, K = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
B = [int(s) for s in input().split()]
C = [int(s) for s in input().split()]
h = []
for i in range(X):
for j in range(Y):
for k in range(Z):
heappush(h, -(A[i] + B[j] + C[k]))
for _ in range(K):
print((-heappop(h)))
|
from heapq import heappop, heappush
X, Y, Z, K = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
B = [int(s) for s in input().split()]
C = [int(s) for s in input().split()]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
counted = set()
h = [(-(A[0] + B[0] + C[0]), 0, 0, 0)]
for _ in range(K):
s, i, j, k = heappop(h)
print((-s))
if X > i+1 and (i+1, j, k) not in counted:
heappush(h, (-(A[i+1] + B[j] + C[k]), i+1, j, k))
counted.add((i+1, j, k))
if Y > j+1 and (i, j+1, k) not in counted:
heappush(h, (-(A[i] + B[j+1] + C[k]), i, j+1, k))
counted.add((i, j+1, k))
if Z > k+1 and (i, j, k+1) not in counted:
heappush(h, (-(A[i] + B[j] + C[k+1]), i, j, k+1))
counted.add((i, j, k+1))
|
p03078
|
import heapq as hq
x, y, z, k = list(map(int,input().split()))
arr_a = sorted(list(map(int,input().split())) ,reverse = True)
arr_b = sorted(list(map(int,input().split())) ,reverse = True)
arr_c = sorted(list(map(int,input().split())) ,reverse = True)
cnt = [[[0 for i in range(z)] for j in range(y)] for k in range(x)]
P_q = [[-(arr_a[0] + arr_b[0] + arr_c[0]),0,0,0]]
cnt[0][0][0] = 1
for _ in range(k):
tmp = hq.heappop(P_q)
t, i, j, k = -tmp[0],tmp[1],tmp[2],tmp[3]
print(t)
if i + 1 < x and cnt[i+1][j][k] == 0:
hq.heappush(P_q,[-(arr_a[i+1] + arr_b[j] + arr_c[k]) ,i + 1,j,k])
cnt[i+1][j][k] = 1
if j + 1 < y and cnt[i][j + 1][k] == 0:
hq.heappush(P_q,[-(arr_a[i] + arr_b[j+1] + arr_c[k]) ,i ,j + 1,k])
cnt[i][j+1][k] = 1
if k + 1 < z and cnt[i][j][k + 1] == 0:
hq.heappush(P_q,[-(arr_a[i] + arr_b[j] + arr_c[k + 1]) ,i,j,k + 1])
cnt[i][j][k + 1] = 1
|
import heapq as hq
x, y, z, k = list(map(int,input().split()))
arr_a = sorted(list(map(int,input().split())) ,reverse = True)
arr_b = sorted(list(map(int,input().split())) ,reverse = True)
arr_c = sorted(list(map(int,input().split())) ,reverse = True)
cnt = set()
P_q = [[-(arr_a[0] + arr_b[0] + arr_c[0]),0,0,0]]
cnt.add((0,0,0))
for _ in range(k):
tmp = hq.heappop(P_q)
t, i, j, k = -tmp[0],tmp[1],tmp[2],tmp[3]
print(t)
if i + 1 < x and (i+1,j,k) not in cnt:
hq.heappush(P_q,[-(arr_a[i+1] + arr_b[j] + arr_c[k]) ,i + 1,j,k])
cnt.add((i+1,j,k))
if j + 1 < y and (i,j+1,k) not in cnt:
hq.heappush(P_q,[-(arr_a[i] + arr_b[j+1] + arr_c[k]) ,i ,j + 1,k])
cnt.add((i,j+1,k))
if k + 1 < z and (i,j,k+1) not in cnt:
hq.heappush(P_q,[-(arr_a[i] + arr_b[j] + arr_c[k + 1]) ,i,j,k + 1])
cnt.add((i,j,k+1))
|
p03078
|
import heapq as hq
x,y,z,k = list(map(int,input().split()))
a = list([int(x) * (-1) for x in input().split()])
b =list([int(x) * (-1) for x in input().split()])
c = list([int(x) * (-1) for x in input().split()])
a.sort()
b.sort()
c.sort()
possibles = [(a[0]+b[0]+c[0],0,0,0)]
done = [[[0 for _ in range(z)]for _ in range(y)] for _ in range(x)]
done[0][0][0] = 1
def neibor(ai,bi,ci,possibles,done):
for aj,bj,cj in [(ai+1,bi,ci),(ai,bi+1,ci),(ai,bi,ci+1)]:
if (aj<=x-1) and (bj<=y-1) and (cj<=z-1) and (not done[aj][bj][cj]):
hq.heappush(possibles,(a[aj]+b[bj]+c[cj],aj,bj,cj))
done[aj][bj][cj] = 1
def conf(possibles,done):
yam,ai,bi,ci = hq.heappop(possibles)
print((-1*yam))
neibor(ai,bi,ci,possibles,done)
for i in range(k):
yam,ai,bi,ci = hq.heappop(possibles)
print((-1*yam))
for aj,bj,cj in [(ai+1,bi,ci),(ai,bi+1,ci),(ai,bi,ci+1)]:
if (aj<=x-1) and (bj<=y-1) and (cj<=z-1) and (not done[aj][bj][cj]):
hq.heappush(possibles,(a[aj]+b[bj]+c[cj],aj,bj,cj))
done[aj][bj][cj] = 1
|
import heapq as hq
x,y,z,k = list(map(int,input().split()))
a = list([int(x) * (-1) for x in input().split()])
b =list([int(x) * (-1) for x in input().split()])
c = list([int(x) * (-1) for x in input().split()])
a.sort()
b.sort()
c.sort()
possibles = [(a[0]+b[0]+c[0],0,0,0)]
done = set()
done |= {(0,0,0)}
def neibor(ai,bi,ci,possibles,done):
for aj,bj,cj in [(ai+1,bi,ci),(ai,bi+1,ci),(ai,bi,ci+1)]:
if (aj<=x-1) and (bj<=y-1) and (cj<=z-1) and (not (aj,bj,cj) in done):
hq.heappush(possibles,(a[aj]+b[bj]+c[cj],aj,bj,cj))
done |= {(aj,bj,cj)}
def conf(possibles,done):
yam,ai,bi,ci = hq.heappop(possibles)
print((-1*yam))
neibor(ai,bi,ci,possibles,done)
for i in range(k):
yam,ai,bi,ci = hq.heappop(possibles)
print((-1*yam))
for aj,bj,cj in [(ai+1,bi,ci),(ai,bi+1,ci),(ai,bi,ci+1)]:
if (aj<=x-1) and (bj<=y-1) and (cj<=z-1) and (not (aj,bj,cj) in done):
hq.heappush(possibles,(a[aj]+b[bj]+c[cj],aj,bj,cj))
done |= {(aj,bj,cj)}
|
p03078
|
from heapq import heappush, nlargest
def main():
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
h = []
for i in A:
for j in B:
for k in C:
heappush(h, i + j + k)
for i in nlargest(K, h):
print(i)
if __name__ == "__main__":
main()
|
from heapq import heappush, nlargest
def main():
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
h = []
for i in A:
for j in B:
heappush(h, i + j)
H = []
for i in nlargest(K, h):
for j in C:
heappush(H, i+j)
for i in nlargest(K, H):
print(i)
if __name__ == "__main__":
main()
|
p03078
|
from operator import itemgetter
K = int(input().split()[-1])
A = sorted([int(e) for e in input().split()], reverse=True)
B = sorted([int(e) for e in input().split()], reverse=True)
C = sorted([int(e) for e in input().split()], reverse=True)
def get_next_iter(i, _list):
if i < len(_list) - 1:
return i + 1
else:
return i
values = []
ia = ib = ic = 0
def get_value(ia, ib, ic):
return A[ia] + B[ib] + C[ic]
def get_next(ia, ib, ic):
ia_n = get_next_iter(ia, A)
ib_n = get_next_iter(ib, B)
ic_n = get_next_iter(ic, C)
s = set()
s.add((ia_n, ib, ic, get_value(ia_n, ib, ic)))
s.add((ia, ib_n, ic, get_value(ia, ib_n, ic)))
s.add((ia, ib, ic_n, get_value(ia, ib, ic_n)))
return s
values.append((ia, ib, ic, get_value(ia, ib, ic)))
candidate = get_next(0, 0, 0)
for k in range(K - 1):
vs = sorted(candidate, reverse=True, key=itemgetter(3))
for i, v in enumerate(vs):
if v not in values:
values.append(v)
candidate.remove(v)
for each in get_next(v[0], v[1], v[2]):
candidate.add(each)
break
else:
continue
for each in values:
print((each[3]))
|
from heapq import heappush, heappop
X, Y, Z, K = list(map(int, input().split()))
A = sorted([int(e) for e in input().split()], reverse=True)
B = sorted([int(e) for e in input().split()], reverse=True)
C = sorted([int(e) for e in input().split()], reverse=True)
def get_value(ai, bi, ci):
return -(A[ai] + B[bi] + C[ci])
heap = []
heappush(heap, (get_value(0, 0, 0), 0, 0, 0))
used = {(0, 0, 0)}
for k in range(K):
v, ia, ib, ic = heappop(heap)
print((-v))
if ia + 1 < X and (ia + 1, ib, ic) not in used:
heappush(heap, (get_value(ia + 1, ib, ic), ia + 1, ib, ic))
used.add((ia + 1, ib, ic))
if ib + 1 < Y and (ia, ib + 1, ic) not in used:
heappush(heap, (get_value(ia, ib + 1, ic), ia, ib + 1, ic))
used.add((ia, ib + 1, ic))
if ic + 1 < Z and (ia, ib, ic + 1) not in used:
heappush(heap, (get_value(ia, ib, ic + 1), ia, ib, ic + 1))
used.add((ia, ib, ic + 1))
|
p03078
|
import heapq
import itertools
x,y,z,k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
l = list(itertools.product(a, b, c))
m = list([sum(x) for x in l])
m2 = heapq.nlargest(k, m)
for i in range(k):
print((m2[i]))
|
import heapq
import itertools
def dif(l):
return max(l) - min(l)
x,y,z,k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
b = sorted(list(map(int, input().split())), reverse=True)
c = sorted(list(map(int, input().split())), reverse=True)
while x*y*z > k and dif(a) > dif(b) and dif(a) > dif(c):
a.pop()
x -= 1
while x*y*z > k and dif(b) > dif(a) and dif(b) > dif(c):
b.pop()
y -= 1
while x*y*z > k and dif(c) > dif(b) and dif(c) > dif(a):
c.pop()
z -= 1
l=[]
for a1 in a:
for b1 in b:
for c1 in c:
l.append(a1+b1+c1)
m2 = heapq.nlargest(k, l)
for i in range(k):
print((m2[i]))
|
p03078
|
from heapq import heapify, heappop, heappush
from collections import defaultdict
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = list(sorted(a, reverse=True))
b = list(sorted(b, reverse=True))
c = list(sorted(c, reverse=True))
t = a[0] + b[0] + c[0]
t *= -1
d = defaultdict(list)
d[t] = [(0, 0, 0)]
q = list()
heapify(q)
heappush(q, t)
a_j = (1, 0, 0)
b_j = (0, 1, 0)
c_j = (0, 0, 1)
st = set()
for i in range(K):
t = heappop(q)
print((-t))
for v in d[t]:
a_i, b_i, c_i = v
for j in range(3):
na_i = a_i + a_j[j]
if na_i >= X: continue
nb_i = b_i + b_j[j]
if nb_i >= Y: continue
nc_i = c_i + c_j[j]
if nc_i >= Z: continue
nt = a[na_i] + b[nb_i] + c[nc_i]
nt *= -1
nv = (na_i, nb_i, nc_i)
# print(nt, nv)
if nv in st: continue
d[nt].append(nv)
st.add(nv)
heappush(q, nt)
|
# https://www.kumilog.net/entry/python-speed-comp#input-%E3%81%A8-sysstdinreadline
# https://teratail.com/questions/88396
from heapq import heapify, heappush, heappop
import sys
input = sys.stdin.readline
class Data:
def __init__(self, value, indices):
self.value = value
self.indices = indices
def __lt__(self, other):
return self.value < other.value
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = list(sorted(a, reverse=True))
b = list(sorted(b, reverse=True))
c = list(sorted(c, reverse=True))
hq = []
heapify(hq)
t = a[0] + b[0] + c[0]
t *= -1
d = Data(t, (0, 0, 0))
heappush(hq, d)
dtpls = ((1, 0, 0), (0, 1, 0), (0, 0, 1))
st = set()
cnt = 0
for _ in range(K):
d = heappop(hq)
print((-d.value))
for dtpl in dtpls:
na = d.indices[0] + dtpl[0]
if na >= X: continue
nb = d.indices[1] + dtpl[1]
if nb >= Y: continue
nc = d.indices[2] + dtpl[2]
if nc >= Z: continue
nt = a[na] + b[nb] + c[nc]
nt *= - 1
ntpl = (na, nb, nc)
if ntpl in st: continue
heappush(hq, Data(nt, ntpl))
st.add(ntpl)
|
p03078
|
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d = [aa + bb for aa in a[:k] for bb in b[:k]]
d.sort(reverse=True)
e = [dd + cc for dd in d[:k] for cc in c[:k]]
e.sort(reverse=True)
print(*e[:k], sep='\n')
|
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d = []
for ai, aa in enumerate(a, 1):
for bi, bb in enumerate(b, 1):
for ci, cc in enumerate(c, 1):
if ai * bi * ci > k:
break
# (ai,bi,ci)より合計の大きい選び方がk通り以上存在する
# (ai,bi)を含む組み合わせは、これ以上調べる必要がない
d.append(aa + bb + cc)
d.sort(reverse=True)
print(*d[:k], sep='\n')
|
p03078
|
def main():
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
A = sorted(map(int, input().split()), reverse=True)
B = sorted(map(int, input().split()), reverse=True)
C = sorted(map(int, input().split()), reverse=True)
ret = sorted(
(a + b + c
for p, a in enumerate(A)
for q, b in enumerate(B)
for r, c in enumerate(C)
if p * q * r <= k
), reverse=True)[:k]
print(*ret, sep='\n')
main()
# O(Klog^3K)
# https://img.atcoder.jp/abc123/editorial.pdf
|
def main():
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
A = sorted(map(int, input().split()), reverse=True)
B = sorted(map(int, input().split()), reverse=True)
C = sorted(map(int, input().split()), reverse=True)
ret = []
for p, a in enumerate(A):
for q, b in enumerate(B):
if p * q > k:
break
for r, c in enumerate(C):
if p * q * r > k:
break
ret.append(a + b + c)
ret.sort(reverse=True)
print(*ret[:k], sep='\n')
main()
# O(Klog^3K)
# https://img.atcoder.jp/abc123/editorial.pdf
|
p03078
|
def main():
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
A = sorted(map(int, input().split()), reverse=True)
B = sorted(map(int, input().split()), reverse=True)
C = sorted(map(int, input().split()), reverse=True)
ret = []
for p, a in enumerate(A):
for q, b in enumerate(B):
if p * q > k:
break
for r, c in enumerate(C):
if p * q * r > k:
break
ret.append(a + b + c)
ret.sort(reverse=True)
print(*ret[:k], sep='\n')
main()
# O(Klog^3K)
# https://img.atcoder.jp/abc123/editorial.pdf
|
def main():
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
A = sorted(map(int, input().split()), reverse=True)
B = sorted(map(int, input().split()), reverse=True)
C = sorted(map(int, input().split()), reverse=True)
ret = []
for p, a in enumerate(A, 1):
for q, b in enumerate(B, 1):
if p * q > k:
break
for r, c in enumerate(C, 1):
if p * q * r > k:
break
ret.append(a + b + c)
ret.sort(reverse=True)
print(*ret[:k], sep='\n')
main()
# O(Klog^3K)
# https://img.atcoder.jp/abc123/editorial.pdf
# Enumerateのindex間違えていた
|
p03078
|
x,y,z,k=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
c=[int(i) for i in input().split()]
a.sort()
a.reverse()
b.sort()
b.reverse()
c.sort()
c.reverse()
a2=a[:k]
b2=[]
for i in a2:
for j in b[:k]:
b2.append(i+j)
b2.sort()
b2.reverse()
b2=b2[:k]
c2=[]
for i in b2:
for j in c[:k]:
c2.append(i+j)
c2.sort()
c2.reverse()
c2=c2[:k]
for i in c2:
print(i)
|
xx, yy, zz, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
a.sort(reverse=1)
b.sort(reverse=1)
c.sort(reverse=1)
ans = []
for x in range(min(xx, k)):
for y in range(min(yy, k // (x + 1))):
for z in range(min(zz, k // ((x + 1) * (y + 1)))):
ans.append(a[x] + b[y] + c[z])
ans.sort(reverse=1)
for i in range(k):
print((ans[i]))
|
p03078
|
import itertools
x,y,z,k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
del a[min(k,x):]
del b[min(k,y):]
del c[min(k,z):]
ab = [i + j for (i, j) in list(itertools.product(a, b))]
ab.sort(reverse=True)
del ab[min(k,x*y):]
abc = [ij + h for (ij, h) in list(itertools.product(ab, c))]
abc.sort(reverse=True)
for g in range(k):
print((abc[g]))
|
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
li=[]
for i in a:
for j in b:
li.append(i+j)
li.sort(reverse=True)
ansli=[]
for i in c:
for j in range(min(k,len(li))):
ansli.append(i+li[j])
ansli.sort(reverse=True)
for i in range(k):
print((ansli[i]))
|
p03078
|
import itertools
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
p = itertools.product(A, B, C)
data = [i + j + k for i, j, k in p]
data.sort(reverse=True)
for i in range(K):
print((data[i]))
if __name__ == '__main__':
main()
|
import itertools
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
p = itertools.product(A, B)
data = [i + j for i, j in p]
data.sort(reverse=True)
data = data[:min(len(data), K)]
p = itertools.product(data, C)
data = [i + j for i, j in p]
data.sort(reverse=True)
# data = data[:K]
for i in range(K):
print((data[i]))
if __name__ == '__main__':
main()
|
p03078
|
import itertools
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
p = itertools.product(A, B)
data = [i + j for i, j in p]
data.sort(reverse=True)
data = data[:min(len(data), K)]
p = itertools.product(data, C)
data = [i + j for i, j in p]
data.sort(reverse=True)
# data = data[:K]
for i in range(K):
print((data[i]))
if __name__ == '__main__':
main()
|
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
data = []
for i in range(X):
for j in range(Y):
if i * j > K:
break
for k in range(Z):
if i * j * k > K:
break
data.append(A[i] + B[j] + C[k])
data.sort(reverse=True)
for i in range(K):
print((data[i]))
if __name__ == '__main__':
main()
|
p03078
|
# -*- coding: utf-8 -*-
import itertools
import sys
import math
from functools import lru_cache
# 1整数
# n = int(input())
# 空白区切り2変数
from queue import Queue
from operator import mul
from functools import reduce
from queue import Queue
from operator import mul
from functools import reduce
from functools import lru_cache
input = sys.stdin.readline
# N個整数
x, y, z, kk = list(map(int, input().split()))
# 1整数
# n = int(input())
# 空白区切りリスト整数
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ll = [0] * 10000000
count = 0
for i in range(len(a)):
for j in range(len(b)):
if i * j > kk:
break
for k in range(len(c)):
if i * j * k > kk:
break
ll[count] = a[i] + b[j] + c[k]
count += 1
ll.sort(reverse=True)
for i in range(kk):
print((ll[i]))
# 空白区切り文字列
# t, d = input().split()
|
# -*- coding: utf-8 -*-
import itertools
import sys
import math
from functools import lru_cache
# 1整数
# n = int(input())
# 空白区切り2変数
from queue import Queue
from operator import mul
from functools import reduce
from queue import Queue
from operator import mul
from functools import reduce
from functools import lru_cache
input = sys.stdin.readline
# N個整数
x, y, z, kk = list(map(int, input().split()))
# 1整数
# n = int(input())
# 空白区切りリスト整数
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ll = []
count = 0
for i in range(len(a)):
for j in range(len(b)):
if i * j > kk:
break
for k in range(len(c)):
if i * j * k > kk:
break
ll.append(a[i] + b[j] + c[k])
ll.sort(reverse=True)
for i in range(kk):
print((ll[i]))
# 空白区切り文字列
# t, d = input().split()
|
p03078
|
# -*- coding: utf-8 -*-
import itertools
import sys
import math
from functools import lru_cache
# 1整数
# n = int(input())
# 空白区切り2変数
from queue import Queue
from operator import mul
from functools import reduce
from queue import Queue
from operator import mul
from functools import reduce
from functools import lru_cache
input = sys.stdin.readline
# N個整数
x, y, z, k = list(map(int, input().split()))
# 1整数
# n = int(input())
# 空白区切りリスト整数
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
ll = [0] * 1000001
count = 0
for i in a:
for j in b:
ll[count] = i + j
count += 1
ll.sort(reverse=True)
ll = ll[0:3000]
c.sort(reverse=True)
lll = [0] * 3000001
count = 0
for i in ll:
for j in c:
lll[count] = i + j
count += 1
lll.sort(reverse=True)
for i in range(k):
print((lll[i]))
# 空白区切り文字列
# t, d = input().split()
|
# -*- coding: utf-8 -*-
import itertools
import sys
import math
from functools import lru_cache
# 1整数
# n = int(input())
# 空白区切り2変数
from queue import Queue
from operator import mul
from functools import reduce
from queue import Queue
from operator import mul
from functools import reduce
from functools import lru_cache
input = sys.stdin.readline
# N個整数
x, y, z, kk = list(map(int, input().split()))
# 1整数
# n = int(input())
# 空白区切りリスト整数
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ll = []
count = 0
for i in range(len(a)):
for j in range(len(b)):
if i * j > kk:
break
for k in range(len(c)):
if i * j * k > kk:
break
ll.append(a[i] + b[j] + c[k])
ll.sort(reverse=True)
for i in range(kk):
print((ll[i]))
# 空白区切り文字列
# t, d = input().split()
|
p03078
|
# -*- coding: utf-8 -*-
import sys
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 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
X,Y,Z,K=MAP()
A=LIST()
B=LIST()
C=LIST()
AB=[]
for i in range(X):
for j in range(Y):
AB.append(A[i]+B[j])
AB.sort(reverse=True)
AB=AB[:3000]
ABC=[]
for i in range(len(AB)):
for j in range(Z):
ABC.append(AB[i]+C[j])
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
# -*- coding: utf-8 -*-
import sys
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 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
X,Y,Z,K=MAP()
A=sorted(LIST(), reverse=True)
B=sorted(LIST(), reverse=True)
C=sorted(LIST(), reverse=True)
ABC=[]
for i in range(X):
for j in range(Y):
if (i+1)*(j+1)>K:
break
for k in range(Z):
if (i+1)*(j+1)*(k+1)>K:
break
ABC.append(A[i]+B[j]+C[k])
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
x, y, z, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
c = tuple(map(int, input().split()))
ab = [i + j for i in a for j in b]
ab.sort(reverse=True)
abc = [i + j for i in ab[:k] for j in c]
abc.sort(reverse=True)
print(("\n".join(map(str, abc[:k]))))
|
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ans = []
for i in range(x):
for j in range(y):
for m in range(z):
if (i+1) * (j+1) * (m+1) > k:
break
ans.append(a[i] + b[j] + c[m])
ans.sort(reverse=True)
for i in ans[:k]:
print(i)
|
p03078
|
from heapq import heappop, heappush
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = []
heappush(h, (-A[0]-B[0]-C[0], 0, 0, 0))
used = set()
result = []
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X-1 and (i+1, j, k) not in used:
heappush(h, (-A[i+1]-B[j]-C[k], i+1, j, k))
used.add((i+1, j, k))
if j < Y-1 and (i, j+1, k) not in used:
heappush(h, (-A[i]-B[j+1]-C[k], i, j+1, k))
used.add((i, j+1, k))
if k < Z-1 and (i, j, k+1) not in used:
heappush(h, (-A[i]-B[j]-C[k+1], i, j, k+1))
used.add((i, j, k+1))
for v in result:
print(v)
|
from heapq import heappop, heappush
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
used = set()
h = []
heappush(h, (-A[0]-B[0]-C[0], 0, 0, 0))
result = []
used.add((0, 0, 0))
for _ in range(K):
sum, i, j, k = heappop(h)
result.append(-sum)
if i < X-1 and (i+1, j, k) not in used:
heappush(h, (-A[i+1]-B[j]-C[k], i+1, j, k))
used.add((i+1, j, k))
if j < Y-1 and (i, j+1, k) not in used:
heappush(h, (-A[i]-B[j+1]-C[k], i, j+1, k))
used.add((i, j+1, k))
if k < Z-1 and (i, j, k+1) not in used:
heappush(h, (-A[i]-B[j]-C[k+1], i, j, k+1))
used.add((i, j, k+1))
for v in result:
print(v)
|
p03078
|
# coding: utf-8
import sys
from bisect import bisect_left, bisect_right
import itertools
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 二分探索, 大きい方から１つずつheapに入れる、XとYは全探索
# AとBは全探索
X, Y, Z, K = lr()
A = lr(); A.sort()
B = lr(); B.sort()
C = lr(); C.sort()
D = []
for a, b in itertools.product(A, B):
D.append(a+b)
D.sort()
def check(x):
length = len(D)
count = 0
for y in C:
i = bisect_left(D, x-y)
count += length - i
return count >= K
ok = 0; ng = 10 ** 11
while abs(ng-ok) > 1:
mid = (ok+ng) // 2
if check(mid):
ok = mid
else:
ng = mid
# ok以上の値
answer = []
for y in C:
index = bisect_left(D, ok-y)
for i in range(index, len(D)):
heappush(answer, -(D[i]+y))
for i in range(K):
print((-heappop(answer)))
# 02
|
# coding: utf-8
import sys
from bisect import bisect_left, bisect_right
import itertools
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# AとBは全探索、その後二分探索
X, Y, Z, K = lr()
A = lr(); A.sort()
B = lr(); B.sort()
C = lr(); C.sort()
D = []
for a, b in itertools.product(A, B):
D.append(a+b)
D.sort()
if len(D) > K:
D = D[-K:]
def check(x):
length = len(D)
count = 0
for y in C:
i = bisect_left(D, x-y)
count += length - i
return count >= K
ok = 0; ng = 10 ** 11
while abs(ng-ok) > 1:
mid = (ok+ng) // 2
if check(mid):
ok = mid
else:
ng = mid
# ok以上の値
answer = []
for y in C:
index = bisect_left(D, ok-y)
for i in range(index, len(D)):
heappush(answer, -(D[i]+y))
for i in range(K):
print((-heappop(answer)))
# 02
|
p03078
|
# coding: utf-8
import sys
from bisect import bisect_left, bisect_right
import itertools
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# AとBは全探索、その後二分探索
X, Y, Z, K = lr()
A = lr(); A.sort()
B = lr(); B.sort()
C = lr(); C.sort()
D = []
for a, b in itertools.product(A, B):
D.append(a+b)
D.sort()
if len(D) > K:
D = D[-K:]
def check(x):
length = len(D)
count = 0
for y in C:
i = bisect_left(D, x-y)
count += length - i
return count >= K
ok = 0; ng = 10 ** 11
while abs(ng-ok) > 1:
mid = (ok+ng) // 2
if check(mid):
ok = mid
else:
ng = mid
# ok以上の値
answer = []
for y in C:
index = bisect_left(D, ok-y)
for i in range(index, len(D)):
heappush(answer, -(D[i]+y))
for i in range(K):
print((-heappop(answer)))
# 02
|
# coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 虫の目、一個ずつheapへ
X, Y, Z, K = lr()
A = lr(); A.sort(reverse=True)
B = lr(); B.sort(reverse=True)
C = lr(); C.sort(reverse=True)
ma = A[0] + B[0] + C[0]
heap = [(-ma, (0, 0, 0))]
used = set()
for _ in range(K):
result, place = heappop(heap)
print((-result))
i, j, k = place
p = (i+1, j, k)
if i + 1 < len(A) and p not in used:
val = A[i+1] + B[j] + C[k]
used.add(p)
heappush(heap, (-val, p))
p = (i, j+1, k)
if j + 1 < len(B) and p not in used:
val = A[i] + B[j+1] + C[k]
used.add(p)
heappush(heap, (-val, p))
p = (i, j, k+1)
if k + 1 < len(C) and p not in used:
val = A[i] + B[j] + C[k+1]
used.add(p)
heappush(heap, (-val, p))
# 26
|
p03078
|
from itertools import product
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
ab = [ai + bi for (ai, bi) in product(a, b)]
ab.sort(reverse=True)
abc = [abi + ci for (abi, ci) in product(ab[: min(k, x * y * z)], c)]
abc.sort(reverse=True)
for abci in abc[: min(k, x * y * z)]:
print(abci)
|
from itertools import product
x, y, z, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
b = sorted(list(map(int, input().split())), reverse=True)
c = sorted(list(map(int, input().split())), reverse=True)
ab = [ai + bi for (ai, bi) in product(a[:k], b[:k])]
ab.sort(reverse=True)
abc = [abi + ci for (abi, ci) in product(ab[: min(k, x * y * z)], c[:k])]
abc.sort(reverse=True)
for abci in abc[: min(k, x * y * z)]:
print(abci)
|
p03078
|
import heapq
x, y, z, k = list(map(int,input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
hq = [[-a[0]-b[0]-c[0], 0, 0, 0]]
heapq.heapify(hq)
visited = [[[0] * z for yy in range(y)] for xx in range(x)]
for i in range(k):
ii, ia, ib, ic = heapq.heappop(hq)
print((-ii))
na = min(ia+1, x-1)
nb = min(ib+1, y-1)
nc = min(ic+1, z-1)
if visited[na][ib][ic] == 0:
heapq.heappush(hq, [-a[na] -b[ib] -c[ic], na, ib, ic])
visited[na][ib][ic] = 1
if visited[ia][nb][ic] == 0:
heapq.heappush(hq, [-a[ia] -b[nb] -c[ic], ia, nb, ic])
visited[ia][nb][ic] = 1
if visited[ia][ib][nc] == 0:
heapq.heappush(hq, [-a[ia] -b[ib] -c[nc], ia, ib, nc])
visited[ia][ib][nc] = 1
|
import heapq
x, y, z, k = list(map(int,input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
hq = [[-a[0]-b[0]-c[0], 0, 0, 0]]
heapq.heapify(hq)
visited = {(0,0,0)}
for i in range(k):
ii, ia, ib, ic = heapq.heappop(hq)
print((-ii))
na = min(ia+1, x-1)
nb = min(ib+1, y-1)
nc = min(ic+1, z-1)
if not (na, ib, ic) in visited:
heapq.heappush(hq, [-a[na] -b[ib] -c[ic], na, ib, ic])
visited.add((na, ib, ic))
if not (ia, nb, ic) in visited:
heapq.heappush(hq, [-a[ia] -b[nb] -c[ic], ia, nb, ic])
visited.add((ia, nb, ic))
if not (ia, ib, nc) in visited:
heapq.heappush(hq, [-a[ia] -b[ib] -c[nc], ia, ib, nc])
visited.add((ia, ib, nc))
|
p03078
|
import heapq
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sorted(A, reverse=True)
b = sorted(B, reverse=True)
c = sorted(C, reverse=True)
added = [(0, 0, 0)]
cakes = [(-(a[0] + b[0] + c[0]), 0, 0, 0)]
for k in range(K):
v = heapq.heappop(cakes)
print((-v[0]))
va, vb, vc = v[1:]
if va < X - 1 and (va + 1, vb, vc) not in added:
heapq.heappush(cakes, (-(a[va + 1] + b[vb] + c[vc]), va + 1, vb, vc))
added += [(va + 1, vb, vc)]
if vb < Y - 1 and (va, vb + 1, vc) not in added:
heapq.heappush(cakes, (-(a[va] + b[vb + 1] + c[vc]), va, vb + 1, vc))
added += [(va, vb + 1, vc)]
if vc < Z - 1 and (va, vb, vc + 1) not in added:
heapq.heappush(cakes, (-(a[va] + b[vb] + c[vc + 1]), va, vb, vc + 1))
added += [(va, vb, vc + 1)]
|
# データ構造：ヒープ
import heapq
class heapque:
def __init__(self, *args):
self.que = []
for arg in args:
self.push(arg)
def push(self, v):
heapq.heappush(self.que, v)
def pop(self):
return heapq.heappop(self.que)
# 定数
INF = float("inf")
MOD = int(1e9 + 7)
# エントリーポイント
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
a = sorted(A, reverse=True)
b = sorted(B, reverse=True)
c = sorted(C, reverse=True)
heap = heapque((-(a[0] + b[0] + c[0]), (0, 0, 0)))
used = {(0, 0, 0)}
for _ in range(K):
cur = heap.pop()
print((-cur[0]))
ai, bi, ci = cur[1]
ns = ((min(ai + 1, X - 1), bi, ci), (ai, min(bi + 1, Y - 1), ci), (ai, bi, min(ci + 1, Z - 1)))
for n in ns:
if n in used: continue
heap.push((-(a[n[0]] + b[n[1]] + c[n[2]]), n))
used |= {n}
main()
|
p03078
|
from bisect import bisect_left as bi
x,y,z,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))[::-1]
b=sorted(list(map(int,input().split())))[::-1]
c=sorted(list(map(int,input().split())))[::-1]
for i in sorted([j+i for j in c for i in sorted([i+j for i in a for j in b])[::-1][:k]])[::-1][:k]:
print(i)
|
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort(reverse=True)
b=list(map(int,input().split()))
b.sort(reverse=True)
c=list(map(int,input().split()))
c.sort(reverse=True)
d=[i+j for i in a for j in b]
d.sort(reverse=True)
e=[i+j for i in c for j in d[:k]]
e.sort(reverse=True)
for i in range(k):
print((e[i]))
|
p03078
|
import math
x,y,z,k = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
Ai= sorted(A, reverse=True)
Bi= sorted(B, reverse=True)
Ci= sorted(C, reverse=True)
def su(a,b,c):
return(Ai[a]+Bi[b]+Ci[c])
a=0
b=0
c=0
pq=[[su(a,b,c),a,b,c]]
ck=[[su(a,b,c),a,b,c]]
dl=0
for i in range(k):
dl=pq.index(max(pq))
res=pq.pop(dl)
print((res[0]))
#print(pq)
a=res[1]
b=res[2]
c=res[3]
if a+1<=x-1 and (not [su(a+1,b,c),a+1,b,c] in ck):
pq.append([su(a+1,b,c),a+1,b,c])
ck.append([su(a+1,b,c),a+1,b,c])
if b+1<=y-1 and (not [su(a,b+1,c),a,b+1,c] in ck):
pq.append([su(a,b+1,c),a,b+1,c])
ck.append([su(a,b+1,c),a,b+1,c])
if c+1<=z-1 and (not [su(a,b,c+1),a,b,c+1] in ck):
pq.append([su(a,b,c+1),a,b,c+1])
ck.append([su(a,b,c+1),a,b,c+1])
|
import math
x,y,z,k = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
Ai= sorted(A, reverse=True)
Bi= sorted(B, reverse=True)
Ci= sorted(C, reverse=True)
def su(a,b,c):
return(Ai[a]+Bi[b]+Ci[c])
a=0
b=0
c=0
pq=[[su(a,b,c),a,b,c]]
ck=[a,b,c]
dl=0
for i in range(k):
dl=pq.index(max(pq))
res=pq.pop(dl)
print((res[0]))
a=res[1]
b=res[2]
c=res[3]
if a+1<=x-1 and (not [a+1,b,c] in ck):
pq.append([su(a+1,b,c),a+1,b,c])
ck.append([a+1,b,c])
if b+1<=y-1 and (not [a,b+1,c] in ck):
pq.append([su(a,b+1,c),a,b+1,c])
ck.append([a,b+1,c])
if c+1<=z-1 and (not [a,b,c+1] in ck):
pq.append([su(a,b,c+1),a,b,c+1])
ck.append([a,b,c+1])
|
p03078
|
import itertools
x,y,z,k=(int(i) for i in input().split())
#print(x,y,z,k)
a=list(int(i) for i in input().split())
#a.sort(reverse=True)
b=list(int(i) for i in input().split())
#b.sort(reverse=True)
c=list(int(i) for i in input().split())
#c.sort(reverse=True)
#print(a,b,c)
#a=[int(i) for i in range(1000,-1,-1)]
#b=[int(i) for i in range(1000,-1,-1)]
#c=[int(i) for i in range(1000,-1,-1)]
x=list(itertools.product(a,b))
for i in range(len(x)):
x[i]=x[i][0]+x[i][1]
x.sort(reverse=True)
y=[]
length=min(len(x),1600)
for i in range(length):
y+=[x[i]]
#print(len(y))
y=list(itertools.product(y,c))
#print(y)
for i in range(len(y)):
y[i]=y[i][0]+y[i][1]
y.sort(reverse=True)
for i in range(k):
print((y[i]))
|
#import itertools
x,y,z,k=(int(i) for i in input().split())
#print(x,y,z,k)
a=list(int(i) for i in input().split())
a.sort(reverse=True)
b=list(int(i) for i in input().split())
b.sort(reverse=True)
c=list(int(i) for i in input().split())
c.sort(reverse=True)
#print(a,b,c)
#k=3000
#a=[int(i) for i in range(1000)]
#b=[int(i) for i in range(1000)]
#c=[int(i) for i in range(1000)]
x=[]
for h in range(len(a)):
for i in range(len(b)):
if (h+1)*(i+1) <=k:
for j in range(len(c)):
if (h+1)*(i+1)*(j+1) <=k:
x.append(a[h]+b[i]+c[j])
x.sort(reverse=True)
for i in range(k):
print((x[i]))
|
p03078
|
import heapq
import itertools
x,y,z,k=(int(i) for i in input().split())
#print(x,y,z,k)
a=list((-1)*int(i) for i in input().split())
#a.sort(reverse=True)
b=list((-1)*int(i) for i in input().split())
#b.sort(reverse=True)
c=list((-1)*int(i) for i in input().split())
#c.sort(reverse=True)
#print(a,b,c)
mylist=list(itertools.product(a,b,c))
#print(mylist)
mylist=[sum(mylist[i]) for i in range(len(mylist))]
#print(mylist)
def heapsort(iterable):
h = []
for value in iterable:
heapq.heappush(h, value)
return [heapq.heappop(h) for i in range(k)]
# return [heapq.heappop(h) for i in range(len(h))]
#heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
mylist1=heapsort(mylist)
for i in range(k):
print(((-1)*mylist1[i]))
|
#from collections import deque
#import copy
x,y,z,ansk=(int(i) for i in input().split())
#print(x,y,z,k)
a=list(int(i) for i in input().split())
a.sort(reverse=True)
b=list(int(i) for i in input().split())
b.sort(reverse=True)
c=list(int(i) for i in input().split())
c.sort(reverse=True)
#print(a,b,c)
mylist=[0 for i in range(x*y)]
k=0
for i in range(x):
for j in range(y):
mylist[k]=a[i]+b[j]
k+=1
mylist.sort(reverse=True)
#print(mylist)
k=0
mylist1=[0 for i in range(x*y*z)]
for i in range(x*y):
for j in range(z):
mylist1[k]=mylist[i]+c[j]
k+=1
mylist1.sort(reverse=True)
for i in range(ansk):
print((mylist1[i]))
|
p03078
|
#from collections import deque
#import copy
x,y,z,ansk=(int(i) for i in input().split())
#print(x,y,z,k)
a=list(int(i) for i in input().split())
a.sort(reverse=True)
b=list(int(i) for i in input().split())
b.sort(reverse=True)
c=list(int(i) for i in input().split())
c.sort(reverse=True)
#print(a,b,c)
l=0
mylist=[0 for i in range(x*y*z)]
for i in range(x):
for j in range(y):
if (i+1)*(j+1) <= ansk:
for k in range(z):
if (i+1)*(j+1)*(k+1) <= ansk:
mylist[l]=a[i]+b[j]+c[k]
l+=1
mylist.sort(reverse=True)
#print(mylist)
for i in range(ansk):
print((mylist[i]))
|
x,y,z,k=(int(i) for i in input().split())
#print(x,y,z,k)
a=list(int(i) for i in input().split())
a.sort(reverse=True)
b=list(int(i) for i in input().split())
b.sort(reverse=True)
c=list(int(i) for i in input().split())
c.sort(reverse=True)
#print(a,b,c)
#k=3000
#a=[int(i) for i in range(1000)]
#b=[int(i) for i in range(1000)]
#c=[int(i) for i in range(1000)]
x=[]
for h in range(len(a)):
for i in range(len(b)):
if (h+1)*(i+1) <=k:
for j in range(len(c)):
if (h+1)*(i+1)*(j+1) <=k:
x.append(a[h]+b[i]+c[j])
x.sort(reverse=True)
for i in range(k):
print((x[i]))
|
p03078
|
x,y,z,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
a.sort(reverse = True)
b.sort(reverse = True)
c.sort(reverse = True)
h = []
for i in range(x):
for j in range(y):
for l in range(z):
if(i*j*l>k): break
h.append(a[i] + b[j] +c[l])
h.sort(reverse = True)
for i in range(k):
print((h[i]))
|
x,y,z,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
a.sort(reverse = True)
b.sort(reverse = True)
c.sort(reverse = True)
h = []
for i in range(x):
for j in range(y):
if(i*j>k): break
for l in range(z):
if(i*j*l>k): break
h.append(a[i] + b[j] +c[l])
h.sort(reverse = True)
for i in range(k):
print((h[i]))
|
p03078
|
X,Y,Z,K=list(map(int, input().split()))
A=list(map(int, input().split()))
B=list(map(int, input().split()))
C=list(map(int, input().split()))
L=[]
for a in A:
for b in B:
L.append(a+b)
L.sort(reverse=True)
L=L[:K]
L2=[]
for ab in L:
for c in C:
L2.append(ab+c)
L2.sort(reverse=True)
for i in range(K):
print(L2[i])
|
X,Y,Z,K=list(map(int, input().split()))
A=list(map(int, input().split()))
B=list(map(int, input().split()))
C=list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
L=[]
for ia, a in enumerate(A):
for ib, b in enumerate(B):
for ic, c in enumerate(C):
if (ia+1)*(ib+1)*(ic+1)<=K:
L.append(a+b+c)
else:
break
L.sort(reverse=True)
for i in range(K):
print(L[i])
|
p03078
|
def main():
x,y,z,k = list(map(int,input().split()))
lia = sorted(list(map(int,input().split())))
lib = sorted(list(map(int,input().split())))
lic = sorted(list(map(int,input().split())))
li2 = sorted(list(a+b for a in lia for b in lib),reverse = True)[:k]
li3 = sorted(list(ab + c for ab in li2 for c in lic),reverse = True)
for i in range(k):
print((li3[i]))
main()
|
def main():
x,y,z,k = list(map(int,input().split()))
lia = sorted(list(map(int,input().split())))
lib = sorted(list(map(int,input().split())))
lic = sorted(list(map(int,input().split())))
li2 = sorted(list(a+b for a in lia for b in lib),reverse = True)[:k]
li3 = sorted(list(ab + c for ab in li2 for c in lic),reverse = True)[:k]
print(('\n'.join(map(str,li3))))
main()
|
p03078
|
x,y,z,k = list(map(int,input().split()))
lia = sorted(list(map(int,input().split())),reverse = True)
lib = sorted(list(map(int,input().split())),reverse = True)
lic = sorted(list(map(int,input().split())),reverse = True)
li = []
for s in range(x):
for t in range(y):
for u in range(z):
if s*t*u <= k:
li.append(lia[s]+lib[t]+lic[u])
ans = sorted(li,reverse = True)[:k]
print(('\n'.join(map(str,ans))))
|
x,y,z,k = list(map(int,input().split()))
lia = sorted(list(map(int,input().split())),reverse = True)
lib = sorted(list(map(int,input().split())),reverse = True)
lic = sorted(list(map(int,input().split())),reverse = True)
li = []
for s in range(x):
for t in range(y):
if s*t > k: break
for u in range(z):
if s*t*u <= k:
li.append(lia[s]+lib[t]+lic[u])
else: break
ans = sorted(li,reverse = True)[:k]
print(('\n'.join(map(str,ans))))
|
p03078
|
def cake(s1,s2,s3):
ans1 = sorted(i+j for i in s1 for j in s2)
ans2 = sorted(i+j for i in ans1 for j in s3)
return ans2
a,b,c,d = list(map(int, input().split()))
s1=list(map(int, input().split()))
s2=list(map(int, input().split()))
s3=list(map(int, input().split()))
z = sorted(cake(s1,s2,s3),reverse=True)
for i in range(0,d):
print((z[i]))
|
import sys
input = sys.stdin.readline
x, y, z, k = map(int, input().split())
a = sorted(int(i) for i in input().split())
b = sorted(int(i) for i in input().split())
c = sorted(int(i) for i in input().split())
#a.sort(reverse=True)
#b.sort(reverse=True)
#c.sort(reverse=True)
ab = sorted(i+j for i in a for j in b)[:-k-1:-1]
abc = sorted(i+j for i in ab for j in c)[:-k-1:-1]
print(*abc[:k], sep="\n")
|
p03078
|
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
ab = sorted(x+y for x in a for y in b)[:-k-1:-1]
abc = sorted(x+y for x in ab[:k] for y in c)[:-k-1:-1]
print(*abc, sep='\n')
|
x, y, z, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
b = sorted(map(int, input().split()))
c = sorted(map(int, input().split()))
ab = sorted(x+y for x in a for y in b)[:-k-1:-1]
abc = sorted(x+y for x in ab[:k] for y in c)[:-k-1:-1]
print(*abc, sep='\n')
|
p03078
|
x, y, z, k = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
c = [int(_) for _ in input().split()]
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i] + b[j])
ab = sorted(ab)[::-1][:k]
abc = []
for i in range(min(k, x*y)):
for j in range(z):
abc.append(ab[i] + c[j])
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
x, y, z, k = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
c = [int(_) for _ in input().split()]
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i] + b[j])
ab.sort(reverse=True)
abc = []
for i in range(min(k, x*y)):
for j in range(z):
abc.append(ab[i] + c[j])
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
p03078
|
x, y, z, k = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
c = [int(_) for _ in input().split()]
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i] + b[j])
ab.sort(reverse=True)
abc = []
for i in range(min(k, x*y)):
for j in range(z):
abc.append(ab[i] + c[j])
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
x, y, z, o = [int(_) for _ in input().split()]
a = sorted([int(_) for _ in input().split()])[::-1]
b = sorted([int(_) for _ in input().split()])[::-1]
c = sorted([int(_) for _ in input().split()])[::-1]
s = []
for i in range(x):
for j in range(y):
for k in range(z):
if (i+1)*(j+1)*(k+1) <= o:
s.append(a[i]+b[j]+c[k])
else:
break
for ans in sorted(s)[::-1][:o]:
print(ans)
|
p03078
|
x, y, z, o = [int(_) for _ in input().split()]
a = sorted([int(_) for _ in input().split()])[::-1]
b = sorted([int(_) for _ in input().split()])[::-1]
c = sorted([int(_) for _ in input().split()])[::-1]
def isBorder(p):
l = []
for i in range(x):
for j in range(y):
for k in range(z):
if a[i]+b[j]+c[k] < p : break
l.append(a[i]+b[j]+c[k])
return l if len(l) >= o else []
l, r = 0, a[0]+b[0]+c[0]
while True:
if r==l : break
p = (l+r)//2
q = isBorder(p)
if q == []:
r = p-1
else:
l = p+1
q.sort(reverse=True)
for i in range(o):
print((q[i]))
|
x, y, z, o = [int(_) for _ in input().split()]
a = sorted([int(_) for _ in input().split()])[::-1]
b = sorted([int(_) for _ in input().split()])[::-1]
c = sorted([int(_) for _ in input().split()])[::-1]
def isEnough(p):
cnt = 0
for i in range(x):
for j in range(y):
for k in range(z):
if a[i]+b[j]+c[k] < p : break
cnt += 1
if cnt >= o: return True
return False
ok, ng = 0, a[0]+b[0]+c[0]
while abs(ok-ng)>1:
m = (ok+ng)//2
if isEnough(m):
ok = m
else:
ng = m
l = []
for i in range(x):
for j in range(y):
for k in range(z):
if a[i]+b[j]+c[k] <= ok : break
l.append(a[i]+b[j]+c[k])
l.sort(reverse=True)
for i in range(o):
if len(l) > i:
print((l[i]))
else:
print(ok)
|
p03078
|
X,Y,Z,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
ans = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if ((i+1)*(j+1)*(k+1) <= K):
ans.append(A[i]+B[j]+C[k])
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
X,Y,Z,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
ans = []
for i in range(X):
for j in range(min(Y,K//(i+1)+1)):
for k in range(min(Z,K//((i+1)*(j+1))+1)):
ans.append(A[i]+B[j]+C[k])
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
p03078
|
x, y, z, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse = True)
b = sorted(list(map(int, input().split())), reverse = True)
c = sorted(list(map(int, input().split())), reverse = True)
list = []
for i in range(x):
for j in range(y):
list.append(a[i]+b[j])
list.sort(reverse = True)
list = list[:k]
list1 = []
for i in range(len(list)):
for j in range(z):
list1.append(list[i]+c[j])
list1.sort(reverse = True)
list1 = list1[:k]
for i in range(k):
print((list1[i]))
|
x, y, z, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse = True)
b = sorted(list(map(int, input().split())), reverse = True)
c = sorted(list(map(int, input().split())), reverse = True)
list = []
for aa in a:
for bb in b:
list.append(aa+bb)
list.sort(reverse = True)
list = list[:k]
list1 = []
for ab in list:
for cc in c:
list1.append(ab+cc)
list1.sort(reverse = True)
list1 = list1[:k]
for i in range(k):
print((list1[i]))
|
p03078
|
X, Y, Z, K = [int(_) for _ in input().split()]
As = [int(_) for _ in input().split()]
Bs = [int(_) for _ in input().split()]
Cs = [int(_) for _ in input().split()]
As.sort()
Bs.sort()
Cs.sort()
choice_stack = [(len(As) - 1, len(Bs) - 1, len(Cs) - 1)]
choice_stack_next = []
choice_log = set()
sums = []
j = 0
while True:
for Ai, Bi, Ci in choice_stack:
sums.append(As[Ai] + Bs[Bi] + Cs[Ci])
cA = (max(0, Ai - 1), Bi, Ci)
cB = (Ai, max(0, Bi - 1), Ci)
cC = (Ai, Bi, max(0, Ci - 1))
if not (cA in choice_log):
choice_stack_next.append(cA)
choice_log.add(cA)
if not (cB in choice_log):
choice_stack_next.append(cB)
choice_log.add(cB)
if not (cC in choice_log):
choice_stack_next.append(cC)
choice_log.add(cC)
sums.sort()
print((sums.pop()))
choice_stack = [_ for _ in choice_stack_next]
choice_stack_next.clear()
j += 1
if j >= K:
break
|
X, Y, Z, K = [int(_) for _ in input().split()]
As = [int(_) for _ in input().split()]
Bs = [int(_) for _ in input().split()]
Cs = [int(_) for _ in input().split()]
As.sort()
Bs.sort()
Cs.sort()
choice_stack = [(As[-1] + Bs[-1] + Cs[-1], len(As) - 1, len(Bs) - 1, len(Cs) - 1)]
choice_log = set()
j = 0
while True:
choice_stack.sort()
chosen_sum, Ai, Bi, Ci = choice_stack.pop()
print(chosen_sum)
step_A = (As[max(0, Ai - 1)] + Bs[Bi] + Cs[Ci], max(0, Ai - 1), Bi, Ci)
step_B = (As[Ai] + Bs[max(0, Bi - 1)] + Cs[Ci], Ai, max(0, Bi - 1), Ci)
step_C = (As[Ai] + Bs[Bi] + Cs[max(0, Ci - 1)], Ai, Bi, max(0, Ci - 1))
if not (step_A in choice_log):
choice_stack.append(step_A)
choice_log.add(step_A)
if not (step_B in choice_log):
choice_stack.append(step_B)
choice_log.add(step_B)
if not (step_C in choice_log):
choice_stack.append(step_C)
choice_log.add(step_C)
j += 1
if j >= K:
break
|
p03078
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
c = c[:k]
e = []
cnt = 0
for va in a:
for vb in b:
heapq.heappush(e, -(va+vb))
d = []
while len(e):
ve = -heapq.heappop(e)
for vc in c:
heapq.heappush(d, -(ve+vc))
for i in range(k):
print((-heapq.heappop(d)))
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
e = []
for va in a:
for vb in b:
e.append(va+vb)
e.sort(reverse=True)
e = e[:k]
d = []
for ve in e:
for vc in c:
heapq.heappush(d, -(ve+vc))
for i in range(k):
print((-heapq.heappop(d)))
|
p03078
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
e = []
for va in a:
for vb in b:
e.append(va+vb)
e.sort(reverse=True)
e = e[:k]
d = []
for ve in e:
for vc in c:
heapq.heappush(d, -(ve+vc))
for i in range(k):
print((-heapq.heappop(d)))
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
e = []
# AxB を取得
for va in a:
for vb in b:
heapq.heappush(e, -(va+vb))
# AxB は 大きい方から最大k個のみ使う
d = []
ite = min(k, len(e))
# AxB[k個] x C を取得
for i in range(ite):
ve = -heapq.heappop(e)
for vc in c:
heapq.heappush(d, -(ve+vc))
for i in range(k):
print((-heapq.heappop(d)))
|
p03078
|
#!/usr/bin/env python3.4
# -*- coding: utf-8 -*-
# abc123_d
import itertools
import math
# input
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
# A = range(1000)
# B = range(1000)
# C = range(1000)
# getans
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
arr = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if i*j*k > K:
break
arr.append(A[i]+B[j]+C[k])
#print(len(arr))
arr = sorted(arr, reverse=True)[:K]
# output
ans = '\n'.join(map(str, arr))
print(ans)
|
#!/usr/bin/env python3.4
# -*- coding: utf-8 -*-
# abc123_d
import itertools
import math
# input
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
# A = range(1000)
# B = range(1000)
# C = range(1000)
# getans
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
arr = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1) > K:
break
arr.append(A[i]+B[j]+C[k])
#print(len(arr))
arr.sort(reverse=True)
# output
ans = '\n'.join(map(str, arr[:K]))
print(ans)
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
AB = []
for i in range(X):
for j in range(Y):
AB.append(A[i] + B[j])
AB.sort(reverse=True)
ABC = []
for i in range(min(len(AB), K)):
for j in range(Z):
ABC.append(AB[i] + C[j])
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ABC = []
for i in range(X):
for j in range(Y):
if (i + 1) * (j + 1) > K:
break
for k in range(Z):
if (i + 1) * (j + 1) * (k + 1) > K:
break
ABC.append(A[i] + B[j] + C[k])
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
#conding utf-8
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
ab=[]
ans=[]
for i in range(len(a)):
for j in range(len(b)):
ab.append(a[i]+b[j])
ab.sort()
ab.reverse()
del ab[k:]
for i in range(len(ab)):
for j in range(len(c)):
ans.append(ab[i]+c[j])
ans.sort()
ans.reverse()
for i in range(k):
print((ans[i]))
|
#conding utf-8
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
ab=[]
ans=[]
for i in range(len(a)):
for j in range(len(b)):
ab.append(a[i]+b[j])
ab.sort()
ab.reverse()
del ab[k:]
c.sort()
c.reverse()
for i in range(len(ab)):
for j in range(len(c)):
ans.append(ab[i]+c[j])
ans.sort()
ans.reverse()
for i in range(k):
print((ans[i]))
|
p03078
|
#conding utf-8
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
ab=[]
ans=[]
for i in range(len(a)):
for j in range(len(b)):
ab.append(a[i]+b[j])
ab.sort()
ab.reverse()
del ab[k:]
c.sort()
c.reverse()
for i in range(len(ab)):
for j in range(len(c)):
ans.append(ab[i]+c[j])
ans.sort()
ans.reverse()
for i in range(k):
print((ans[i]))
|
#conding utf-8
x,y,z,K=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
a.sort()
b.sort()
c.sort()
a.reverse()
b.reverse()
c.reverse()
ans=[]
for i in range(len(a)):
for j in range(len(b)):
if (i+1)*(j+1)>K:
break
for k in range(len(c)):
if (i+1)*(j+1)*(k+1)>K:
break
ans.append(a[i]+b[j]+c[k])
ans.sort()
ans.reverse()
for i in range(K):
print((ans[i]))
|
p03078
|
X,Y,Z,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
import heapq
ans = []
heapq.heapify(ans)
for a in A:
for b in B:
for c in C:
heapq.heappush(ans,-(a+b+c))
for _ in range(K):
i = heapq.heappop(ans)
print((-i))
|
X,Y,Z,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
# A,B,Cのリストを降順にソート
A.sort(reverse =True)
B.sort(reverse =True)
C.sort(reverse =True)
# A,B,Cを上からp,q,r番目を選択した場合にp*q*rがKより大きい組み合わせがKより上位に来ることはない
# A,B,Cを上から参照していき。p*q*rがK以下の場合はリストにa+b+cを追加，K以上の場合はbreak
D = []
for p in range(1,X+1):
for q in range(1,Y+1):
for r in range(1,Z+1):
if p*q*r<=K:
D.append(A[p-1]+B[q-1]+C[r-1])
else:
break
D.sort(reverse=True)
for i in range(K):
print((D[i]))
|
p03078
|
x,y,z,k = list(map(int,input().split()))
al = list(map(int,input().split()))
bl = list(map(int,input().split()))
cl = list(map(int,input().split()))
al = sorted(al)
bl = sorted(bl)
cl = sorted(cl)
rank = []
for xx in range(x-1,-1,-1):
tmp = al[xx]+bl[-1]+cl[-1]
if len(rank) >= k:
if rank[-1] >= tmp:
break
for yy in range(y-1, -1, -1):
tmp = al[xx]+bl[yy]+cl[-1]
if len(rank) >= k:
if rank[-1] >= tmp:
break
for zz in range(z-1,-1,-1):
if len(rank) < k:
rank.append(al[xx]+bl[yy]+cl[zz])
rank = sorted(rank, reverse=True)
else:
tmp = al[xx]+bl[yy]+cl[zz]
if rank[-1] < tmp:
rank.pop()
rank.append(tmp)
rank = sorted(rank, reverse=True)
else:
break
for i in rank:
print(i)
|
x,y,z,k = list(map(int,input().split()))
al = list(map(int,input().split()))
bl = list(map(int,input().split()))
cl = list(map(int,input().split()))
al = sorted(al)
bl = sorted(bl)
cl = sorted(cl)
rank = []
flag = False
for xx in range(x-1,-1,-1):
tmp = al[xx]+bl[-1]+cl[-1]
if flag and rank[-1] >= tmp:
break
for yy in range(y-1, -1, -1):
tmp = al[xx]+bl[yy]+cl[-1]
if flag and rank[-1] >= tmp:
break
for zz in range(z-1,-1,-1):
if len(rank) < k:
rank.append(al[xx]+bl[yy]+cl[zz])
rank = sorted(rank, reverse=True)
else:
tmp = al[xx]+bl[yy]+cl[zz]
if rank[-1] < tmp:
flag = True
rank.pop()
rank.append(tmp)
rank = sorted(rank, reverse=True)
else:
break
for i in rank:
print(i)
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
sumsofAandB = sorted([a+b for a in A for b in B])
sumsofAll = sorted([ab+c for ab in sumsofAandB for c in C], reverse=True)
for i in range(K):
print((sumsofAll[i]))
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
sumsofAandB = sorted([a+b for a in A for b in B], reverse=True)[:K]
sumsofAll = sorted([ab+c for ab in sumsofAandB for c in C], reverse=True)
for i in range(K):
print((sumsofAll[i]))
|
p03078
|
# -*- coding:utf-8 -*-
def solve():
X, Y, Z, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
B = list(map(int, input().split(" ")))
C = list(map(int, input().split(" ")))
ans = []
for x in range(X):
for y in range(Y):
for z in range(Z):
ans.append(A[x]+B[y]+C[z])
ans.sort(reverse=True)
for i in range(0, K):
print((ans[i]))
if __name__ == "__main__":
solve()
|
# -*- coding:utf-8 -*-
def solve():
""" TLE """
X, Y, Z, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
B = list(map(int, input().split(" ")))
C = list(map(int, input().split(" ")))
ans = []
for x in range(X):
for y in range(Y):
for z in range(Z):
abc = A[x]+B[y]+C[z]
if len(ans) < K-1:
ans.append(abc)
continue
elif len(ans) == K-1:
ans.append(abc)
ans.sort(reverse=True)
continue
if abc > ans[-1]:
ans[-1] = abc
ans.sort(reverse=True)
continue
for i in range(0, K):
print((ans[i]))
if __name__ == "__main__":
solve()
|
p03078
|
# -*- coding:utf-8 -*-
def solve():
""" TLE """
X, Y, Z, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
B = list(map(int, input().split(" ")))
C = list(map(int, input().split(" ")))
ans = []
for x in range(X):
for y in range(Y):
ab = A[x] + B[y]
for z in range(Z):
abc = ab + C[z]
if len(ans) < K-1:
ans.append(abc)
continue
elif len(ans) == K-1:
ans.append(abc)
ans.sort(reverse=True)
continue
if abc > ans[-1]:
ans[-1] = abc
ans.sort(reverse=True)
continue
for i in range(0, K):
print((ans[i]))
if __name__ == "__main__":
solve()
|
# -*- coding:utf-8 -*-
def solve():
""" TLE """
X, Y, Z, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
B = list(map(int, input().split(" ")))
C = list(map(int, input().split(" ")))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
for x in range(X):
for y in range(Y):
ab = A[x] + B[y]
for z in range(Z):
if (x+1)*(y+1)*(z+1) > K:
break
ans.append(ab + C[z])
ans.sort(reverse=True)
for i in range(0, K):
print((ans[i]))
if __name__ == "__main__":
solve()
|
p03078
|
import sys
x, y, z, k = list(map(int, sys.stdin.readline().split()))
xlist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(x, k)]
ylist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(y, k)]
zlist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(z, k)]
anslist = [0]
for i in range(min(x, k)):
for j in range(min(y, k)):
for l in range(min(z, k)):
if (i+1)*(j+1)*(l+1) <= k:
anslist.append(xlist[i]+ylist[j]+zlist[l])
anslist = sorted(anslist, reverse=True)
for i in range(k):
print((anslist[i]))
|
import sys
x, y, z, k = list(map(int, sys.stdin.readline().split()))
xlist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(x, k)]
ylist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(y, k)]
zlist = sorted(list([int(i)
for i in sys.stdin.readline().split()]), reverse=True)[:min(z, k)]
anslist = [0]
for i in range(min(x, k)):
for j in range(min(y, k)):
for l in range(min(z, k)):
if (i+1)*(j+1)*(l+1) <= k:
anslist.append(xlist[i] + ylist[j] + zlist[l])
else:
break
anslist = sorted(anslist, reverse=True)
for i in range(k):
print((anslist[i]))
|
p03078
|
from bisect import bisect_left
from heapq import heappush, heappop
X, Y, Z, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
*C, = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
# x以上のものがK個あるならOK
def f(x):
cnt = 0
for i in A:
for j in B:
for k in C:
if i+j+k<x:break
cnt += 1
if cnt>=K:
return True
return False
def get_boarder():
l, r = 0, A[0]+B[0]+C[0]
while r-l>1:
m = (l+r)//2
if f(m):
l = m
else:
r = m
return l
s = []
for i in B:
for j in C:
s.append(i+j)
s.sort()
A.sort()
boarder = get_boarder()
q = []
for i in A:
if boarder-i<0:continue
pos = bisect_left(s, boarder-i)
for j in s[pos:]:
heappush(q, -(i+j))
for _ in range(K):
print((-heappop(q)))
|
from heapq import heappush, heappop
X, Y, Z, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
*C, = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
# x以上のものがK個あるならOK
def f(x):
cnt = 0
for i in A:
for j in B:
for k in C:
if i+j+k<x:break
cnt += 1
if cnt>=K:
return True
return False
def get_boarder():
l, r = 0, A[0]+B[0]+C[0]
while r-l>1:
m = (l+r)//2
if f(m):
l = m
else:
r = m
return l
boarder = get_boarder()
q = []
for i in A:
for j in B:
for k in C:
if i+j+k<boarder:break
heappush(q, -(i+j+k))
for _ in range(K):
print((-heappop(q)))
|
p03078
|
from heapq import heappop, heappush
from itertools import product
X, Y, Z, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
*C, = list(map(int, input().split()))
A.sort(reverse=True)
D = [i+j for j in C for i in B]
D.sort(reverse=True)
q = []
for i, j in product(A, D):
heappush(q, -(i+j))
for _ in range(K):
print((-heappop(q)))
|
from heapq import heappop, heappush
X, Y, Z, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
*C, = list(map(int, input().split()))
A.sort(reverse=True)
# Bi+Cjの和を求め、降順にソートしておく(Dkとします)
D = [i+j for j in C for i in B]
D.sort(reverse=True)
# Ai+Bj+Ckの大きい順からK個を構成する要素としては、Aiの大きい順からK個とDkの大きい順からK個しか登場しないので
q = []
for i in A[:K]:
for j in D[:K]:
heappush(q, -(i+j))
for _ in range(K):
print((-heappop(q)))
|
p03078
|
x,y,z,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
c=[int(x) for x in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
s=list()
for l in range(x):
for m in range(y):
for n in range(z):
if l*m*n>k:
break
s.append(a[l]+b[m]+c[n])
s.sort(reverse=True)
for i in range(k):
print((s[i]))
|
x,y,z,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
c=[int(x) for x in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
s=list()
for l in range(x):
if l>k:
break
for m in range(y):
if l*m>k:
break
for n in range(z):
if l*m*n>k:
break
s.append(a[l]+b[m]+c[n])
s.sort(reverse=True)
for i in range(k):
print((s[i]))
|
p03078
|
import sys,queue,math,copy,itertools,bisect,collections
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
X,Y,Z,K = LI()
A = LI()
B = LI()
C = LI()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = A[0] + B[0] + C[0]
l = 0
while h > l+1:
m = (h+l) // 2
num = 0
for a in A:
j = len(C) - 1
for i in B:
while i + C[j] < m - a:
j -= 1
if j < 0: break
else:
num += j + 1
continue
break
if num > K:
l = m
else:
h = m
ans = []
cnt = 0
for a in A:
j = len(C) - 1
last_cnt = cnt
for i in B:
while i + C[j] <= l - a:
j -= 1
if j < 0: break
else:
for k in range(j+1):
ans.append(a+i+C[k])
cnt += 1
continue
break
ans.sort(reverse=True)
for _ in range(K-len(ans)):
ans.append(l)
print (*ans[:K],sep='\n')
|
import sys,queue,math,copy,itertools,bisect,collections
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
X,Y,Z,K = LI()
A = LI()
B = LI()
C = LI()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
h = A[0] + B[0] + C[0]
l = 0
while h > l+1:
m = (h+l) // 2
num = 0
for a in A:
j = len(C) - 1
for i in B:
while i + C[j] < m - a:
j -= 1
if j < 0: break
else:
num += j + 1
continue
break
if num > K:
l = m
else:
h = m
ans = []
for a in A:
j = len(C) - 1
for i in B:
while i + C[j] <= l - a:
j -= 1
if j < 0: break
else:
for k in range(j+1):
ans.append(a+i+C[k])
continue
break
ans.sort(reverse=True)
for _ in range(K-len(ans)):
ans.append(l)
print(*ans[:K], sep='\n')
|
p03078
|
x, y, z, k = list(map(int, input().split()))
c_s = list(map(int, input().split()))
b_s = list(map(int, input().split()))
a_s = list(map(int, input().split()))
a_s.sort(reverse=True)
b_s.sort(reverse=True)
c_s.sort(reverse=True)
d = {}
abcs = [0]
j = -1
for a in a_s:
for b in b_s:
for c in c_s:
abc = a + b + c
if j >= k and abcs[k-1] >= abc:
break
if abcs[0] == 0:
abcs[0] = abc
else:
for i in reversed(list(range(len(abcs)))):
if abcs[i] >= abc:
abcs.insert(i+1, abc)
break
if j >= k:
abcs.pop(-1)
j += 1
for i in range(k):
print((abcs[i]))
|
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
ab = []
for ai in a:
for bi in b:
ab.append(ai + bi)
ab.sort(reverse = True)
abc = []
for abi in ab[:k]:
for ci in c:
abc.append(abi + ci)
abc.sort(reverse = True)
for abci in abc[:k]:
print(abci)
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
l = []
for i in a:
for j in b:
for k in c:
l.append(i + j + k)
l.sort(reverse = True)
for i in range(K):
print((l[i]))
|
X, Y, Z, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
l = []
for i in range(X):
for j in range(Y):
l.append(a[i] + b[j])
l.sort(reverse = True)
l = l[:K]
L = []
for i in range(len(l)):
for j in range(Z):
L.append(l[i] + c[j])
L.sort(reverse = True)
for i in range(K):
print((L[i]))
|
p03078
|
X, Y, Z, K = [int(i) for i in input().split()]
ABCList = [sorted([int(i) for i in input().split()], reverse=True) for _ in range(3)]
ABSum = sorted([i + j for i in ABCList[0] for j in ABCList[1]], reverse=True)[:K]
for ans in sorted([i + j for i in ABSum for j in ABCList[2]], reverse=True)[:K]:
print(ans)
|
X, Y, Z, K = [int(i) for i in input().split()]
ABCList = [sorted([int(i) for i in input().split()], reverse=True) for _ in range(3)]
ansList = []
for i, A in enumerate(ABCList[0]):
for j, B in enumerate(ABCList[1]):
for k, C in enumerate(ABCList[2]):
if (i + 1) * (j + 1) * (k + 1) <= K:
ansList.append(A + B + C)
else:
break
for ans in sorted(ansList, reverse=True)[:K]:
print(ans)
|
p03078
|
import bisect
X, Y, Z, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
nums = []
for a in A:
for b in B:
for c in C:
n = a + b + c
idx = bisect.bisect_right(nums, n)
if idx == 0 and len(nums) > K:
break
else:
nums.insert(idx, n)
if len(nums) > K:
nums.pop(0)
if a + b + C[0] < nums[0]:
break
if a + B[0] + C[0] < nums[0]:
break
for n in nums[::-1]:
print(n)
|
X, Y, Z, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
E = sorted([a+b for a in A for b in B], reverse=True)
E = E[:K]
nums = sorted([e+c for e in E for c in C], reverse=True)
for n in nums[:K]:
print(n)
|
p03078
|
X,Y,Z,K=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
K=min(K,3000)
AB=[a+b for a in A for b in B]
AB.sort(reverse=True)
ABC=[ab+c for ab in AB[:K] for c in C]
ABC.sort(reverse=True)
for k in range(K):
print((ABC[k]))
|
X,Y,Z,K=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
K=min(K,3000)
AB=[a+b for a in A for b in B]
AB.sort(reverse=True)
ABC=[ab+c for ab in AB[:K] for c in C[:K]]
ABC.sort(reverse=True)
for k in range(K):
print((ABC[k]))
|
p03078
|
x,y,z,k=list(map(int,input().split()))
a,b,c=[list(map(int,input().split())) for i in range(3)]
l=[i+j for i in a for j in b]
l.sort(reverse=True)
maxl=[i+j for i in l[:k] for j in c]
maxl.sort(reverse=True)
for a in maxl[:k]:
print(a)
|
x,y,z,k=list(map(int,input().split()))
a,b,c=[sorted(list(map(int,input().split())),reverse=True) for i in range(3)]
L=[]
for i in range(x):
for j in range(y):
if (i+1)*(j+1)>k:
break
for m in range(z):
if (i+1)*(j+1)*(m+1)>k:
break
else:
L.append(a[i]+b[j]+c[m])
for i in sorted(L,reverse=True)[:k]:
print(i)
|
p03078
|
import heapq
X,Y,Z,K = list(map(int,input().split()))
Alist = list( map(int, input().split()))
Blist = list(map(int, input().split()))
Clist = list( map(int, input().split()))
sum =[]
heapq.heapify(sum)
for i in range(0,X):
for j in range(0,Y):
for k in range(0,Z):
heapq.heappush(sum,(Alist[i]+Blist[j]+Clist[k])*(-1))
for i in range(0,K):
print((-1*heapq.heappop(sum)))
|
import heapq
X,Y,Z,K = list(map(int,input().split()))
Alist = list( map(int, input().split()))
Blist = list(map(int, input().split()))
Clist = list( map(int, input().split()))
Alist.sort(reverse=True)
Blist.sort(reverse=True)
Clist.sort(reverse=True)
sum =[]
heapq.heapify(sum)
arg_hash = {}
heapq.heappush(sum,((Alist[0]+Blist[0]+Clist[0])*(-1),(0,0,0)))
for i in range(0,K):
ans,(a,b,c) = heapq.heappop(sum)
print((-ans))
arg_a = a+1,b,c
arg_b = a,b+1,c
arg_c = a,b,c+1
if a < X-1 and arg_a not in arg_hash:
heapq.heappush(sum,((Alist[a+1]+Blist[b]+Clist[c])*(-1),arg_a))
arg_hash[arg_a]=1
if b < Y-1 and arg_b not in arg_hash:
heapq.heappush(sum,((Alist[a]+Blist[b+1]+Clist[c])*(-1),arg_b))
arg_hash[arg_b]=1
if c < Z - 1 and arg_c not in arg_hash:
heapq.heappush(sum, ((Alist[a] + Blist[b] + Clist[c+1]) * (-1), arg_c))
arg_hash[arg_c] = 1
|
p03078
|
from heapq import heappush, heappop
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
q = []
x = y = z = 0
heappush(q, (-(A[x] + B[y] + C[z]), (x, y, z)))
done = set((0, 0, 0))
ans = []
for _ in range(K):
val, (x, y, z) = heappop(q)
ans.append(-val)
for i, j, k in [(1, 0, 0), (0, 1, 0), (0, 0, 1)]:
nx = x + i; ny = y + j; nz = z + k
if nx < X and ny < Y and nz < Z and (nx, ny, nz) not in done:
heappush(q, (-(A[nx] + B[ny] + C[nz]), (nx, ny, nz)))
done.add((nx, ny, nz))
print(*ans, sep='\n')
|
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
for x in range(X):
for y in range(Y):
for z in range(Z):
if (x + 1) * (y + 1) * (z + 1) <= K:
ans.append(A[x] + B[y] + C[z])
else:
break
ans.sort(reverse=True)
print(*ans[:K], sep='\n')
|
p03078
|
# solution 2
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
L = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1) <= K:
L.append(A[i]+B[j]+C[k])
else:
break
L.sort(reverse=True)
for l in range(K):
print((L[l]))
|
# solution 2
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
L = []
for i in range(X):
for j in range(Y):
if (i+1)*(j+1) > K:
break
for k in range(Z):
if (i+1)*(j+1)*(k+1) > K:
break
else:
L.append(A[i] + B[j] + C[k])
L.sort(reverse=True)
for l in range(K):
print((L[l]))
|
p03078
|
# solution 3
import heapq
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
Q = []
s = []
heapq.heappush(Q, (-A[0]-B[0]-C[0], 0, 0, 0))
for n in range(K):
q, i, j, k = heapq.heappop(Q)
print((-q))
if i < X-1 and [i+1, j, k] not in s:
heapq.heappush(Q, (- A[i+1] - B[j] - C[k], i+1, j, k))
s.append([i + 1, j, k])
if j < Y-1 and [i, j+1, k] not in s:
heapq.heappush(Q, (- A[i] - B[j+1] - C[k], i, j+1, k))
s.append([i, j + 1, k])
if k < Z-1 and [i, j, k+1] not in s:
heapq.heappush(Q, (- A[i] - B[j] - C[k+1], i, j, k+1))
s.append([i, j, k + 1])
|
# solution 3
import heapq
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
Q = []
s = set()
heapq.heappush(Q, (-A[0]-B[0]-C[0], 0, 0, 0))
for n in range(K):
q, i, j, k = heapq.heappop(Q)
print((-q))
if i < X-1 and (i+1, j, k) not in s:
heapq.heappush(Q, (- A[i+1] - B[j] - C[k], i+1, j, k))
s.add((i + 1, j, k))
if j < Y-1 and (i, j+1, k) not in s:
heapq.heappush(Q, (- A[i] - B[j+1] - C[k], i, j+1, k))
s.add((i, j + 1, k))
if k < Z-1 and (i, j, k+1) not in s:
heapq.heappush(Q, (- A[i] - B[j] - C[k+1], i, j, k+1))
s.add((i, j, k + 1))
|
p03078
|
x, y, z, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
b = sorted(list(map(int, input().split())), reverse=True)
c = sorted(list(map(int, input().split())), reverse=True)
d = []
for i in range(len(a)):
for j in range(len(b)):
d.append(a[i]+b[j])
tmp = sorted(d, reverse=True)
if len(tmp) < k:
use_tmp = tmp
else:
use_tmp = tmp[0:k]
ans = []
for i in range(len(use_tmp)):
for j in range(len(c)):
ans.append(use_tmp[i]+c[j])
final_ans = sorted(ans, reverse=True)
for i in range(k):
print((final_ans[i]))
|
x, y, z, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
b = sorted(list(map(int, input().split())), reverse=True)
c = sorted(list(map(int, input().split())), reverse=True)
sumAB = sorted([ai + bi for ai in a for bi in b],reverse=True)[:k]
final_ans = sorted([ci + abi for ci in c for abi in sumAB],reverse = True)[:k]
for i in range(k):
print((final_ans[i]))
|
p03078
|
from heapq import heapify, heappush, heappop, heapreplace
from collections import deque
import sys
input = sys.stdin.readline
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
D = deque([(0,0,0)])
F = set()
H = [0]
heapify(H)
k = 1
while D:
p = D.popleft()
if p in F:
continue
F.add(p)
x, y, z = p
d = A[x] + B[y] + C[z]
if k < K:
heappush(H, d)
k += 1
elif H[0] > d:
continue
else:
heapreplace(H, d)
if x < X - 1: D.append((x + 1, y, z))
if y < Y - 1: D.append((x, y + 1, z))
if z < Z - 1: D.append((x, y, z + 1))
print(*sorted(H, reverse=True), sep="\n")
|
from heapq import heapify, heappush, heappop, heapreplace
import sys
input = sys.stdin.readline
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
D = [(-(A[0] + B[0] + C[0]), 0, 0, 0)]
heapify(D)
F = set()
for _ in range(K):
p = heappop(D)
d, x, y, z = p
print((-d))
if x < X - 1:
p = (-(A[x + 1] + B[y] + C[z]), x + 1, y, z)
if p not in F:
heappush(D, p)
F.add(p)
if y < Y - 1:
p = (-(A[x] + B[y + 1] + C[z]), x, y + 1, z)
if p not in F:
heappush(D, p)
F.add(p)
if z < Z - 1:
p = (-(A[x] + B[y] + C[z + 1]), x, y, z + 1)
if p not in F:
heappush(D, p)
F.add(p)
|
p03078
|
X,Y,Z,K=list(map(int,input().split()))
A=[int(x) for x in input().split()]
B=[int(x) for x in input().split()]
C=[int(x) for x in input().split()]
A.sort(reverse =True)
B.sort(reverse =True)
C.sort(reverse =True)
answer=[]
for p in range(min(X,K)):
for q in range(min(Y,K)):
for r in range(min(Z,K)):
answer +=[A[p]+B[q]+C[r]]
answer.sort()
for i in range(K):
print((answer[-i-1]))
|
X,Y,Z,K=list(map(int,input().split()))
A=[int(x) for x in input().split()]
B=[int(x) for x in input().split()]
C=[int(x) for x in input().split()]
A.sort(reverse =True)
B.sort(reverse =True)
C.sort(reverse =True)
answer=[]
for p in range(min(X,K)):
for q in range(min(Y,K)):
if p*q>K:
break
for r in range(min(Z,K)):
if p*q*r>K:
break
answer +=[A[p]+B[q]+C[r]]
answer.sort()
for i in range(K):
print((answer[-i-1]))
|
p03078
|
#!/usr/bin/env python
x, y, z, k = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
D = []
E = []
for b in B:
for c in C:
D.append(b+c)
D.sort(reverse=True)
n = 0
for a in A:
for d in D:
E.append(a+d)
E.sort(reverse=True)
for e in E[:k]:
print(e)
|
#!/usr/bin/env python
x, y, z, k = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
D = []
E = []
for b in B:
for c in C:
D.append(b+c)
D.sort(reverse=True)
n = 0
for a in A:
for d in D[:k]:
E.append(a+d)
E.sort(reverse=True)
for e in E[:k]:
print(e)
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A, key = lambda x:-x)
B = sorted(B, key = lambda x:-x)
C = sorted(C, key = lambda x:-x)
AB = [0] * (X * Y)
index = 0
for i in range(len(A)):
for j in range(len(B)):
AB[index] = A[i] + B[j]
index += 1
AB = sorted(AB, key = lambda x:-x)
AB = AB[0:3010]
ABC = [0] * (3010 * Z)
index = 0
for i in AB:
for j in range(len(C)):
if j > 3010:
break
ABC[index] = i + C[j]
index += 1
ABC = sorted(ABC, key = lambda x:-x)
for i in range(0,K):
print((ABC[i]))
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A, key = lambda x:-x)
B = sorted(B, key = lambda x:-x)
C = sorted(C, key = lambda x:-x)
AB = [0] * (X * Y)
ABC = []
for i in range(X):
for j in range(Y):
if (i + 1) * (j + 1) > K:
break
for k in range(Z):
if (i + 1) * (j + 1) * (k + 1) > K:
break
ABC.append(A[i] + B[j] + C[k])
ABC = sorted(ABC, key = lambda x:-x)
for i in range(0, K):
print((ABC[i]))
|
p03078
|
X,Y,Z,K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A,reverse=True)
B = sorted(B,reverse=True)
C = sorted(C,reverse=True)
#print(A,B,C)
list1 = []
a,b,c = 0,0,0
for a in range(X):
for b in range(Y):
for c in range(Z):
list1.append(A[a]+B[b]+C[c])
for i in range(K):
print((max(list1)))
list1.remove(max(list1))
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
AB = [0] * (X * Y)
for i in range(X):
for j in range(Y):
AB[i * Y + j] = A[i] + B[j]
AB = sorted(AB, reverse = True)[:K]
#print(AB)
ABC = []
for i in range(len(AB)):
for j in range(Z):
ABC.append(AB[i] + C[j])
ABC = sorted(ABC, reverse = True)[:K]
for i in range(K):
print((ABC[i]))
|
p03078
|
x,y,z,k=list(map(int, input().split()))
a=list(map(int, input().split()))
b=list(map(int, input().split()))
c=list(map(int, input().split()))
import itertools
combi=list(itertools.product(a,b,c))
ans=[0]*len(combi)
for i in range(len(combi)):
ans[i]= sum(combi[i])
ans.sort(reverse=True)
for x in ans[:k]:
print(x)
|
x,y,z,k=list(map(int, input().split()))
a=list(map(int, input().split()))
b=list(map(int, input().split()))
c=list(map(int, input().split()))
import itertools
combi=list(itertools.product(a,b))
ans=[0]*len(combi)
for i in range(len(combi)):
ans[i]= sum(combi[i])
ans.sort(reverse=True)
combi2=list(itertools.product(ans[:k],c))
ans2=[0]*len(combi2)
for j in range(len(combi2)):
ans2[j]=sum(combi2[j ])
ans2.sort(reverse=True)
for x in ans2[:k]:
print(x)
|
p03078
|
x, y, z, k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
L = []
for i in A:
for j in B:
L.append(i+j)
S = sorted(L, reverse=True)[:k]
T = []
for i in S:
for j in sorted(C, reverse=True)[:k]:
T.append(i+j)
print(*sorted(T, reverse=True)[:k], sep="\n")
|
x, y, z, k = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
L = []
for i in range(min(x, k)):
for j in range(min(y, k//(i+1))):
for l in range(min(z, k//(i+1)//(j+1))):
L.append(A[i]+B[j]+C[l])
print(*sorted(L)[::-1][:k], sep="\n")
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
L = []
for a in A:
for b in B:
L.append(a + b)
L.sort(reverse = True)
ans = []
for i, l in enumerate(L):
if i == K:
break
else:
for c in C:
ans.append(l + c)
ans.sort(reverse = True)
for i, a in enumerate(ans):
if i == K:
break
else:
print(a)
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
L = []
for i, a in enumerate(A):
for j, b in enumerate(B):
if i * j > K:
continue
else:
L.append(a + b)
L.sort(reverse = True)
ans = []
for i, l in enumerate(L):
if i == K:
break
else:
for c in C:
ans.append(l + c)
ans.sort(reverse = True)
for i, a in enumerate(ans):
if i == K:
break
else:
print(a)
|
p03078
|
X,Y,Z,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
ABC = []
for a in A:
for b in B:
for c in C:
ABC.append(a+b+c)
ABC = sorted(ABC,reverse=True)
for k in range(K):
print((ABC[k]))
|
X,Y,Z,K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
AB = []
for a in A:
for b in B:
AB.append(a+b)
AB = sorted(AB,reverse=True)[:K]
C = sorted(C,reverse=True)
ABC = []
for c in C:
for ab in AB:
ABC.append(c + ab)
ABC = sorted(ABC,reverse=True)
print(*ABC[:K],sep="\n")
|
p03078
|
# -*- coding: utf-8 -*-
"""
D - Cake 123
https://atcoder.jp/contests/abc123/tasks/abc123_d
"""
import sys
from itertools import product
def solve(X, Y, Z, K, A, B, C):
res_AB = sorted([sum(p) for p in product(A, B)], reverse=True)[:K]
return sorted([sum(p) for p in product(res_AB, C)], reverse=True)[:K]
def main(args):
X, Y, Z, K = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(b) for b in input().split()]
C = [int(c) for c in input().split()]
ans = solve(X, Y, Z, K, A, B, C)
print(*ans, sep='\n')
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
D - Cake 123
https://atcoder.jp/contests/abc123/tasks/abc123_d
"""
import sys
from itertools import product
def solve(X, Y, Z, K, A, B, C):
# TLE
res_AB = sorted([sum(p) for p in product(A, B)], reverse=True)[:K]
return sorted([sum(p) for p in product(res_AB, C)], reverse=True)[:K]
def main(args):
X, Y, Z, K = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(b) for b in input().split()]
C = [int(c) for c in input().split()]
ans = solve(X, Y, Z, K, A, B, C)
print(*ans, sep='\n')
if __name__ == '__main__':
main(sys.argv[1:])
|
p03078
|
# -*- coding: utf-8 -*-
"""
D - Cake 123
https://atcoder.jp/contests/abc123/tasks/abc123_d
AC
"""
import sys
from itertools import product
def solve(X, Y, Z, K, A, B, C):
# 解説の解法#2
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
res = []
for i, a in enumerate(A, start=1):
for j, b in enumerate(B, start=1):
for k, c in enumerate(C, start=1):
if i*j*k > K:
break
res.append(a+b+c)
return sorted(res, reverse=True)[:K]
def main(args):
X, Y, Z, K = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(b) for b in input().split()]
C = [int(c) for c in input().split()]
ans = solve(X, Y, Z, K, A, B, C)
print(*ans, sep='\n')
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
D - Cake 123
https://atcoder.jp/contests/abc123/tasks/abc123_d
AC
"""
import sys
def solve(X, Y, Z, K, A, B, C):
# 解説の解法#2
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
res = []
for i, a in enumerate(A, start=1):
for j, b in enumerate(B, start=1):
for k, c in enumerate(C, start=1):
if i*j*k > K:
break
res.append(a+b+c)
return sorted(res, reverse=True)[:K]
def main(args):
X, Y, Z, K = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(b) for b in input().split()]
C = [int(c) for c in input().split()]
ans = solve(X, Y, Z, K, A, B, C)
print(*ans, sep='\n')
if __name__ == '__main__':
main(sys.argv[1:])
|
p03078
|
x,y,z,k=list(map(int,input().split()))
al=[int(i) for i in input().split()]
bl=[int(i) for i in input().split()]
cl=[int(i) for i in input().split()]
lst=[i+j for i in al for j in bl]
lst.sort(reverse=True)
num=min(x*y,k)
lst=lst[:num]
L=[i+j for i in cl for j in lst]
L.sort(reverse=True)
for i in range(k):
print((L[i]))
|
def main():
x,y,z,k=list(map(int,input().split()))
al=[int(i) for i in input().split()]
bl=[int(i) for i in input().split()]
cl=[int(i) for i in input().split()]
lst=[i+j for i in al for j in bl]
lst.sort(reverse=True)
num=min(x*y,k)
lst=lst[:num]
L=[i+j for i in cl for j in lst]
L.sort(reverse=True)
for i in range(k):
print((L[i]))
if __name__=='__main__':
main()
|
p03078
|
x,y,z,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
a.sort(reverse=True),b.sort(reverse=True),c.sort(reverse=True)
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i]+b[j])
ab.sort(reverse=True)
ab = ab[0:k]
abc = []
for i in ab:
for j in c:
abc.append(i+j)
abc.sort(reverse=True)
abc = abc[0:k]
for i in abc:
print(i)
|
x,y,z,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
a.sort(reverse=True),b.sort(reverse=True),c.sort(reverse=True)
abc = []
for i in range(x):
for j in range(y):
for l in range(z):
if (i+1)*(j+1)*(l+1)>k:
break
abc.append(a[i]+b[j]+c[l])
abc.sort(reverse=True)
abc = abc[0:k]
for i in abc:
print(i)
|
p03078
|
import itertools
import sys
input = sys.stdin.readline
maxn = 10000000000
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.append(-maxn)
B.append(-maxn)
C.append(-maxn)
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
apos, bpos, cpos = 0, 0, 0
while (apos + 1) * (bpos + 1) * (cpos + 1) < min(2 * 10 ** 6, X * Y * Z):
if (
apos < len(A) - 2
and abs(A[apos] - A[apos + 1]) < abs(B[bpos] - B[bpos + 1])
and abs(A[apos] - A[apos + 1]) < abs(C[cpos] - C[cpos + 1])
):
apos += 1
elif bpos < len(B) - 2 and B[bpos] - B[bpos + 1] < C[cpos] - C[cpos + 1]:
bpos += 1
else:
cpos += 1
res = []
for a in list(itertools.product(A[: apos + 1], B[: bpos + 1], C[: cpos + 1])):
res.append(a[0] + a[1] + a[2])
res.sort(reverse=True)
for k in range(K):
print((res[k]))
|
import itertools
import sys
input = sys.stdin.readline
maxn = 10000000000
X, Y, Z, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
cand = []
for i, a in enumerate(A):
for j, b in enumerate(B):
for k, c in enumerate(C):
if (i + 1) * (j + 1) * (k + 1) <= K:
cand.append(a + b + c)
else:
break
cand.sort(reverse=True)
for k in range(K):
print((cand[k]))
|
p03078
|
x, y, z, k = list(map(int, input().split()))
alist = list(map(int, input().split()))
blist = list(map(int, input().split()))
clist = list(map(int, input().split()))
alist.sort(reverse=True)
blist.sort(reverse=True)
clist.sort(reverse=True)
delist = []
for a in range(x) :
for b in range(y) :
if a+b > k :
break
for c in range(z) :
if a+b+c > k :
break
else :
delist.append(alist[a]+blist[b]+clist[c])
delist.sort(reverse=True)
for n in delist[:k] :
print(n)
|
x, y, z, k = list(map(int, input().split()))
alist = list(map(int, input().split()))
blist = list(map(int, input().split()))
clist = list(map(int, input().split()))
alist.sort(reverse=True)
blist.sort(reverse=True)
clist.sort(reverse=True)
delist = []
for a in range(x) :
for b in range(y) :
if a*b > k :
break
for c in range(z) :
if a*b*c > k :
break
else :
delist.append(alist[a]+blist[b]+clist[c])
delist.sort(reverse=True)
for n in delist[:k] :
print(n)
|
p03078
|
def main():
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
AB = []
ABappend = AB.append
for i in range(X):
for j in range(Y):
ABappend(A[i] + B[j])
ABC = []
ABCappend = ABC.append
for i in range(X * Y):
for j in range(Z):
ABCappend(AB[i] + C[j])
ABC.sort(reverse=True)
print(('\n'.join(map(str, ABC[:K]))))
if __name__ == '__main__':
main()
|
def main():
X, Y, Z, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
AB = []
ABappend = AB.append
for i in range(X):
for j in range(Y):
ABappend(A[i] + B[j])
AB.sort(reverse=True)
ABC = []
ABCappend = ABC.append
for i in range(min(K, X*Y)):
for j in range(Z):
ABCappend(AB[i] + C[j])
ABC.sort(reverse=True)
print(('\n'.join(map(str, ABC[:K]))))
if __name__ == '__main__':
main()
|
p03078
|
from itertools import product
x, y, z, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
AB = [sum(ab) for ab in product(A, B)]
AB.sort(reverse=True)
AB = AB[:k]
ABC = [sum(abc) for abc in product(AB, C)]
ABC.sort(reverse=True)
for i in range(k):
print((ABC[i]))
|
x, y, z, K = list(map(int, input().split()))
A = sorted(map(int, input().split()), reverse=True)
B = sorted(map(int, input().split()), reverse=True)
C = sorted(map(int, input().split()), reverse=True)
ans = []
for i in range(x):
for j in range(y):
for k in range(z):
if (i+1)*(j+1)*(k+1) <= K:
ans.append(A[i]+B[j]+C[k])
continue
break
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
p03078
|
x, y, z, k = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
Z = [int(i) for i in input().split()]
count = []
for i in X:
for j in Y:
for l in Z:
count.append(i+j+l)
count.sort(reverse=1)
for c in range(k):
print((count[c]))
|
x, y, z, k = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
Z = [int(i) for i in input().split()]
answer = []
for i in X:
for j in Y:
answer.append(i+j)
answer.sort(reverse=1)
answer2 = []
for l in Z[:k]:
for a in answer[:k]:
answer2.append(l+a)
answer2.sort(reverse=1)
for p in answer2[:k]:
print(p)
|
p03078
|
x, y, z, k = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
Z = [int(i) for i in input().split()]
X.sort(reverse=1)
Y.sort(reverse=1)
Z.sort(reverse=1)
answer = []
for i in X[:k]:
for j in Y[:k]:
answer.append(i+j)
answer.sort(reverse=1)
answer2 = []
for l in Z[:k]:
for a in answer[:k]:
answer2.append(l+a)
answer2.sort(reverse=1)
for p in answer2[:k]:
print(p)
|
x, y, z, k = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
Z = [int(i) for i in input().split()]
X.sort(reverse=1)
Y.sort(reverse=1)
Z.sort(reverse=1)
answer = [i+j for i in X[:k] for j in Y[:k]]
answer.sort(reverse=1)
answer2 = [i+j for i in Z[:k] for j in answer[:k]]
answer2.sort(reverse=1)
for p in answer2[:k]:
print(p)
|
p03078
|
x, y, z, k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
result = []
for c in range(z):
for b in range(y):
for a in range(x):
result.append(A[a] + B[b] + C[c])
result.sort()
[print(val) for val in result[-k:][::-1]]
|
x, y, z, k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
result = []
def func1():
E = [a+b for a in A for b in B]
E.sort()
if len(E) > k: E = E[-k:]
F = [c+e for c in C for e in E]
F.sort()
return F[-k:][::-1]
[print(val) for val in func1()]
|
p03078
|
X,Y,Z,K = list(map(int,input().split()))
K = min(K,X*Y*Z)
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
sum2 = []
for a in A:
for b in B:
sum2.append(a+b)
sum2.sort(reverse = True)
sum2 = sum2[:K]
idx = 0
sum3 = []
for c in C:
for s in sum2:
sum3.append(c+s)
sum3.sort(reverse=True)
for i in range(K):
print((sum3[i]))
|
import heapq
X,Y,Z,K = list(map(int,input().split()))
K = min(K,X*Y*Z)
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
set_ = set()
hq = [(-(A[0]+B[0]+C[0]),0,0,0)]
heapq.heapify(hq)
set_.add((0,0,0))
while K:
val,i,j,k = heapq.heappop(hq)
print((-val))
K-=1
if i+1<len(A) and (i+1,j,k) not in set_:
heapq.heappush(hq,(-(A[i+1]+B[j]+C[k]),i+1,j,k))
set_.add((i+1,j,k))
if j+1<len(B) and (i,j+1,k) not in set_:
heapq.heappush(hq,(-(A[i]+B[j+1]+C[k]),i,j+1,k))
set_.add((i,j+1,k))
if k+1<len(C) and (i,j,k+1) not in set_:
heapq.heappush(hq,(-(A[i]+B[j]+C[k+1]),i,j,k+1))
set_.add((i,j,k+1))
|
p03078
|
x,y,z,K = list(map(int, input().split()))
abc = [sorted(list(map(int, input().split())), reverse=True) for i in range(3)]
ans = []
for i in range(x):
for j in range(y):
for k in range(z):
if (i+1)*(j+1)*(k+1) <= K:
ans.append(abc[0][i]+abc[1][j]+abc[2][k])
for i in sorted(ans)[::-1][:K]:
print(i)
|
x,y,z,K = list(map(int, input().split()))
abc = [sorted(list(map(int, input().split())), reverse=True) for i in range(3)]
ans = []
for i in range(x):
for j in range(y):
for k in range(z):
if (i+1)*(j+1)*(k+1) <= K:
ans.append(abc[0][i]+abc[1][j]+abc[2][k])
else:
break
for i in sorted(ans)[::-1][:K]:
print(i)
|
p03078
|
import bisect
a,b,c,k = list(map(int,input().split()))
aa = list(map(int,input().split()))
bb = list(map(int,input().split()))
cc = list(map(int,input().split()))
aa.sort(reverse = True)
bb.sort(reverse = True)
cc.sort(reverse = True)
al = []
for i in range(a):
for j in range(b):
for l in range(c):
kk = aa[i]+bb[j]+cc[l]
bisect.insort_left(al,kk)
al.reverse()
for i in range(k):
print((al[i]))
|
a,b,c,k = list(map(int,input().split()))
aa = list(map(int,input().split()))
aa.sort(reverse = True)
bb = list(map(int,input().split()))
bb.sort(reverse = True)
cc = list(map(int,input().split()))
cc.sort(reverse = True)
al = []
aal = []
for i in aa:
for j in bb:
al.append(i+j)
al.sort()
if len(al) > k:
al = al[len(al)-k:]
for i in al:
for j in cc:
aal.append(i+j)
aal.sort()
if len(aal) > k:
aal = aal[len(aal)-k:]
aal.reverse()
for i in aal:
print(i)
|
p03078
|
x,y,z,k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = sorted(a)
b = sorted(b)
c = sorted(c)
memory = []
ai = x-1
bi = y-1
ci = z-1
p = 10**11
while k>0:
ps = []
abc = []
for dx in range(-8,8):
for dy in range(-8,8):
for dz in range(-8,8):
if not (ai+dx>=0 and ai+dx<x and bi+dy>=0 and bi+dy<y and ci+dz>=0 and ci+dz<z):
continue
tmp = a[ai+dx]+b[bi+dy]+c[ci+dz]
if p >= tmp and not (ai+dx,bi+dy,ci+dz) in memory:
ps.append(tmp)
abc.append((ai+dx, bi+dy, ci+dz))
p = max(ps)
i = ps.index(p)
memory.append(abc[i])
print(p)
k -= 1
|
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
T = []
for a in A:
for b in B:
T.append(a + b)
T = sorted(T, reverse=True)[:min(K, len(T))]
res = []
for t in T:
for c in C:
res.append(t + c)
res = sorted(res, reverse=True)[:K]
for r in res:
print(r)
if __name__ == "__main__":
main()
|
p03078
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
# A.sort(reverse=True)
# B.sort(reverse=True)
# C.sort(reverse=True)
# m = A[0]+B[0]+C[0]
AB = []
for a in A:
for b in B:
AB.append(a+b)
ABC = []
for c in C:
for ab in AB:
ABC.append(c+ab)
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
X, Y, Z, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
# A.sort(reverse=True)
# B.sort(reverse=True)
# C.sort(reverse=True)
# m = A[0]+B[0]+C[0]
AB = []
ABC = []
for a in A:
for b in B:
AB.append(a+b)
AB.sort(reverse=True)
AB = AB[:K]
for c in C:
for ab in AB:
ABC.append(c+ab)
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
x,y,z,k = [int(num) for num in input().split()]
a_cake,b_cake,c_cake = [sorted([int(num) for num in input().split()],reverse=True)[:k] for _ in range(3)]
sum_cake = sorted([a+b+c for a in a_cake for b in b_cake for c in c_cake],reverse=True)[:k]
for i in sum_cake:
print(i)
|
x,y,z,k = [int(num) for num in input().split()]
a_cake,b_cake,c_cake = [sorted([int(num) for num in input().split()],reverse=True)[:k] for _ in range(3)]
sum_cake=list()
for i,a in enumerate(a_cake,1):
for j,b in enumerate(b_cake,1):
if(i*j>k):
break
for n,c in enumerate(c_cake,1):
if(i*j*n>k):
break
sum_cake.append(a+b+c)
sum_cake.sort(reverse=True)
for i in sum_cake[:k]:
print(i)
|
p03078
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
def diff(l):
m = max(l)
return sorted(m - v for v in l)[1:]
s = sum(map(max, [a, b, c]))
sa, sb, sc = list(map(diff, [a, b, c]))
da, db, dc = [0], [0], [0]
q = [0]
while k > 0:
while True:
if len(sa) > 0 and (len(q) == 0 or q[0] >= sa[0]):
for v in [sa[0] + bb + cc for bb in db for cc in dc]:
heapq.heappush(q, v)
da.append(sa[0])
sa = sa[1:]
elif len(sb) > 0 and (len(q) == 0 or q[0] >= sb[0]):
for v in [sb[0] + aa + cc for aa in da for cc in dc]:
heapq.heappush(q, v)
db.append(sb[0])
sb = sb[1:]
elif len(sc) > 0 and (len(q) == 0 or q[0] >= sc[0]):
for v in [sc[0] + aa + bb for aa in da for bb in db]:
heapq.heappush(q, v)
dc.append(sc[0])
sc = sc[1:]
else:
break
v = heapq.heappop(q)
print(s - v)
k -= 1
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
def diff(l):
m = max(l)
return sorted(m - v for v in l)[1:]
s = sum(map(max, [a, b, c]))
sa, sb, sc = list(map(diff, [a, b, c]))
da, db, dc = [0], [0], [0]
q = [0]
while k > 0:
while True:
if len(sa) > 0 and (len(q) == 0 or q[0] > sa[0]):
for v in [sa[0] + bb + cc for bb in db for cc in dc]:
heapq.heappush(q, v)
da.append(sa[0])
sa = sa[1:]
elif len(sb) > 0 and (len(q) == 0 or q[0] > sb[0]):
for v in [sb[0] + aa + cc for aa in da for cc in dc]:
heapq.heappush(q, v)
db.append(sb[0])
sb = sb[1:]
elif len(sc) > 0 and (len(q) == 0 or q[0] > sc[0]):
for v in [sc[0] + aa + bb for aa in da for bb in db]:
heapq.heappush(q, v)
dc.append(sc[0])
sc = sc[1:]
else:
break
v = heapq.heappop(q)
print(s - v)
k -= 1
|
p03078
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
def diff(l):
m = max(l)
return sorted(m - v for v in l)[1:]
s = sum(map(max, [a, b, c]))
sa, sb, sc = list(map(diff, [a, b, c]))
da, db, dc = [0], [0], [0]
q = [0]
while k > 0:
while True:
if len(sa) > 0 and (len(q) == 0 or q[0] > sa[0]):
for v in [sa[0] + bb + cc for bb in db for cc in dc]:
heapq.heappush(q, v)
da.append(sa[0])
sa = sa[1:]
elif len(sb) > 0 and (len(q) == 0 or q[0] > sb[0]):
for v in [sb[0] + aa + cc for aa in da for cc in dc]:
heapq.heappush(q, v)
db.append(sb[0])
sb = sb[1:]
elif len(sc) > 0 and (len(q) == 0 or q[0] > sc[0]):
for v in [sc[0] + aa + bb for aa in da for bb in db]:
heapq.heappush(q, v)
dc.append(sc[0])
sc = sc[1:]
else:
break
v = heapq.heappop(q)
print(s - v)
k -= 1
|
import heapq
x, y, z, k = list(map(int, input().split()))
a = sorted(map(int, input().split()))
b = sorted(map(int, input().split()))
c = sorted(map(int, input().split()))
q = []
memo = set()
def qpush(q, ai, bi, ci):
t = (-(a[ai] + b[bi] + c[ci]), ai, bi, ci)
if not t in memo:
memo.add(t)
heapq.heappush(q, t)
qpush(q, len(a) - 1, len(b) - 1, len(c) - 1)
for _ in range(k):
s, ai, bi, ci = heapq.heappop(q)
if ai > 0:
qpush(q, ai - 1, bi, ci)
if bi > 0:
qpush(q, ai, bi - 1, ci)
if ci > 0:
qpush(q, ai, bi, ci - 1)
print(-s)
|
p03078
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.