input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
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=[]
append=AB.append
for i in range(min(K,X)):
for j in range(min(K,Y)):
append(A[i]+B[j])
AB.sort(reverse=True)
ABC=[]
appendd=ABC.append
for k in range(min(K,len(AB))):
for l in range(min(K,Z)):
appendd(AB[k]+C[l])
ABC.sort(reverse=True)
for m in range(K):
print((ABC[m]))
|
import sys
def main():
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)
AB=[]
append=AB.append
for i in range(min(K,X)):
for j in range(min(K,Y)):
append(A[i]+B[j])
AB.sort(reverse=True)
ABC=[]
appendd=ABC.append
for k in range(min(K,len(AB))):
for l in range(min(K,Z)):
appendd(AB[k]+C[l])
ABC.sort(reverse=True)
for m in range(K):
print((ABC[m]))
if __name__=="__main__":
main()
|
p03078
|
x, y, z, k = list(map(int, input().split()))
k = min(x * y * z, k)
a = sorted(list(map(int, input().split())), reverse=True)[:k]
b = sorted(list(map(int, input().split())), reverse=True)[:k]
c = sorted(list(map(int, input().split())), reverse=True)[:k]
def f(a, b):
results = []
cnt = 0
for i in a:
for j in b:
cnt += 1
results.append(i + j)
return results
ab_results = sorted(f(a, b), reverse=True)
results = sorted(f(c, ab_results[:k]), reverse=True)
print(("\n".join(map(str, results[:k]))))
|
x, y, z, k = list(map(int, input().split()))
k = min(x * y * z, k)
a = sorted(list(map(int, input().split())), reverse=True)[:k]
b = sorted(list(map(int, input().split())), reverse=True)[:k]
c = sorted(list(map(int, input().split())), reverse=True)[:k]
def f(a, b):
return [i + j for i in a for j in b]
ab_results = sorted(f(a, b), reverse=True)
results = sorted(f(c, ab_results[:k]), reverse=True)
print(("\n".join(map(str, results[:k]))))
|
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個分のみの要素にする
'''
'''
import math
cnt_num = math.ceil(pow(k, 1/3))
A = sorted(A,reverse=True)[:cnt_num]
B = sorted(B,reverse=True)[:cnt_num]
C = sorted(C,reverse=True)[:cnt_num]
'''
A = sorted(A,reverse=True)[:k]
B = sorted(B,reverse=True)[:k]
C = sorted(C,reverse=True)[:k]
ans_list = []
for a in A:
for b in B:
for c in C:
ans_list.append(a+b+c)
ans_list.sort(reverse=True)
for ans in ans_list[:k]:
print(ans)
|
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)[:k]
B = sorted(B,reverse=True)[:k]
C = sorted(C,reverse=True)[:k]
list_ans = []
for index_a,a in enumerate(A):
for index_b,b in enumerate(B):
for index_c,c in enumerate(C):
if (index_a + 1) * (index_b + 1) * (index_c + 1) > k:
break
list_ans.append(a+b+c)
list_ans.sort(reverse=True)
for i in list_ans[:k]:
print(i)
|
p03078
|
import sys
def p(*a):
s=" ".join(map(str,a))
#print(s)
sys.stderr.write(s+"\n")
X,Y,Z,K = list(map(int, input().split()))
A = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
B = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
C = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
p(X,Y,Z,K)
p(A)
p(B)
p(C)
from itertools import product
L = list( product(A,B,C) ) # 上と同じ意味
#p(L)
from operator import itemgetter
#p( sorted(L, key=lambda x: (x[0]+x[1]+x[2])*(-1)) ) # 0 番目の要素 * 2 番目の要素でソート
iCount=0
for l in sorted(L, key=lambda x: (x[0]+x[1]+x[2])*(-1)):
a = l[0]+l[1]+l[2]
print(a)
iCount+=1
if iCount>=K: break
|
import sys
def p(*a):
s=" ".join(map(str,a))
#print(s)
sys.stderr.write(s+"\n")
X,Y,Z,K = list(map(int, input().split()))
A = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
B = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
C = sorted(list( map(int, input().split()) ), reverse=True) # 1 2 3 4 5 ...(ソート付き)
p(X,Y,Z,K)
p(A)
p(B)
p(C)
#ABC=[]
#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
# ABC.append(A[a]+B[b]+C[c])
#
#ABC.sort(reverse=True)
AB=[]
for a in range(X):
for b in range(Y):
if (a+b)>K: break
AB.append(A[a]+B[b])
AB.sort(reverse=True)
p("AB=",AB)
ABC=[]
for ab in range(len(AB)):
if ab>K: break
for c in range(Z):
if (ab+c)>K: break
ABC.append(AB[ab]+C[c])
ABC.sort(reverse=True)
p("ABC=",ABC)
for k in range(K):
print((ABC[k]))
|
p03078
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
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)
sum_list = []
seen_list = set()
ans = []
heappush(sum_list, (-(A[0]+B[0]+C[0]), 0, 0, 0))
seen_list.add((0, 0, 0))
while sum_list:
s, i, j, k = heappop(sum_list)
ans.append(-s)
if i+1 < len(A) and (i+1, j, k) not in seen_list:
heappush(sum_list, (-(A[i+1]+B[j]+C[k]), i+1, j, k))
seen_list.add((i+1, j, k))
if j+1 < len(B) and (i, j+1, k) not in seen_list:
heappush(sum_list, (-(A[i]+B[j+1]+C[k]), i, j+1, k))
seen_list.add((i, j+1, k))
if k+1 < len(C) and (i, j, k+1) not in seen_list:
heappush(sum_list, (-(A[i]+B[j]+C[k+1]), i, j, k+1))
seen_list.add((i, j, k+1))
for i in range(0, K):
print((ans[i]))
if __name__ == "__main__":
solve()
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
from heapq import heappop, heappush, heapify
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)
sum_list = []
seen_list = set()
ans = []
heappush(sum_list, (-(A[0]+B[0]+C[0]), 0, 0, 0))
seen_list.add((0, 0, 0))
for _ in range(K):
s, i, j, k = heappop(sum_list)
ans.append(-s)
if i+1 < len(A) and (i+1, j, k) not in seen_list:
heappush(sum_list, (-(A[i+1]+B[j]+C[k]), i+1, j, k))
seen_list.add((i+1, j, k))
if j+1 < len(B) and (i, j+1, k) not in seen_list:
heappush(sum_list, (-(A[i]+B[j+1]+C[k]), i, j+1, k))
seen_list.add((i, j+1, k))
if k+1 < len(C) and (i, j, k+1) not in seen_list:
heappush(sum_list, (-(A[i]+B[j]+C[k+1]), i, j, k+1))
seen_list.add((i, j, k+1))
for i in range(0, K):
print((ans[i]))
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)
delicious_list = []
for a in A[:min((1000,len(A)))]:
for b in B[:min((1000,len(B)))]:
for c in C[:min((1000,len(C)))]:
delicious_list.append(a+b+c)
delicious_list.sort(reverse=True)
for i in range(K):
print((delicious_list[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)
delicious_list = []
for i in range(len(A)):
for j in range(len(B)):
for k in range(len(C)):
if i*j*k>=K: continue
delicious_list.append(A[i]+B[j]+C[k])
delicious_list.sort(reverse=True)
for i in range(K):
print((delicious_list[i]))
|
p03078
|
import sys
input = sys.stdin.readline
x, y, z, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
c_list = list(map(int, input().split()))
a_list.sort(reverse=True)
b_list.sort(reverse=True)
c_list.sort(reverse=True)
tmp_list = [a+b for a in a_list for b in b_list]
tmp_list.sort(reverse=True)
honest_list = [tmp+c for tmp in tmp_list for c in c_list]
honest_list.sort(reverse=True)
for h in honest_list[:k]:
print(h)
|
import sys
input = sys.stdin.readline
x, y, z, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
c_list = list(map(int, input().split()))
a_list.sort(reverse=True)
b_list.sort(reverse=True)
c_list.sort(reverse=True)
tmp_list = [a+b for a in a_list for b in b_list]
tmp_list.sort(reverse=True)
honest_list = [tmp+c for tmp in tmp_list[:k] for c in c_list]
honest_list.sort(reverse=True)
for h in honest_list[:k]:
print(h)
|
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 s in a:
for t in b:
l.append(s+t)
l.sort(reverse=True)
n=[]
for s in l[:k+1]:
for t in c:
n.append(s+t)
n.sort(reverse=True)
for i in range(k):
print((n[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 s in range(x):
for t in range(y):
for u in range(z):
if (s+1)*(t+1)*(u+1)<= k:
l.append(a[s]+b[t]+c[u])
else:
break
l.sort(reverse=True)
for i in range(k):
print((l[i]))
|
p03078
|
from collections import deque, defaultdict
import copy
import bisect
#sys.setrecursionlimit(10 ** 9)
import math
import heapq
import sys
def input():
return sys.stdin.readline().strip()
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)
kouho = []
all_set = []
heapq.heappush(kouho, [-(A[0] + B[0] + C[0]), 0, 0, 0])
all_set.append([-(A[0] + B[0] + C[0]), 0, 0, 0])
for i in range(K):
comb = heapq.heappop(kouho)
print((-comb[0]))
if comb[1] < X - 1 and not [-(A[comb[1] + 1] + B[comb[2]] + C[comb[3]]), comb[1] + 1, comb[2], comb[3]] in all_set:
heapq.heappush(kouho, [-(A[comb[1] + 1] + B[comb[2]] + C[comb[3]]), comb[1] + 1, comb[2], comb[3]])
all_set.append([-(A[comb[1] + 1] + B[comb[2]] + C[comb[3]]), comb[1] + 1, comb[2], comb[3]])
if comb[2] < Y - 1 and not [-(A[comb[1]] + B[comb[2] + 1] + C[comb[3]]), comb[1], comb[2] + 1, comb[3]] in all_set:
heapq.heappush(kouho, [-(A[comb[1]] + B[comb[2] + 1] + C[comb[3]]), comb[1], comb[2] + 1, comb[3]])
all_set.append([-(A[comb[1]] + B[comb[2] + 1] + C[comb[3]]), comb[1], comb[2] + 1, comb[3]])
if comb[3] < Z - 1 and not [-(A[comb[1]] + B[comb[2]] + C[comb[3] + 1]), comb[1], comb[2], comb[3] + 1] in all_set:
heapq.heappush(kouho, [-(A[comb[1]] + B[comb[2]] + C[comb[3] + 1]), comb[1], comb[2], comb[3] + 1])
all_set.append([-(A[comb[1]] + B[comb[2]] + C[comb[3] + 1]), comb[1], comb[2], comb[3] + 1])
|
from collections import deque, defaultdict
import copy
import bisect
#sys.setrecursionlimit(10 ** 9)
import math
import heapq
import sys
def input():
return sys.stdin.readline().strip()
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)
kouho = []
all_set = set()
heapq.heappush(kouho, [-(A[0] + B[0] + C[0]), 0, 0, 0])
all_set.add(0)
for i in range(K):
comb = heapq.heappop(kouho)
print((-comb[0]))
if comb[1] < X - 1 and not (comb[1] + 1)*Y*Z + comb[2]*Z + comb[3] in all_set:
heapq.heappush(kouho, [-(A[comb[1] + 1] + B[comb[2]] + C[comb[3]]), comb[1] + 1, comb[2], comb[3]])
all_set.add((comb[1] + 1)*Y*Z + comb[2]*Z + comb[3])
if comb[2] < Y - 1 and not comb[1]*Y*Z + (comb[2] + 1)*Z + comb[3] in all_set:
heapq.heappush(kouho, [-(A[comb[1]] + B[comb[2] + 1] + C[comb[3]]), comb[1], comb[2] + 1, comb[3]])
all_set.add(comb[1]*Y*Z + (comb[2] + 1)*Z + comb[3])
if comb[3] < Z - 1 and not comb[1]*Y*Z + comb[2]*Z + comb[3] + 1 in all_set:
heapq.heappush(kouho, [-(A[comb[1]] + B[comb[2]] + C[comb[3] + 1]), comb[1], comb[2], comb[3] + 1])
all_set.add(comb[1]*Y*Z + comb[2]*Z + comb[3] + 1)
|
p03078
|
from itertools import product
x, y, z, k = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
zs = list(map(int, input().split()))
# xs.sort(reverse=True)
# ys.sort(reverse=True)
# zs.sort(reverse=True)
ans_list = []
for i,a in enumerate(list(product(xs,ys,zs))):
ans_list.append(sum(a))
ans_list.sort(reverse=True)
for i,ans in enumerate(ans_list):
print(ans)
if i == k - 1:
break
|
from itertools import product
x, y, z, k = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
zs = list(map(int, input().split()))
xy_list = []
for i,xy in enumerate(list(product(xs,ys))):
xy_list.append(sum(xy))
xy_list.sort(reverse=True)
xy_list = xy_list[:k]
ans_list = []
for i,xyz in enumerate(list(product(xy_list,zs))):
ans_list.append(sum(xyz))
ans_list.sort(reverse=True)
ans_list = ans_list[:k]
for ans in ans_list:
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()))
AB = list()
for i in A:
for j in B:
AB.append(i+j)
AB.sort(reverse=True)
ABC = list()
for i in AB[:K]:
for j in C:
ABC.append(i+j)
ABC.sort(reverse=True)
for i in range(K):
print((ABC[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)
ans = list()
for i in range(X):
for j in range(Y):
if (i+1)*(j+1) > K:
break
else:
for k in range(Z):
if (i+1)*(j+1)*(k+1) > K:
break
else:
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 = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
ans = [p+q+r for p in a for q in b for r in c]
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()))
e = [i + j for i in a for j in b]
e.sort(reverse=True)
e = e[:k]
ans = [i + j for i in e for j in c]
ans.sort(reverse=True)
ans = ans[:k]
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()))
e = [i + j for i in a for j in b]
e.sort(reverse=True)
e = e[:k]
ans = [i + j for i in e for j in c]
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)
e = [i + j for i in a[:k] for j in b[:k]]
e.sort(reverse=True)
e = e[:k]
ans = [i + j for i in e for j in c[:k]]
ans.sort(reverse=True)
for i in range(k):
print((ans[i]))
|
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()))
'''
必ず3つからそれぞれ1つずつ取らないといけないので、a,bの組み合わせの大きい順
とa,b,cの組の大きい順で見たときの(a,b)の順は一致している
a,bの組み合わせのうち上からk番目以降は考える必要がない
'''
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i] + b[j])
ab.sort(reverse=True)
ab = ab[:k]
rec = []
for i in range(min(x*y, k)):
for j in range(z):
rec.append(ab[i] + c[j])
rec.sort(reverse=True)
rec = rec[:k]
print(*rec, 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()))
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i] + b[j])
ab.sort(reverse=True)
ab = ab[:k]
rec = []
for i in range(min(x*y, k)):
for j in range(z):
rec.append(ab[i] + c[j])
rec.sort(reverse=True)
rec = rec[:k]
print(*rec, sep='\n')
|
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(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
for a in A:
for b in B:
for c in C:
ans.append(a+b+c)
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
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(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
b=0
c=0
for a in range(len(A)):
for b in range(len(B)):
for c in range(len(C)):
if (a+1)*(b+1)*(c+1)<=K:
ans.append(A[a]+B[b]+C[c])
else:
break
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
p03078
|
x,y,z,k=list(map(int,input().split()))
list_a=list(map(int,input().split()))
list_b=list(map(int,input().split()))
list_c=list(map(int,input().split()))
list_a.sort(reverse=True)
list_b.sort(reverse=True)
list_c.sort(reverse=True)
dict_p={}
dict_p[(0,0,0)]=list_a[0]+list_b[0]+list_c[0]
pop_list=[]
for i in range(0,k):
Max=max(dict_p.values())
print(Max)
for j in dict_p:
if dict_p[j]==Max:
now=j
dict_p.pop(now)
pop_list.append(now)
break
x_t=1
y_t=1
z_t=1
for i in pop_list:
if (now[0]+1,now[1],now[2])==i:
x_t=0
if (now[0],now[1]+1,now[2])==i:
y_t=0
if (now[0],now[1],now[2]+1)==i:
z_t=0
if now[0]+1<x:
if x_t==1:
dict_p[(now[0]+1,now[1],now[2])]=list_a[now[0]+1]+list_b[now[1]]+list_c[now[2]]
if now[1]+1<y:
if y_t==1:
dict_p[(now[0],now[1]+1,now[2])]=list_a[now[0]]+list_b[now[1]+1]+list_c[now[2]]
if now[2]+1<z:
if z_t==1:
dict_p[(now[0],now[1],now[2]+1)]=list_a[now[0]]+list_b[now[1]]+list_c[now[2]+1]
|
x,y,z,k=list(map(int,input().split()))
list_a=list(map(int,input().split()))
list_b=list(map(int,input().split()))
list_c=list(map(int,input().split()))
list_a.sort(reverse=True)
list_b.sort(reverse=True)
list_c.sort(reverse=True)
dict_p={}
dict_p[(0,0,0)]=list_a[0]+list_b[0]+list_c[0]
pop_list=[]
for i in range(0,k):
Max=max(dict_p.values())
print(Max)
for j in dict_p:
if dict_p[j]==Max:
now=j
dict_p.pop(now)
pop_list.append(now)
break
if now[0]+1<x:
if not (now[0]+1,now[1],now[2]) in pop_list:
dict_p[(now[0]+1,now[1],now[2])]=list_a[now[0]+1]+list_b[now[1]]+list_c[now[2]]
if now[1]+1<y:
if not (now[0],now[1]+1,now[2]) in pop_list:
dict_p[(now[0],now[1]+1,now[2])]=list_a[now[0]]+list_b[now[1]+1]+list_c[now[2]]
if now[2]+1<z:
if not (now[0],now[1],now[2]+1) in pop_list:
dict_p[(now[0],now[1],now[2]+1)]=list_a[now[0]]+list_b[now[1]]+list_c[now[2]+1]
|
p03078
|
from itertools import product
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_a = []
L_b = []
L_c = []
for i in range(X) :
L_a.append(A[0] - A[i])
for i in range(Y) :
L_b.append(B[0] - B[i])
for i in range(Z) :
L_c.append(C[0] - C[i])
L = []
P = list(product(range(max(X,Y,Z)), repeat=3))
su = A[0]+B[0]+C[0]
for i in range(len(P)) :
l = su - (L_a[P[i][0]] + L_b[P[i][1]] + L_c[P[i][2]])
L.append(l)
L = sorted(L,reverse=True)
L = L[:K]
print(*L,sep="\n")
|
X,Y,Z,K = 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]
L = []
for i in range(X) :
for j in range(Y) :
L.append(A[i]+B[j])
L = sorted(L)[::-1][:K]
L2 = []
for i in range(len(L)) :
for j in range(Z) :
L2.append(L[i]+C[j])
L2 = sorted(L2)[::-1][:K]
print(*L2,sep="\n")
|
p03078
|
from heapq import heappush, heappushpop
def main():
x, y, z, k = list(map(int, input().split()))
aa = sorted(map(int, input().split()), reverse=True)
bb = sorted(map(int, input().split()), reverse=True)
cc = sorted(map(int, input().split()), reverse=True)
heap = []
for a in aa:
if len(heap) == k and a + bb[0] + cc[0] < heap[0]:
break
for b in bb:
if len(heap) == k and a + b + cc[0] < heap[0]:
break
for c in cc:
v = a + b + c
if len(heap) < k:
heappush(heap, v)
continue
if v < heap[0]:
break
heappushpop(heap, v)
for v in sorted(heap, reverse=True):
print(v)
if __name__ == "__main__":
main()
|
from heapq import heappop, heappush
def main():
x, y, z, k = list(map(int, input().split()))
aa = sorted(map(int, input().split()))
bb = sorted(map(int, input().split()))
cc = sorted(map(int, input().split()))
v = aa[-1] + bb[-1] + cc[-1]
t = (len(aa) - 1, len(bb) - 1, len(cc) - 1)
q = [(-v, t)]
vs = []
ts = set()
while len(vs) < k:
nv, t = heappop(q)
if t in ts:
continue
vs.append(-nv)
ts.add(t)
if t[0] > 0:
heappush(q, (-(aa[t[0] - 1] + bb[t[1]] + cc[t[2]]), (t[0] - 1, t[1], t[2])))
if t[1] > 0:
heappush(q, (-(aa[t[0]] + bb[t[1] - 1] + cc[t[2]]), (t[0], t[1] - 1, t[2])))
if t[2] > 0:
heappush(q, (-(aa[t[0]] + bb[t[1]] + cc[t[2] - 1]), (t[0], t[1], t[2] - 1)))
for v in vs:
print(v)
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)
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(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1) <= K: ans.append(A[i]+B[j]+C[k])
else: break
ans.sort(reverse=True)
for i in range(K): print((ans[i]))
|
p03078
|
x, y, z, k = [int(i) for i in input().split()]
p = [int(a) for a in input().split()]
q = [int(b) for b in input().split()]
r = [int(c) for c in input().split()]
p = sorted(p, reverse=True)
q = sorted(q, reverse=True)
r = sorted(r, reverse=True)
pqr = []
for a in range(len(p)):
if a+1 > k:
continue
for b in range(len(q)):
if b+1 > k:
continue
elif (a+1)*(b+1) > k:
continue
for c in range(len(r)):
if c+1 > k:
continue
elif (a+1)*(c+1) > k:
continue
elif (b+1)*(c+1) > k:
continue
elif (a+1)*(b+1)*(c+1) > k:
continue
pqr.append(p[a] + q[b] + r[c])
pqr = sorted(pqr, reverse=True)
for i in range(k):
print((pqr[i]))
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
if a+1 > K:
break
for b in range(len(B)):
if b+1 > K:
break
elif (a+1)*(b+1) > K:
break
for c in range(len(C)):
if c+1 > K:
break
elif (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
if a+1 > K:
break
for b in range(len(B)):
if b+1 > K:
break
elif (a+1)*(b+1) > K:
break
for c in range(len(C)):
if c+1 > K:
break
elif (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
if a+1 > K:
break
for b in range(len(B)):
if b+1 > K:
break
elif (a+1)*(b+1) > K:
break
for c in range(len(C)):
if (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
if a+1 > K:
break
for b in range(len(B)):
if b+1 > K:
break
elif (a+1)*(b+1) > K:
break
for c in range(len(C)):
if (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
if a+1 > K:
break
for b in range(len(B)):
if (a+1)*(b+1) > K:
break
for c in range(len(C)):
if (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
for b in range(len(B)):
if (a+1)*(b+1) > K:
break
for c in range(len(C)):
if (a+1)*(c+1) > K:
break
elif (b+1)*(c+1) > K:
break
elif (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
X, Y, Z, K = [int(x) for x in 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()]
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
C = sorted(C, reverse=True)
ABC = []
for a in range(len(A)):
for b in range(len(B)):
if (a+1)*(b+1) > K:
break
for c in range(len(C)):
if (a+1)*(b+1)*(c+1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC = sorted(ABC, reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
import sys
import math
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
x,y,z,p = 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()
"""
if x*y*z <= 3*10**6:
abc = []
for i in range(x):
for j in range(y):
for k in range(z):
abc.append(a[i]+b[j]+c[k])
abc.sort()
abc = abc[::-1]
for i in range(p):
print(abc[i])
exit()
"""
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i]+b[j])
ab.sort()
c = c[::-1]
ab = ab[::-1]
ab.append(-2**62)
ans = []
miru = [0]*z
for i in range(z):
if i + 1 == z:
d = -2**60
else:
d = c[i+1]+ab[0]
for j in range(i+1):
flag = 0
while ab[miru[j]] + c[j] >= d and (len(ans)<= p or ab[miru[j]] + c[j] >= ans[0]):
ans.append(ab[miru[j]] + c[j])
miru[j]+=1
flag = 1
if flag and len(ans) >p:
ans.sort()
ans.sort()
ans = ans[::-1]
for i in range(p):
print((ans[i]))
|
import sys
import math
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
x,y,z,p = 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()
"""
if x*y*z <= 3*10**6:
abc = []
for i in range(x):
for j in range(y):
for k in range(z):
abc.append(a[i]+b[j]+c[k])
abc.sort()
abc = abc[::-1]
for i in range(p):
print(abc[i])
exit()
"""
ab = []
for i in range(x):
for j in range(y):
ab.append(a[i]+b[j])
ab.sort()
c = c[::-1]
ab = ab[::-1]
ab.append(-2**62)
ans = []
miru = [0]*z
for i in range(z):
if i + 1 == z:
d = -2**60
else:
d = c[i+1]+ab[0]
for j in range(i+1):
flag = 0
while ab[miru[j]] + c[j] >= d and (len(ans)<= p or ab[miru[j]] + c[j] >= ans[0]):
ans.append(ab[miru[j]] + c[j])
miru[j]+=1
flag = 1
if flag and len(ans) <=p+1:
ans.sort()
ans.sort()
ans = ans[::-1]
for i in range(p):
print((ans[i]))
|
p03078
|
def main():
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()))
AB = [a+b for a in A for b in B]
res = [c+ab for c in C for ab in AB]
res.sort(reverse = True)
print(("\n".join(list(map(str,res[:K])))))
if __name__ == "__main__":
main()
|
def main():
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)
AB = [a+b for a in A for b in B]
AB.sort(reverse = True)
res = [c+ab for ab in AB[:min(K, len(AB))] for c in C]
res.sort(reverse = True)
print(("\n".join(list(map(str,res[:K])))))
if __name__ == "__main__":
main()
|
p03078
|
def main():
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)
res = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1) <= K:
res.append(A[i]+B[j]+C[k])
res.sort(reverse = True)
for r in res[:K]:
print(r)
if __name__ == "__main__":
main()
|
def main():
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)
res = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1) <= K:
res.append(A[i]+B[j]+C[k])
else:
break
res.sort(reverse = True)
for r in res[:K]:
print(r)
if __name__ == "__main__":
main()
|
p03078
|
x,y,z,K = list(map(int,input().split()))
ans = 0
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()))
ans = 0
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(K//(i+1),y)):
for k in range(min(z,K//((i+1)*(j+1)))):
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]))
|
p03078
|
X,Y,Z,K = list(map(int, input().split()))
A_list = list(map(int, input().split()))
B_list = list(map(int, input().split()))
C_list = list(map(int, input().split()))
taste_list = []
for i in range(X):
for j in range(Y):
for k in range(Z):
taste_list.append(A_list[i]+B_list[j]+C_list[k])
taste_list.sort(reverse=True)
for i in range(K):
print((taste_list[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 a in A:
for b in B:
AB.append(a+b)
AB.sort(reverse=True)
AB = AB[:K]
ABC = []
for ab in AB:
for c in C:
ABC.append(ab+c)
ABC.sort(reverse=True)
for i in range(K):
print((ABC[i]))
|
p03078
|
from collections import defaultdict
inpl = lambda: list(map(int,input().split()))
X, Y, Z, K = inpl()
A = [ sorted(inpl(), key=lambda x: -x) for _ in range(3) ]
N = [X, Y, Z]
mem = defaultdict(int)
ans = sum([A[i][0] for i in range(3)])
mem[(0,0,0)] = 1
cand = [(ans,0,0,0)]
for i in range(K):
cand.sort()
c = cand[-1]
print((c[0]))
n = [c[1],c[2],c[3]]
cand.pop(-1)
for p in range(3):
if n[p] < N[p]-1:
n[p] += 1
if mem[(n[0],n[1],n[2])] == 0:
mem[(n[0],n[1],n[2])] = 1
cand.append((sum([A[j][n[j]] for j in range(3)]),n[0],n[1],n[2]))
n[p] -= 1
|
from collections import defaultdict
import heapq
inpl = lambda: list(map(int,input().split()))
X, Y, Z, K = inpl()
A = [ sorted(inpl(), reverse=True) for _ in range(3) ]
N = [X, Y, Z]
mem = defaultdict(int)
score = sum([A[i][0] for i in range(3)])
mem[(0,0,0)] = 1
candidates = []
heapq.heappush(candidates, (-score,(0,0,0)))
for i in range(K):
c = heapq.heappop(candidates)
print((-c[0]))
n = list(c[1])
for p in range(3):
if n[p] < N[p]-1:
n[p] += 1
if mem[tuple(n)] == 0:
mem[tuple(n)] = 1
score = sum([A[j][n[j]] for j in range(3)])
heapq.heappush(candidates, (-score,tuple(n)))
n[p] -= 1
|
p03078
|
import itertools
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()))
sum_list = []
for i in list(itertools.product(al, bl, cl)):
sum_list.append(sum(i))
sum_list.sort(reverse=True)
for i in sum_list[:k]:
print(i)
|
import itertools
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()))
sum_list = [sum(i) for i in itertools.product(al, bl, cl)]
sum_list.sort(reverse=True)
for i in sum_list[:k]:
print(i)
|
p03078
|
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(list(ax+bx for ax in a for bx in b), reverse=True)[:k[3]]
abc = sorted(list(aby+cy for aby in ab for cy in c), reverse=True)[:k[3]]
for i in abc: print(i)
|
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)[:k[3]]
B = sorted(b, reverse=True)[:k[3]]
C = sorted(c, reverse=True)[:k[3]]
ab = sorted(list(ax+bx for ax in A for bx in B), reverse=True)[:k[3]]
abc = sorted(list(aby+cy for aby in ab for cy in C), reverse=True)[:k[3]]
for i in abc: 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.sort(key=lambda x:-x)
b.sort(key=lambda x:-x)
c.sort(key=lambda x:-x)
sumAB=[0 for _ in range(x*y)]
index=0
imax=min(k,x)
jmax=min(k,y)
for i in range(imax):
for j in range(jmax):
sumAB[index]=a[i]+b[j]
index+=1
sumAB.sort(key=lambda x:-x)
beauty=[0 for _ in range(k*k)]
index=0
imax=min(k,x*y)
jmax=min(k,z)
for i in range(imax):
for j in range(jmax):
beauty[index]=sumAB[i]+c[j]
index+=1
beauty.sort(key=lambda x:-x)
for i in range(k):
print((beauty[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(key=lambda x:-x)
b.sort(key=lambda x:-x)
c.sort(key=lambda x:-x)
beauty=[]
index=0
for i in range(x):
for j in range(y):
for l in range(z):
if (i+1)*(j+1)*(l+1)<=k:
beauty.append(a[i]+b[j]+c[l])
else:
break
beauty.sort(key=lambda x:-x)
for i in range(k):
print((beauty[i]))
|
p03078
|
X,Y,Z,K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))[:K]
B = sorted(list(map(int, input().split())))[:K]
C = sorted(list(map(int, input().split())))[:K]
ab = sorted(list(a+b for a in A for b in B), reverse = True)[:K]
abc = sorted(list(ab+c for ab in ab for c in C), reverse = True)[:K]
for i in abc :
print(i)
|
X,Y,Z,K = list(map(int, input().split()))
A = sorted(list(map(int, input().split()))[:K])
B = sorted(list(map(int, input().split()))[:K])
C = sorted(list(map(int, input().split()))[:K])
ab = sorted(list(a+b for a in A for b in B), reverse = True)[:K]
abc = sorted(list(ab+c for ab in ab for c in C), reverse = True)[:K]
for i in abc :
print(i)
|
p03078
|
def main():
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(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ans = []
for i in range(x):
if i > k:
break
for j in range(y):
if i * j > k:
break
for m in range(z):
if i * j * m > k:
break
ans.append(a[i]+b[j]+c[m])
ans.sort(reverse=True)
for i in range(k):
print((ans[i]))
main()
|
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(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
ans=[]
for i in range(x):
if i > k:
break
for j in range(y):
if i*j > k:
break
for l in range(z):
if i*j*l > k:
break
ans.append(a[i]+b[j]+c[l])
ans.sort(reverse=True)
for i in range(k):
print((ans[i]))
|
p03078
|
X,Y,Z,K=[int(s) for s in input().split()]
xls=sorted([int(s) for s in input().split()],reverse=True)
yls=sorted([int(s) for s in input().split()],reverse=True)
zls=sorted([int(s) for s in input().split()],reverse=True)
xyls=[]
for x in xls[:K]:
for y in yls[:K]:
xyls.append(x+y)
xyls=sorted(xyls,reverse=True)
cake=[]
for xy in xyls[:K]:
for z in zls[:K]:
cake.append(xy+z)
cake=sorted(cake,reverse=True)
for i in range(K):
print((cake[i]))
|
X,Y,Z,K=[int(s) for s in input().split()]
xls=sorted([int(s) for s in input().split()],reverse=True)
yls=sorted([int(s) for s in input().split()],reverse=True)
zls=sorted([int(s) for s in input().split()],reverse=True)
cake=[]
for a in range(X):
for b in range(Y):
ab=(a+1)*(b+1)
for c in range(Z):
if ab*(c+1)>K:
break
cake.append(xls[a]+yls[b]+zls[c])
if ab>K:
break
cake=sorted(cake,reverse=True)
for i in range(K):
print((cake[i]))
|
p03078
|
import sys
from bisect import bisect_left,bisect_right,insort
input = sys.stdin.readline
def main():
x,y,z,K=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
b=sorted(list(map(int,input().split())))
c=sorted(list(map(int,input().split())))
l,r=a[0]+b[0]+c[0],a[-1]+b[-1]+c[-1]
while l+1<r:
ans=0
m=(l+r)//2
for i in range(x-1,-1,-1):
if a[i]>=m:
ans+=y*z
continue
for j in range(y-1,-1,-1):
if a[i]+b[j]>=m:
ans+=z
continue
for k in range(z-1,-1,-1):
if a[i]+b[j]+c[k]>=m:
ans+=1
continue
else:
break
if ans>=K:
l=m
else:
r=m
s=[0]
for i in range(x-1,-1,-1):
for j in range(y-1,-1,-1):
for k in range(z-1,-1,-1):
if a[i]+b[j]+c[k]>=l:
s.append(a[i]+b[j]+c[k])
continue
else:
break
s.sort()
for i in range(len(s)-1,0,-1):
print((s[i]))
if __name__ == '__main__':
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()))
AB = [a + b for a in A for b in B]
AB.sort(reverse=True)
AB = AB[:k]
ABC = [ab + c for ab in AB for c in C]
ABC.sort(reverse=True)
ABC = ABC[:k]
print(('\n'.join(map(str, ABC))))
|
p03078
|
import itertools
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 = sorted(A)[::-1][:K]
B = sorted(B)[::-1][:K]
C = sorted(C)[::-1][:K]
T = [A, B]
score = []
for cand in itertools.product(*T):
score.append(sum(cand))
T = [sorted(score)[::-1][:K], C]
res = []
for cand in itertools.product(*T):
res.append(sum(cand))
res = sorted(res)[::-1][:K]
for i in range(K):
print((res[i]))
|
import itertools
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(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
D = [a+b for a,b in itertools.product(A[:K], B[:K])]
D.sort(reverse=True)
E = [c+d for c,d in itertools.product(C[:K], D[:K])]
E.sort(reverse=True)
for i in range(K):
print((E[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 i in range(len(A)):
for j in range(len(B)):
L.append(A[i] + B[j])
L.sort(reverse=True)
ans_list = [0] * (10000000)
for i in range(min(K,len(L))):
for j in range(len(C)):
ans_list.append(L[i] + C[j])
ans_list.sort(reverse=True)
for i in range(K):
print((ans_list[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()
b.sort()
c.sort()
bc = [0] * (y * z)
q = 0
for i in range(y):
for j in range(z):
bc[q] = b[i] + c[j]
q += 1
bc.sort(reverse=True)
r = len(bc)
bc = bc[:min(k, r)]
abc = [0] * (x * min(k, r))
q = 0
for i in range(min(k, r)):
for j in range(x):
abc[q] = bc[i] + a[j]
q += 1
abc.sort(reverse=True)
for i in range(min(k, x*y*z)):
print((abc[i]))
|
p03078
|
import heapq
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(" ")]
AB=[]
for a in A:
for b in B:
AB.append(a+b)
AB=heapq.nlargest(K,AB)
ABC=[]
for ab in AB:
for c in C:
ABC.append(ab+c)
for cake in heapq.nlargest(K,ABC):
print(cake)
|
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(" ")]
AB=[]
A=sorted(A,reverse=True)[:K:]
B=sorted(B,reverse=True)[:K:]
C=sorted(C,reverse=True)[:K:]
for a in A:
for b in B:
AB.append(a+b)
AB=sorted(AB,reverse=True)[:K:]
ABC=[]
for ab in AB:
for c in C:
ABC.append(ab+c)
ABC=sorted(ABC,reverse=True)[:K:]
for abc in ABC:
print(abc)
|
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)
c.sort(reverse=True)
l.sort(reverse=True)
l2 = []
for i in c:
for j in l:
l2.append(i + j)
l2.sort(reverse=True)
print(*l2[:k], 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()))
l = []
for i in a:
for j in b:
l.append(i + j)
c.sort(reverse=True)
l.sort(reverse=True)
l = l[:k]
l2 = []
for i in c:
for j in l:
l2.append(i + j)
l2.sort(reverse=True)
print(*l2[:k], sep="\n")
|
p03078
|
X,Y,Z,K = [int(x) for x in 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()
B.sort()
C.sort()
A.reverse()
B.reverse()
C.reverse()
li=[]
inf = 10**11
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):
li.append(A[i]+B[j]+C[k])
li.sort()
li.reverse()
for i in li[:K]:
print(i)
|
X,Y,Z,K = [int(x) for x in 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()
B.sort()
C.sort()
A.reverse()
B.reverse()
C.reverse()
li=[]
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):
li.append(A[i]+B[j]+C[k])
li.sort()
li.reverse()
for i in li[:K]:
print(i)
|
p03078
|
from heapq import heapify,heappop,heappush
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)
que=[[-(A[0]+B[0]+C[0]),0,0,0]];heapify(que)
Count=[[[0]*(Z+1) for i in range(Y+1)] for j in range(X+1)]
for i in range(K):
p=heappop(que)
print((-p[0]))
if p[1]<X-1 and Count[p[1]+1][p[2]][p[3]]==0:
heappush(que,[-sum([A[p[1]+1],B[p[2]],C[p[3]]]),p[1]+1,p[2],p[3]])
Count[p[1]+1][p[2]][p[3]]+=1
if p[2]<Y-1 and Count[p[1]][p[2]+1][p[3]]==0:
heappush(que,[-sum([A[p[1]],B[p[2]+1],C[p[3]]]),p[1],p[2]+1,p[3]])
Count[p[1]][p[2]+1][p[3]]+=1
if p[3]<Z-1 and Count[p[1]][p[2]][p[3]+1]==0:
heappush(que,[-sum([A[p[1]],B[p[2]],C[p[3]+1]]),p[1],p[2],p[3]+1])
Count[p[1]][p[2]][p[3]+1]+=1
|
from heapq import heapify,heappop,heappush
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)
que=[[-(A[0]+B[0]+C[0]),0,0,0]];heapify(que)
s=set()
for i in range(K):
p=heappop(que)
print((-p[0]))
if p[1]<X-1 and not (p[1]+1,p[2],p[3]) in s:
heappush(que,[-sum([A[p[1]+1],B[p[2]],C[p[3]]]),p[1]+1,p[2],p[3]])
s.add((p[1]+1,p[2],p[3]))
if p[2]<Y-1 and not (p[1],p[2]+1,p[3]) in s:
heappush(que,[-sum([A[p[1]],B[p[2]+1],C[p[3]]]),p[1],p[2]+1,p[3]])
s.add((p[1],p[2]+1,p[3]))
if p[3]<Z-1 and not (p[1],p[2],p[3]+1) in s:
heappush(que,[-sum([A[p[1]],B[p[2]],C[p[3]+1]]),p[1],p[2],p[3]+1])
s.add((p[1],p[2],p[3]+1))
|
p03078
|
from itertools import groupby
from operator import itemgetter
x,y,z,k = (int(x) for x in 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()]
# key, group
ga0 = [{'val':key, 'cnt':len(list(group))} for key, group in groupby(a)]
ga = list(reversed(sorted(ga0, key=itemgetter('val'))))
gb = list(reversed(sorted([{'val':key, 'cnt':len(list(group))} for key, group in groupby(b)], key=itemgetter('val'))))
gc = list(reversed(sorted([{'val':key, 'cnt':len(list(group))} for key, group in groupby(c)], key=itemgetter('val'))))
lga, lgb = len(ga), len(gb)
ia,ib = 0,0
ca,cb = ga[0]['cnt'],gb[0]['cnt']
while ca*cb < k:
if ia == lga-1 and ib == lgb-1:
break
elif ia == lga-1:
ib += 1
cb += gb[ib]['cnt']
elif ib == lgb-1:
ia += 1
ca += ga[ia]['cnt']
elif ga[ia+1]['val'] + gb[ib]['val'] >= ga[ia]['val'] + gb[ib+1]['val']:
ia += 1
ca += ga[ia]['cnt']
else:
ib += 1
cb += gb[ib]['cnt']
d = []
for va in ga:
for vb in gb:
d.append((va['val']+vb['val'],va['cnt']*vb['cnt']))
gd0 = [{'val':key, 'cnt':sum(c_ for _, c_ in list(group))} for key, group in groupby(d,itemgetter(0))]
gd = list(reversed(sorted(gd0, key=itemgetter('val'))))[:k]
lgc, lgd = len(gc), len(gd)
ic,id = 0,0
cc,cd = gc[0]['cnt'],gd[0]['cnt']
while cc*cd < k:
if ic == lgc-1 and id == lgd-1:
break
elif ic == lgc-1:
id += 1
cd += gd[id]['cnt']
elif id == lgd-1:
ic += 1
cc += gc[ic]['cnt']
elif gc[ic+1]['val'] + gd[id]['val'] >= gc[ic]['val'] + gd[id+1]['val']:
ic += 1
cc += gc[ic]['cnt']
else:
id += 1
cd += gd[id]['cnt']
r = []
for vc in gc:
for vd in gd:
r.append((vc['val']+vd['val'],vc['cnt']*vd['cnt']))
gr0 = [{'val':key, 'cnt':sum(c_ for _, c_ in list(group))} for key, group in groupby(r,itemgetter(0))]
gr = list(reversed(sorted(gr0, key=itemgetter('val'))))[:k]
i = 0
for vr in gr:
for j in range(vr['cnt']):
print((vr['val']))
i += 1
if i == k:
exit
|
import heapq
x,y,z,k = (int(x) for x in 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)
# heap
h = []
g = set()
heapq.heappush(h, (-(a[0]+b[0]+c[0]),0,0,0))
for i in range(k):
q,ia,ib,ic = heapq.heappop(h)
print((-q))
ja,jb,jc = ia+1,ib,ic
if ja<x and (ja,jb,jc) not in g:
heapq.heappush(h, (-(a[ja]+b[jb]+c[jc]),ja,jb,jc))
g.add((ja,jb,jc))
ja,jb,jc = ia,ib+1,ic
if jb<y and (ja,jb,jc) not in g:
heapq.heappush(h, (-(a[ja]+b[jb]+c[jc]),ja,jb,jc))
g.add((ja,jb,jc))
ja,jb,jc = ia,ib,ic+1
if jc<z and (ja,jb,jc) not in g:
heapq.heappush(h, (-(a[ja]+b[jb]+c[jc]),ja,jb,jc))
g.add((ja,jb,jc))
|
p03078
|
import sys
import heapq
input = sys.stdin.readline
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list([-int(x) for x in input().split()])
B = list([-int(x) for x in input().split()])
C = list([-int(x) for x in input().split()])
A.sort()
B.sort()
C.sort()
p_queue = [(A[0] + B[0] + C[0], 0, 0, 0)]
appear = [[[False for _ in range(Z)] for _ in range(Y)] for _ in range(X)]
appear[0][0][0] = True
ans = []
while len(ans) < K:
s, i_A, i_B, i_C = heapq.heappop(p_queue)
ans.append(-s)
if i_A < X - 1 and not appear[i_A + 1][i_B][i_C]:
appear[i_A + 1][i_B][i_C] = True
t = s - A[i_A] + A[i_A + 1]
heapq.heappush(p_queue, (t, i_A + 1, i_B, i_C))
if i_B < Y - 1 and not appear[i_A][i_B + 1][i_C]:
appear[i_A][i_B + 1][i_C] = True
t = s - B[i_B] + B[i_B + 1]
heapq.heappush(p_queue, (t, i_A, i_B + 1, i_C))
if i_C < Z - 1 and not appear[i_A][i_B][i_C + 1]:
appear[i_A][i_B][i_C + 1] = True
t = s - C[i_C] + C[i_C + 1]
heapq.heappush(p_queue, (t, i_A, i_B, i_C + 1))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
|
import sys
import heapq
input = sys.stdin.readline
def main():
X, Y, Z, K = list(map(int, input().split()))
A = list([-int(x) for x in input().split()])
B = list([-int(x) for x in input().split()])
C = list([-int(x) for x in input().split()])
A.sort()
B.sort()
C.sort()
p_queue = [(A[0] + B[0] + C[0], 0, 0, 0)]
visited = set()
visited.add((0, 0, 0))
ans = []
while len(ans) < K:
s, i_A, i_B, i_C = heapq.heappop(p_queue)
ans.append(-s)
if i_A < X - 1 and (i_A + 1, i_B, i_C) not in visited:
visited.add((i_A + 1, i_B, i_C))
t = s - A[i_A] + A[i_A + 1]
heapq.heappush(p_queue, (t, i_A + 1, i_B, i_C))
if i_B < Y - 1 and (i_A, i_B + 1, i_C) not in visited:
visited.add((i_A, i_B + 1, i_C))
t = s - B[i_B] + B[i_B + 1]
heapq.heappush(p_queue, (t, i_A, i_B + 1, i_C))
if i_C < Z - 1 and (i_A, i_B, i_C + 1) not in visited:
visited.add((i_A, i_B, i_C + 1))
t = s - C[i_C] + C[i_C + 1]
heapq.heappush(p_queue, (t, i_A, i_B, i_C + 1))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
|
p03078
|
import sys
readline = sys.stdin.readline
X,Y,Z,K = list(map(int,readline().split()))
A = sorted(list(map(int,readline().split())),reverse = True)
B = sorted(list(map(int,readline().split())),reverse = True)
C = sorted(list(map(int,readline().split())),reverse = True)
# AとBを組み合わせたケーキの上位K位を作る
AB = []
for a in range(len(A)):
for b in range(len(B)):
AB += [A[a] + B[b]]
AB = sorted(AB,reverse = True)[:K]
# ABとCを組み合わせたケーキの上位K位を作る
ans = []
for ab in range(len(AB)):
for c in range(len(C)):
ans += [AB[ab] + C[c]]
ans = sorted(ans,reverse = True)[:K]
for a in ans:
print(a)
|
import sys
readline = sys.stdin.readline
X,Y,Z,K = map(int,readline().split())
A = sorted(list(map(int,readline().split())),reverse = True)
B = sorted(list(map(int,readline().split())),reverse = True)
C = sorted(list(map(int,readline().split())),reverse = True)
ans = []
for a in range(len(A)):
for b in range(len(B)):
for c in range(len(C)):
if (a + 1) * (b + 1) * (c + 1) > K:
break
ans += [A[a] + B[b] + C[c]]
ans = sorted(ans,reverse = True)[:K]
print(*ans,sep = "\n")
|
p03078
|
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)
AB=[]
for a in A:
for b in B:
AB.append(a+b)
ABC=[]
for ab in sorted(AB, reverse=True)[:K]:
for c in C:
ABC.append(ab+c)
for abc in sorted(ABC, reverse=True)[:K]:
print(abc)
|
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 a in A:
for b in B:
AB.append(a+b)
ABC=[]
for ab in sorted(AB, reverse=True)[:K]:
for c in C:
ABC.append(ab+c)
for abc in sorted(ABC, reverse=True)[:K]:
print(abc)
|
p03078
|
import itertools
X, Y, Z, K = [int(x) for x in 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()]
list_ = [a+b+c for (a,b,c) in itertools.product(A, B, C)]
list_.sort(reverse=True)
for N in list_[:K]:
print(N)
|
import itertools
X, Y, Z, K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort(reverse=True)
B = [int(x) for x in input().split()]
B.sort(reverse=True)
C = [int(x) for x in input().split()]
C.sort(reverse=True)
list_ = [b+c for (b,c) in itertools.product(B, C)]
list_.sort(reverse=True)
list__ = [ab+c for (ab,c) in itertools.product(list_[:K], A)]
list__.sort(reverse=True)
for N in list__[:K]:
print(N)
|
p03078
|
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(X, Y, Z, K, As, Bs, Cs):
ABs = []
for A in As:
for B in Bs:
ABs.append(A + B)
ABs.sort(reverse=True)
ABCs = []
for i in range(min(X * Y, K)):
AB = ABs[i]
for C in Cs:
ABCs.append(AB + C)
ABCs.sort(reverse=True)
for i in range(K):
print((ABCs[i]))
if __name__ == '__main__':
# S = input()
# N = int(input())
X, Y, Z, K = list(map(int, input().split()))
As = [int(i) for i in input().split()]
Bs = [int(i) for i in input().split()]
Cs = [int(i) for i in input().split()]
# import random
# X, Y, Z, K = 1000,1000,1000,3000
# As = [random.randint(1, 10 ** 10) for _ in range(X)]
# Bs = [random.randint(1, 10 ** 10) for _ in range(Y)]
# Cs = [random.randint(1, 10 ** 10) for _ in range(Z)]
solve(X, Y, Z, K, As, Bs, Cs)
|
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(X, Y, Z, K, As, Bs, Cs):
ABs = []
for A in As:
for B in Bs:
ABs.append(A + B)
ABs.sort(reverse=True)
ABCs = []
for i in range(min(X * Y, K)):
AB = ABs[i]
for C in Cs:
ABCs.append(AB + C)
ABCs.sort(reverse=True)
for i in range(K):
print((ABCs[i]))
if __name__ == '__main__':
# S = input()
# N = int(input())
X, Y, Z, K = list(map(int, input().split()))
As = [int(i) for i in input().split()]
Bs = [int(i) for i in input().split()]
Cs = [int(i) for i in input().split()]
# import random
# X, Y, Z, K = 1000,1000,1000,3000
# As = [random.randint(1, 10 ** 10) for _ in range(X)]
# Bs = [random.randint(1, 10 ** 10) for _ in range(Y)]
# Cs = [random.randint(1, 10 ** 10) for _ in range(Z)]
solve(X, Y, Z, K, As, Bs, Cs)
|
p03078
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
X, Y, Z, K = list(map(int, input().split(" ")))
As = []
Bs = []
Cs = []
As = input().split()
As = [int(s) for s in As]
Bs = input().split()
Bs = [int(s) for s in Bs]
Cs = input().split()
Cs = [int(s) for s in Cs]
As.sort(reverse=True)
Bs.sort(reverse=True)
Cs.sort(reverse=True)
As = As[:K]
Bs = Bs[:K]
Cs = Cs[:K]
ans = []
for i, val in enumerate(As):
for j, vol in enumerate(Bs):
for k, ogi in enumerate(Cs):
ans.append(val+vol+ogi)
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
X, Y, Z, K = list(map(int, input().split(" ")))
As = []
Bs = []
Cs = []
As = input().split()
As = [int(s) for s in As]
Bs = input().split()
Bs = [int(s) for s in Bs]
Cs = input().split()
Cs = [int(s) for s in Cs]
As.sort(reverse=True)
Bs.sort(reverse=True)
Cs.sort(reverse=True)
ans1 = []
for i, val in enumerate(As):
for j, vol in enumerate(Bs):
ans1.append(val+vol)
ans1.sort(reverse=True)
ans1 = ans1[:3000]
ans2 = []
for i, val in enumerate(ans1):
for j, vol in enumerate(Cs):
ans2.append(val+vol)
ans2.sort(reverse=True)
for i in range(K):
print((ans2[i]))
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()))
D = []
E = []
for i in range(x):
for j in range(y):
D.append(A[i]+B[j])
for i in range(z):
for j in range(len(D)):
E.append(C[i]+D[j])
print(("\n".join(map(str,sorted(E)[::-1][:k]))))
|
x, y, z, k = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list((list(map(int,input().split()))))
D = []
E = []
for i in range(x):
for j in range(y):
D.append(A[i]+B[j])
D.sort()
for i in range(z):
for j in range(min(len(D),k)):
E.append(C[i]+D[::-1][j])
print(("\n".join(map(str,sorted(E)[::-1][:k]))))
|
p03078
|
x, y, z, k = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list((list(map(int,input().split()))))
D = []
E = []
for i in range(x):
for j in range(y):
D.append(A[i]+B[j])
D = sorted(D,reverse=True)[:k]
for j in range(len(D)):
for i in range(z):
E.append(C[i]+D[j])
E = sorted(E, reverse=True)
for i in range(k):
print((E[i]))
|
x, y, z, k = [int(n) for n in input().split()]
va = sorted([int(n) for n in input().split()], reverse=True)
vb = sorted([int(n) for n in input().split()], reverse=True)
xy = min(x*y, k)
vab = (sorted([a + b for a in va for b in vb], reverse=True))[:xy]
vc = sorted([int(n) for n in input().split()], reverse=True)
xyz = min(x*y*z, k)
print(*((sorted([ab + c for ab in vab for c in vc], reverse=True))[:xyz]), sep="\n")
|
p03078
|
def MergeSort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]
left = MergeSort(left)
right = MergeSort(right)
return MergeArray(left, right)
def MergeArray(left, right):
merged = []
li, ri = 0, 0
while li < len(left) and ri < len(right):
if left[li] > right[ri]:
merged.append(left[li])
li += 1
else:
merged.append(right[ri])
ri += 1
if li < len(left):
merged.extend(left[li:])
elif ri < len(right):
merged.extend(right[ri:])
return merged
def solve():
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()]
A = MergeSort(A)[:K]
B = MergeSort(B)[:K]
C = MergeSort(C)[:K]
lB = len(B)
lC = len(C)
sumAB = []
for i in range(lB):
tmpA = [ele + B[i] for ele in A]
sumAB = MergeArray(sumAB, tmpA)
sumABC = []
for i in range(lC):
tmpAB = [ele + C[i] for ele in sumAB]
sumABC = MergeArray(sumABC, tmpAB)
for i in range(K):
print(sumABC[i])
if __name__ == '__main__':
solve()
|
def MergeSort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]
left = MergeSort(left)
right = MergeSort(right)
return MergeArray(left, right)
def MergeArray(left, right):
merged = []
li, ri = 0, 0
while li < len(left) and ri < len(right):
if left[li] > right[ri]:
merged.append(left[li])
li += 1
else:
merged.append(right[ri])
ri += 1
if li < len(left):
merged.extend(left[li:])
elif ri < len(right):
merged.extend(right[ri:])
return merged
def solve():
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()]
A = MergeSort(A)[:K]
B = MergeSort(B)[:K]
C = MergeSort(C)[:K]
lB = len(B)
lC = len(C)
sumAB = []
for i in range(lB):
tmpA = [ele + B[i] for ele in A]
sumAB = MergeArray(sumAB, tmpA)[:K]
sumABC = []
for i in range(lC):
tmpAB = [ele + C[i] for ele in sumAB]
sumABC = MergeArray(sumABC, tmpAB)[:K]
for i in range(K):
print(sumABC[i])
if __name__ == '__main__':
solve()
|
p03078
|
def get_input():
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()]
return X, Y, Z, K, A, B, C
def solve():
X, Y, Z, K, A, B, C = get_input()
A = MergeSort(A)[:K]
B = MergeSort(B)[:K]
C = MergeSort(C)[:K]
lB = len(B)
lC = len(C)
sumAB = []
for i in range(lB):
tmpA = [ele + B[i] for ele in A]
sumAB = MergeArray(sumAB, tmpA)[:K]
sumABC = []
for i in range(lC):
tmpAB = [ele + C[i] for ele in sumAB]
sumABC = MergeArray(sumABC, tmpAB)[:K]
for i in range(K):
print(sumABC[i])
def solve2():
X, Y, Z, K, A, B, C = get_input()
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
sumABC = []
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i + 1) * (j + 1) * (k + 1) <= K:
sumABC.append(A[i] + B[j] + C[k])
sumABC.sort(reverse = True)
for i in range(K):
print(sumABC[i])
if __name__ == '__main__':
solve2()
|
def get_input():
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()]
return X, Y, Z, K, A, B, C
def AddToQueue(_ele, _queue, _ijk_set, K):
if len(_queue) == 0:
_queue.append(_ele)
else:
cnt = 0
while cnt < len(_queue) and _queue[cnt][0] >= _ele[0]:
cnt += 1
ijk = (_ele[1], _ele[2], _ele[3])
if not (ijk in _ijk_set):
_queue.insert(cnt, _ele)
_ijk_set.add(ijk)
_queue = _queue[:K]
def solve3():
X, Y, Z, K, A, B, C = get_input()
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
ijk_set = set()
queue = [(A[0] + B[0] + C[0], 0, 0, 0)]
ijk_set.add((0, 0, 0))
for cnt in range(K):
ele, i, j, k = queue.pop(0)
print(ele)
if i + 1 < X:
AddToQueue((A[i+1] + B[j] + C[k], i+1, j, k), queue, ijk_set, K)
if j + 1 < Y:
AddToQueue((A[i] + B[j+1] + C[k], i, j+1, k), queue, ijk_set, K)
if k + 1 < Z:
AddToQueue((A[i] + B[j] + C[k+1], i, j, k+1), queue, ijk_set, K)
if __name__ == '__main__':
solve3()
|
p03078
|
def get_input():
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()]
return X, Y, Z, K, A, B, C
def AddToQueue(_ele, _queue, _ijk_set, K):
if len(_queue) == 0:
_queue.append(_ele)
else:
cnt = 0
while cnt < len(_queue) and _queue[cnt][0] >= _ele[0]:
cnt += 1
ijk = (_ele[1], _ele[2], _ele[3])
if not (ijk in _ijk_set):
_queue.insert(cnt, _ele)
_ijk_set.add(ijk)
_queue = _queue[:K]
def solve3():
X, Y, Z, K, A, B, C = get_input()
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
ijk_set = set()
queue = [(A[0] + B[0] + C[0], 0, 0, 0)]
ijk_set.add((0, 0, 0))
for cnt in range(K):
ele, i, j, k = queue.pop(0)
print(ele)
if i + 1 < X:
AddToQueue((A[i+1] + B[j] + C[k], i+1, j, k), queue, ijk_set, K)
if j + 1 < Y:
AddToQueue((A[i] + B[j+1] + C[k], i, j+1, k), queue, ijk_set, K)
if k + 1 < Z:
AddToQueue((A[i] + B[j] + C[k+1], i, j, k+1), queue, ijk_set, K)
if __name__ == '__main__':
solve3()
|
def get_input():
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()]
return X, Y, Z, K, A, B, C
def solve2():
X, Y, Z, K, A, B, C = get_input()
A.sort(reverse = True)
B.sort(reverse = True)
C.sort(reverse = True)
sumABC = []
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
sumABC.append(A[i] + B[j] + C[k])
sumABC.sort(reverse = True)
for i in range(K):
print(sumABC[i])
if __name__ == '__main__':
solve2()
|
p03078
|
k = [int(i) for i in 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()
y.sort()
z.sort()
e = []
for i in x:
for j in y:
e.append(i+j)
e.sort()
f = []
for i in e:
for j in z:
f.append(i+j)
f.sort()
f.reverse()
for i in range(k[3]):
print((f[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)
SUM=[]
for i in range(X):
for j in range(Y):
for k in range(Z):
if (i+1)*(j+1)*(k+1)<=K:
SUM.append(A[i]+B[j]+C[k])
else:
break
SUM.sort(reverse=True)
for i in range(K):
print((SUM[i]))
|
p03078
|
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()))
l1=sorted([i+j for i in a for j in b],reverse=True)[:k]
l2=sorted([i+j for i in l1 for j in c],reverse=True)[:k]
for i in l2:
print(i)
|
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)
l1=sorted([i+j for i in a for j in b],reverse=True)[:k]
l2=sorted([i+j for i in l1 for j in c],reverse=True)[:k]
for i in l2:
print(i)
|
p03078
|
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)
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, 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]))
|
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)
ABC = []
for a in range(X):
for b in range(Y):
if (a + 1) * (b + 1) > K:
break
for c in range(Z):
if (a + 1) * (b + 1) * (c + 1) > K:
break
ABC.append(A[a] + B[b] + C[c])
ABC.sort(reverse=True)
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()))
Al = sorted(A,reverse=True)[:K]
Bl = sorted(B,reverse=True)[:K]
Cl = sorted(C,reverse=True)[:K]
result = []
for a in Al:
for b in Bl:
for c in Cl:
result.append(a+b+c)
result.sort(reverse=True)
for i in range(K):
print((result[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()))
Al = sorted(A,reverse=True)[:K]
Bl = sorted(B,reverse=True)[:K]
Cl = sorted(C,reverse=True)[:K]
ABl = []
for a in Al:
for b in Bl:
ABl.append(a+b)
result = []
ABl = sorted(ABl,reverse=True)[:K]
for ab in ABl:
for c in Cl:
result.append(ab+c)
result.sort(reverse=True)
for i in range(K):
print((result[i]))
|
p03078
|
X,Y,Z,K = list(map(int,input().split()))
list_a = list(map(int,input().split()))
list_b = list(map(int,input().split()))
list_c = list(map(int,input().split()))
list_a.sort(reverse=True)
list_b.sort(reverse=True)
list_c.sort(reverse=True)
list = []
for la in list_a:
for lb in list_b:
list.append([la,lb,la+lb])
list.sort(key=lambda x:x[2],reverse=True)
list2 = []
for a,b,n in list:
for lc in list_c:
list2.append(n+lc)
list2.sort(reverse=True)
cnt = 0
for i in list2:
print(i)
cnt += 1
if cnt == K:
exit()
|
X,Y,Z,K = list(map(int,input().split()))
list_a = list(map(int,input().split()))
list_b = list(map(int,input().split()))
list_c = list(map(int,input().split()))
list_a.sort(reverse=True)
list_b.sort(reverse=True)
list_c.sort(reverse=True)
sum_ = []
for a in range(X):
for b in range(Y):
for c in range(Z):
if (a+1)*(b+1)*(c+1) > K:
break
sum_.append(list_a[a]+list_b[b]+list_c[c])
sum_.sort(reverse=True)
for i in range(K):
print((sum_[i]))
|
p03078
|
import itertools
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()]
D = []
for a, b in itertools.product(A, B):
d = a + b
D.append(d)
D.sort(reverse = True)
E = []
for c, d in itertools.product(C, D[:K]):
e = c + d
E.append(e)
E.sort(reverse = True)
for e in E[:K]:
print(e)
|
X, Y, Z, K = list(map(int, input().split()))
A = sorted([int(i) for i in input().split()], reverse = True)
B = sorted([int(i) for i in input().split()], reverse = True)
C = sorted([int(i) for i in input().split()], reverse = True)
D = []
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
D.append(A[i] + B[j] + C[k])
#print(A[i] + B[j] + C[k], i, j, k)
D.sort(reverse = True)
for d in D[:K]:
print(d)
|
p03078
|
x,y,z,k=list(map(int,input().split()))
a=sorted([int(i) for i in input().split()],reverse=True)
b=sorted([int(i) for i in input().split()],reverse=True)
c=sorted([int(i) for i in input().split()],reverse=True)
ab=[a[i]+b[j] for j in range(y) for i in range(x)]
ab.sort(reverse=True)
ab=ab[:k]
l=len(ab)
abc=[ab[i]+c[j] for j in range(z) for i in range(l)]
abc.sort(reverse=True)
for i in range(k):
print((abc[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()
b.sort()
c.sort()
ab=[a[i]+b[j] for j in range(y) for i in range(x)]
ab.sort(reverse=True)
ab=ab[:k]
l=len(ab)
abc=[ab[i]+c[j] for j in range(z) for i in range(l)]
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
p03078
|
#AC済み
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()
b.sort()
c.sort()
ab=[-a[i]-b[j] for j in range(y) for i in range(x)]
ab.sort()
ab=ab[:k]
l=len(ab)
abc=[ab[i]-c[j] for j in range(z) for i in range(l)]
abc.sort()
for i in range(k):
print((-abc[i]))
|
#AC済み
x,y,z,k=list(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()
b.sort()
c.sort()
ab=[a[i]+b[j] for j in range(y) for i in range(x)]
ab.sort(reverse=True)
ab=ab[:k]
l=len(ab)
abc=[ab[i]+c[j] for j in range(z) for i in range(l)]
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
p03078
|
#AC済み
x,y,z,k=list(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()])
ab=[a[i]+b[j] for j in range(y) for i in range(x)]
ab.sort(reverse=True)
ab=ab[:k]
l=len(ab)
abc=[ab[i]+c[j] for j in range(z) for i in range(l)]
abc.sort(reverse=True)
for i in range(k):
print((abc[i]))
|
#AC済み
x,y,z,k=list(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()])
ab=sorted([a[i]+b[j] for j in range(y) for i in range(x)],reverse=True)
ab=ab[:k]
l=len(ab)
abc=sorted([ab[i]+c[j] for j in range(z) for i in range(l)],reverse=True)
for i in range(k):
print((abc[i]))
|
p03078
|
import itertools
X, Y, Z, K = list(map(int, input().rstrip().split()))
A = list(map(int, input().rstrip().split()))
B = list(map(int, input().rstrip().split()))
C = list(map(int, input().rstrip().split()))
A.sort()
B.sort()
C.sort()
combinations = list(itertools.product(A, B, C))
total = []
for combination in combinations:
total.append(sum(combination))
total.sort(reverse=True)
for i in range(K):
print((total[i]))
|
import itertools
X, Y, Z, K = list(map(int, input().rstrip().split()))
A = list(map(int, input().rstrip().split()))
B = list(map(int, input().rstrip().split()))
C = list(map(int, input().rstrip().split()))
A.sort()
B.sort()
C.sort()
if X*Y*Z != K:
if X >= 200:
A = A[:200]
if Y >= 200:
B = B[:200]
if Z >= 200:
C = C[:200]
combinations = list(itertools.product(A, B, C))
total = []
for combination in combinations:
total.append(sum(combination))
total.sort(reverse=True)
for i in range(K):
print((total[i]))
|
p03078
|
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()))
used = [[[False] * (z + 1) for _ in range(y + 1)] for _ in range(x + 1)]
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
kouho = [(-(A[0] + B[0] + C[0]), 0, 0, 0)]
def calc(a, b, c):
if not used[a][b][c]:
used[a][b][c] = True
heappush(kouho, ((-A[a] - B[b] - C[c]), a, b, c))
used[0][0][0] = True
for i in range(k):
temp, p, q, r = heappop(kouho)
temp *= -1
print(temp)
if p + 1 < x:
calc(p + 1, q, r)
if q + 1 < y:
calc(p, q + 1, r)
if r + 1 < z:
calc(p, q, r + 1)
|
# pypyでギリ。
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
x, y, z, k = map(int, readline().split())
A = list(map(int, readline().split()))
B = list(map(int, readline().split()))
C = list(map(int, readline().split()))
goukei = []
for a in A:
for b in B:
goukei.append(a + b)
goukei.sort()
goukei2 = goukei[-k:]
goukei3 = []
for c in C:
for ab in goukei2:
goukei3.append(ab + c)
goukei3.sort(reverse=True)
print(*goukei3[: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()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
tmp=[]
for i in range(x):
for j in range(y):
tmp.append(a[i]+b[j])
tmp.sort(reverse=True)
ans=[]
for i in tmp[:3000]:
for j in range(z):
ans.append(i+c[j])
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(y):
if (i+1)*(j+1)>K:
break
for k in range(z):
if (i+1)*(j+1)*(k+1)>K:
break
ans.append(a[i]+b[j]+c[k])
ans.sort(reverse=True)
for i in range(K):
print((ans[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()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
l=[]
stat=int(math.sqrt(10**7//X))
for i in range(X):
for j in range(min(stat,Y)):
for k in range(min(stat,Z)):
l.append(A[i] + B[j] + C[k])
end1=stat
stat2=int(math.sqrt(10**7//Y))
for i in range(min(stat,X),min(stat+stat2,X)):
for j in range(Y):
for k in range(min(stat,Z),min(stat+stat2,Z)):
l.append(A[i] + B[j] + C[k])
end2=stat+stat2
stat3=int(math.sqrt(10**7//Z))
for i in range(min(stat+stat2,X),min(stat+stat2+stat3,X)):
for j in range(min(stat+stat2,Y),min(stat+stat2+stat3,Y)):
for k in range(Z):
l.append(A[i] + B[j] + C[k])
l.sort(reverse=True)
#print(l)
for i in range(K):
print((l[i]))
|
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()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
l=[]
#まずX+Yを求め、上から順にソート
#10^6相当の計算
for i in range(X):
for j in range(Y):
l.append(A[i] + B[j])
l.sort(reverse=True)
ans=[]
#(X+Y)+Zより、全体の上位を求めるが、Zが何であれ、X+Yの和が上からK番目以下のものは考慮しなくて良い
#(X+YにおいてK+i番目のもの(X+Y)_K+i+Zjが全体でK番以内に食い込めるということは、1~K番目のX+Yにて(X+Y)_1~K+Zj>(X+Y)_K+i+Zjが成立することと矛盾する)
#これで高々10^7相当までのソートでよくなる
for i in range(min(K,len(l))):
for j in range(Z):
ans.append(l[i]+C[j])
ans.sort(reverse=True)
for i in range(K):
print((ans[i]))
|
p03078
|
import heapq
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()))
AA = list([x*(-1) for x in A])
BB = list([x*(-1) for x in B])
CC = list([x*(-1) for x in C])
ans = []
heapq.heapify(ans)
for a in AA:
for b in BB:
for c in CC:
heapq.heappush(ans, a+b+c)
for i in range(K):
print((heapq.heappop(ans)*(-1)))
main()
|
from heapq import heappush, heapify, heappop
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)
que = []
heapify(que)
heappush(que, (-A[0]-B[0]-C[0], 0, 0, 0))
s = set()
for i in range(K):
ans = heappop(que)
print((-ans[0]))
if(ans[1] < X-1 and not (ans[1]+1, ans[2], ans[3]) in s):
heappush(que, [-A[ans[1]+1]-B[ans[2]]-C[ans[3]], ans[1]+1, ans[2], ans[3]])
s.add((ans[1]+1, ans[2], ans[3]))
if(ans[2] < Y-1 and not (ans[1], ans[2]+1, ans[3]) in s):
heappush(que, [-A[ans[1]]-B[ans[2]+1]-C[ans[3]], ans[1], ans[2]+1, ans[3]])
s.add((ans[1], ans[2]+1, ans[3]))
if(ans[3] < Z-1 and not (ans[1], ans[2], ans[3]+1) in s):
heappush(que, [-A[ans[1]]-B[ans[2]]-C[ans[3]+1], ans[1], ans[2], ans[3]+1])
s.add((ans[1], ans[2], ans[3]+1))
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()))
AB = [a + b for a in A for b in B]
AB.sort()
AB.reverse()
ABC = [ab + c for ab in AB for c in C]
ABC.sort()
ABC.reverse()
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()))
AB = [a + b for a in A for b in B]
AB.sort()
AB.reverse()
AB = AB[:min(K, X*Y)]
ABC = [ab + c for ab in AB for c in C]
ABC.sort()
ABC.reverse()
for k in range(min(K, X*Y*Z)):
print((ABC[k]))
|
p03078
|
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)
AB = [A[x]+B[y] for x in range(X) for y in range(Y)]
AB.sort(reverse=True)
AB = AB[:K]
XY = len(AB)
ABC = [AB[xy]+C[z] for xy in range(XY) for z in range(Z)]
ABC.sort(reverse=True)
for k in range(K):
print((ABC[k]))
|
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)
AB = [A[x] + B[y] for y in range(Y) for x in range(X)]
AB.sort(reverse=True)
AB = AB[:K]
ABC = [AB[x] + C[z] for z in range(Z) for x in range(len(AB))]
ABC.sort(reverse=True)
for k in range(K):
print((ABC[k]))
|
p03078
|
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)
AB = [A[x] + B[y] for y in range(Y) for x in range(X)]
AB.sort(reverse=True)
AB = AB[:K]
XY = len(AB)
ABC = [AB[xy] + C[z] for z in range(Z) for xy in range(XY)]
ABC.sort(reverse=True)
for k in range(K):
print((ABC[k]))
|
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)
AB = [a+b for a in A for b in B]
AB.sort(reverse=True)
AB = AB[:K]
XY = len(AB)
ABC = [ab+c for c in C for ab in AB]
ABC.sort(reverse=True)
ABC = ABC[:K]
for abc in ABC:
print(abc)
|
p03078
|
# -*- coding: 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()))
v = []
d = [e1+e2 for e1 in a for e2 in b]
d.sort(reverse=True)
d = d[:k]
e = [e1+e2 for e1 in d for e2 in c]
e.sort(reverse=True)
for i in range(k):
print((e[i]))
|
# -*- coding: 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(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d = [e1+e2 for e1 in a for e2 in b]
d.sort(reverse=True)
d = d[:k]
e = [e1+e2 for e1 in d for e2 in c]
e.sort(reverse=True)
for i in range(k):
print((e[i]))
|
p03078
|
import heapq
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*(n+1)
self.rank=[0]*(n+1)
def FindRoot(self,x):
if self.root[x]<0:
return x
else:
self.root[x]=self.FindRoot(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.FindRoot(x)
y=self.FindRoot(y)
if x==y:
return
else:
if self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
elif self.rank[x]<=self.rank[y]:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def isSameGroup(self,x,y):
return self.FindRoot(x)==self.FindRoot(y)
def Count(self,x):
return -self.root[self.FindRoot(x)]
n,m=list(map(int,input().split()))
cost=list(map(int,input().split()))
if n==1:
print((0))
exit()
if n==2:
if m==0:
print((cost[0]+cost[1]))
exit()
if m==1:
print((0))
exit()
edges=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
for a,b in edges:
uf.Unite(a,b)
isolates=set()
isolates_cnt=0
groups=set()
groups_cnt=2
roots=[]
qs=[[] for _ in range(n)]
for i in range(n):
root=uf.FindRoot(i)
cnt=uf.Count(i)
if cnt==1:
isolates_cnt+=1
isolates.add(root)
heapq.heappush(qs[root],(cost[i],i))
else:
if root not in groups:
groups_cnt+=cnt-2
roots.append((root,cnt))
groups.add(root)
heapq.heappush(qs[root],(cost[i],i))
if groups_cnt<isolates_cnt:
print('Impossible')
else:
ans=0
roots=sorted(roots,reverse=True,key=lambda x:x[1])
root=roots[0][0]
for tmp_root,_ in roots[1:]:
cv,v=heapq.heappop(qs[root])
cu,u=heapq.heappop(qs[tmp_root])
ans+=(cv+cu)
while len(qs[tmp_root])!=0:
tc,tv=heapq.heappop(qs[tmp_root])
heapq.heappush(qs[root],(tc,tv))
for tmp_root in isolates:
cv,v=heapq.heappop(qs[root])
cu,u=heapq.heappop(qs[tmp_root])
ans+=(cv+cu)
print(ans)
|
import heapq
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*(n+1)
self.rank=[0]*(n+1)
def FindRoot(self,x):
if self.root[x]<0:
return x
else:
self.root[x]=self.FindRoot(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.FindRoot(x)
y=self.FindRoot(y)
if x==y:
return
else:
if self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
elif self.rank[x]<=self.rank[y]:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def isSameGroup(self,x,y):
return self.FindRoot(x)==self.FindRoot(y)
def Count(self,x):
return -self.root[self.FindRoot(x)]
n,m=list(map(int,input().split()))
costs=list(map(int,input().split()))
if m==n-1:
print((0))
exit()
edges=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
for a,b in edges:
uf.Unite(a,b)
qs=[[] for _ in range(n)]
roots=set()
for i in range(n):
root=uf.FindRoot(i)
roots.add(root)
heapq.heappush(qs[root],costs[i])
remains=[]
ans=0
cnt=0
for root in roots:
cost=heapq.heappop(qs[root])
ans+=cost
cnt+=1
while len(qs[root])!=0:
cost=heapq.heappop(qs[root])
heapq.heappush(remains,cost)
while len(remains)!=0 and cnt<2*(n-m-1):
cost=heapq.heappop(remains)
ans+=cost
cnt+=1
if cnt==2*(n-m-1):
print(ans)
else:
print('Impossible')
|
p03440
|
from collections import*
from heapq import*
(n,m),a,*q=[[*map(int,o.split())]for o in open(0)]
t=[-1]*n
def r(x):
while t[x]>=0:x=t[x]
return x
def u(x,y):
x,y=r(x),r(y)
if x!=y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
d=defaultdict(list)
for x,y in q:u(x,y)
i=0
for v in a:d[r(i)]+=v,;i+=1
if len(d)<2:exit(print(0))
c,b,k=0,[],(n-m-1)*2
for r,p in d.items():p.sort();c+=p.pop(0);b+=p;k-=1
print(k>len(b)and'Impossible'or c+sum(sorted(b)[:k]))
|
from collections import*
from heapq import*
(n,m),a,*q=[[*map(int,o.split())]for o in open(0)]
t=[-1]*n
def r(x):
while t[x]>=0:x=t[x]
return x
def u(x,y):
x,y=r(x),r(y)
if x!=y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
d=defaultdict(list)
for x,y in q:u(x,y)
i=c=0;b=[];k=(n+~m)*2
for v in a:d[r(i)]+=v,;i+=1
if k<1:exit(print(0))
for r,p in d.items():p.sort();c+=p.pop(0);b+=p;k-=1
print(k>len(b)and'Impossible'or c+sum(sorted(b)[:k]))
|
p03440
|
import sys
input = sys.stdin.buffer.readline
from collections import defaultdict
import heapq
def main():
N,M = list(map(int,input().split()))
a = list(map(int,input().split()))
d = defaultdict(list)
I = [i for i in range(N)]
rank = [1 for _ in range(N)]
def root(a):
if I[a] == a:
return a
else:
I[a] = root(I[a])
return I[a]
def unite(a,b):
pa,pb = root(a),root(b)
ra,rb = rank[a],rank[b]
if ra > rb:
I[pb] = pa
else:
I[pa] = pb
if ra == rb:
rank[pb] += 1
for _ in range(M):
x,y = list(map(int,input().split()))
unite(x,y)
parent = root(x)
for i,num in enumerate(I):
parent = root(num)
heapq.heappush(d[parent],a[i])
if M == N-1:
print((0))
exit()
elif N < 2*(N-M-1):
print("Impossible")
exit()
l = len(list(d.keys()))
ans = 0
rest = []
for use in list(d.values()):
ans += heapq.heappop(use)
rest.extend(use)
remain = 2*(N-M-1)-l
rest.sort()
ans += sum(rest[:remain])
print(ans)
if __name__ == "__main__":
main()
|
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
elif self.rank[y]<self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
from collections import defaultdict
N,M,*L = list(map(int, open(0).read().split()))
A = L[:N]
U = UnionFind(N)
for x,y in zip(*[iter(L[N:])]*2):
U.unit(x,y)
ans = 0
rest = []
dic = defaultdict(list)
for i in range(N):
dic[U.find(i)].append(A[i])
for k in list(dic.keys()):
dic[k].sort()
ans += dic[k][0]
rest.extend(dic[k][1:])
if N-1==M:
print((0))
exit()
if N<2*(N-M-1):
print('Impossible')
exit()
rest.sort()
remain = 2*(N-M-1)-len(list(dic.keys()))
ans += sum(rest[:remain])
print(ans)
|
p03440
|
from sys import exit, setrecursionlimit, stderr
from functools import reduce
from itertools import *
from collections import *
from bisect import bisect
def read():
return int(eval(input()))
def reads():
return [int(x) for x in input().split()]
def main():
N, M = reads()
A = reads()
d = Counter(A)
uf = union_find(N)
edges = [[] for _ in range(N)]
for _ in range(M):
x, y = reads()
uf.unite(x, y)
INF = 1 << 30
mins = defaultdict(lambda: INF)
for i in range(N):
k = uf.root(i)
mins[k] = min(mins[k], A[i])
g = len(mins)
if g == 1:
print((0)); exit()
if (g - 1) * 2 > N:
print("Impossible"); exit()
ans = 0
for k, v in list(mins.items()):
ans += v
d[v] -= 1
ans += sum(sorted(d.elements())[:g-2])
print(ans)
class union_find:
def __init__(self, n):
self.par = [-1] * n
def __repr__(self):
return "union_find({0})".format(self.par)
def unite(self, x, y):
if self.root(x) != self.root(y):
self.par[self.root(x)] = y
def root(self, x):
if self.par[x] == -1:
return x
else:
self.par[x] = self.root(self.par[x])
return self.par[x]
def same(self, x, y):
return self.root(x) == self.root(y)
main()
|
from sys import exit, setrecursionlimit, stderr
from functools import reduce
from itertools import *
from collections import *
from bisect import bisect
def read():
return int(eval(input()))
def reads():
return [int(x) for x in input().split()]
def main():
N, M = reads()
A = reads()
if M == N-1:
print((0)); exit()
d = Counter(A)
uf = union_find(N)
edges = [[] for _ in range(N)]
for _ in range(M):
x, y = reads()
uf.unite(x, y)
INF = 1 << 30
mins = defaultdict(lambda: INF)
for i in range(N):
k = uf.root(i)
mins[k] = min(mins[k], A[i])
g = len(mins)
if (g - 1) * 2 > N:
print("Impossible"); exit()
ans = 0
for k, v in list(mins.items()):
ans += v
d[v] -= 1
ans += sum(sorted(d.elements())[:g-2])
print(ans)
class union_find:
def __init__(self, n): self.par = [-1] * n; self.rank = [0] * n
def __repr__(self): return "union_find({0})".format([self.root(i) for i in range(n)])
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y: return
if self.rank[x] < self.rank[y]: self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]: self.rank[x] += 1
def root(self, x):
if self.par[x] == -1: return x
else: self.par[x] = self.root(self.par[x]); return self.par[x]
def same(self, x, y): return self.root(x) == self.root(y)
main()
|
p03440
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from heapq import heappop,heappush
n,m = list(map(int,readline().split()))
a = list(map(int,readline().split()))
xy = list(map(int,read().split()))
if(n-m==1):
print((0))
exit()
p = ((n-1)-m)*2
if( p > n):
print('Impossible')
exit()
sys.setrecursionlimit(10**9)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self,x):
if(self.parents[x] < 0):
return x
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def size(self, x):
return self.parents[ self.find(x) ] * -1
def same(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
return (x_root == y_root)
def union(self,x,y):
x_root = self.find(x)
y_root = self.find(y)
if(x_root == y_root):
return
if( self.parents[x_root] <= self.parents[y_root] ):
self.parents[x_root] += self.parents[y_root]
self.parents[y_root] = x_root
else:
self.parents[y_root] += self.parents[x_root]
self.parents[x_root] = y_root
def members(self,x):
root = self.find(x)
ret = [ i for i in range(self.n) if self.find(i) == root ]
return ret
def roots(self):
ret = [ i for i in range(self.n) if self.parents[i] < 0]
return ret
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(n)
hqs = [[] for _ in range(n)]
it = iter(xy)
for x,y in zip(it,it):
uf.union(x,y)
for i in range(n):
root = uf.find(i)
heappush(hqs[root], a[i])
ans = []
others = []
for i in range(n):
if(hqs[i]):
ans.append(heappop(hqs[i]))
others = others + hqs[i]
others.sort()
rem = p - len(ans)
ans = ans + others[:rem]
print((sum(ans)))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from heapq import heappop,heappush
n,m = list(map(int,readline().split()))
a = list(map(int,readline().split()))
xy = list(map(int,read().split()))
if(n-m==1):
print((0))
exit()
p = ((n-1)-m)*2
if( p > n):
print('Impossible')
exit()
sys.setrecursionlimit(10**9)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self,x):
if(self.parents[x] < 0):
return x
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def size(self, x):
return self.parents[ self.find(x) ] * -1
def same(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
return (x_root == y_root)
def union(self,x,y):
x_root = self.find(x)
y_root = self.find(y)
if(x_root == y_root):
return
if( self.parents[x_root] <= self.parents[y_root] ):
self.parents[x_root] += self.parents[y_root]
self.parents[y_root] = x_root
else:
self.parents[y_root] += self.parents[x_root]
self.parents[x_root] = y_root
def members(self,x):
root = self.find(x)
ret = [ i for i in range(self.n) if self.find(i) == root ]
return ret
def roots(self):
ret = [ i for i in range(self.n) if self.parents[i] < 0]
return ret
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(n)
hqs = [[] for _ in range(n)]
it = iter(xy)
for x,y in zip(it,it):
uf.union(x,y)
for i in range(n):
root = uf.find(i)
heappush(hqs[root], a[i])
ans = []
others = []
for i in range(n):
if(hqs[i]):
ans.append(heappop(hqs[i]))
for j in hqs[i]:
others.append(j)
others.sort()
rem = p - len(ans)
ans = ans + others[:rem]
print((sum(ans)))
|
p03440
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent,[])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int, input().split()))
uf.union(x,y)
first_mins = []
other_vals = []
all_members = uf.get_all_members()
if len(all_members) == 1:
print((0))
exit()
for members in all_members:
vs = []
for m in members:
vs.append(al[m])
vs.sort()
first_mins.append(vs[0])
other_vals = other_vals + vs[1:]
# print(first_mins)
ans = 0
ans += sum(first_mins)
rem = len(all_members)-2
if len(other_vals) < rem:
print('Impossible')
exit()
other_vals.sort()
ans += sum(other_vals[:rem])
print(ans)
if __name__ == "__main__":
main()
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent,[])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int, input().split()))
uf.union(x,y)
first_mins = []
other_vals = []
all_members = uf.get_all_members()
if len(all_members) == 1:
print((0))
exit()
for members in all_members:
vs = []
for m in members:
vs.append(al[m])
vs.sort()
first_mins.append(vs[0])
for i,v in enumerate(vs):
if i > 0:
other_vals.append(v)
# print(first_mins)
ans = 0
ans += sum(first_mins)
rem = len(all_members)-2
if len(other_vals) < rem:
print('Impossible')
exit()
other_vals.sort()
ans += sum(other_vals[:rem])
print(ans)
if __name__ == "__main__":
main()
|
p03440
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent,[])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int, input().split()))
uf.union(x,y)
first_mins = []
other_vals = []
all_members = uf.get_all_members()
if len(all_members) == 1:
print((0))
exit()
for members in all_members:
vs = []
for m in members:
vs.append(al[m])
vs.sort()
first_mins.append(vs[0])
for i,v in enumerate(vs):
if i > 0:
other_vals.append(v)
# print(first_mins)
ans = 0
ans += sum(first_mins)
rem = len(all_members)-2
if len(other_vals) < rem:
print('Impossible')
exit()
other_vals.sort()
ans += sum(other_vals[:rem])
print(ans)
if __name__ == "__main__":
main()
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent,[])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int, input().split()))
uf.union(x,y)
first_mins = []
other_vals = []
all_members = uf.get_all_members()
if len(all_members) == 1:
print((0))
exit()
for members in all_members:
vs = []
for m in members:
vs.append(al[m])
vs.sort()
first_mins.append(vs[0])
for i,v in enumerate(vs[1:]):
# if i > 0:
other_vals.append(v)
# print(first_mins)
ans = 0
ans += sum(first_mins)
rem = len(all_members)-2
if len(other_vals) < rem:
print('Impossible')
exit()
other_vals.sort()
ans += sum(other_vals[:rem])
print(ans)
if __name__ == "__main__":
main()
|
p03440
|
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
parent_data = []
def union(ind):
global parent_data
if parent_data[ind] != ind:
parent_data[ind] = union(parent_data[ind])
return parent_data[ind]
def main():
node_num, edge_num = list(map(int, input().split()))
cost_data = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(edge_num)]
global parent_data
parent_data = [i for i in range(node_num)]
for i in range(edge_num):
a, b = data[i]
parent_a = union(a)
parent_b = union(b)
parent_data[min(parent_a, parent_b)] = max(parent_a, parent_b)
parent_count = defaultdict(int)
cost_heap = defaultdict(list)
for i in range(node_num):
parent_i = union(i)
parent_count[parent_i] += 1
heapq.heappush(cost_heap[parent_i], cost_data[i])
parent_count = list(sorted(list(parent_count.items()), key=lambda x:-x[1]))
ans = 0
ori_ind, ori_count = parent_count[0]
for i in range(len(parent_count) - 1):
now_ind, now_count = parent_count[i + 1]
if len(cost_heap[ori_ind]) == 0:
print('Impossible')
sys.exit()
ori_cost = heapq.heappop(cost_heap[ori_ind])
now_cost = heapq.heappop(cost_heap[now_ind])
ans += ori_cost + now_cost
cost_heap[ori_ind] = list(heapq.merge(cost_heap[ori_ind], cost_heap[now_ind]))
print(ans)
if __name__ == '__main__':
main()
|
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
parent_data = []
def union(ind):
global parent_data
if parent_data[ind] != ind:
parent_data[ind] = union(parent_data[ind])
return parent_data[ind]
def main():
node_num, edge_num = list(map(int, input().split()))
cost_data = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(edge_num)]
global parent_data
parent_data = [i for i in range(node_num)]
for i in range(edge_num):
a, b = data[i]
parent_a = union(a)
parent_b = union(b)
parent_data[min(parent_a, parent_b)] = max(parent_a, parent_b)
parent_count = defaultdict(int)
cost_heap = defaultdict(list)
for i in range(node_num):
parent_i = union(i)
parent_count[parent_i] += 1
heapq.heappush(cost_heap[parent_i], (cost_data[i], parent_i))
parent_count = list(sorted(list(parent_count.items()), key=lambda x:-x[1]))
ans = 0
ori_ind, ori_count = parent_count[0]
for i in range(len(parent_count) - 1):
now_ind, now_count = parent_count[i + 1]
if len(cost_heap[ori_ind]) == 0:
print('Impossible')
sys.exit()
ori_cost, o_ind = heapq.heappop(cost_heap[ori_ind])
now_cost, n_ind = heapq.heappop(cost_heap[now_ind])
ans += ori_cost + now_cost
if len(cost_heap[n_ind]) > 0:
a, b = heapq.heappop(cost_heap[n_ind])
heapq.heappush(cost_heap[ori_ind], (a, b))
if len(cost_heap[o_ind]) > 0 and o_ind != ori_ind:
a, b = heapq.heappop(cost_heap[o_ind])
heapq.heappush(cost_heap[ori_ind], (a, b))
print(ans)
if __name__ == '__main__':
main()
|
p03440
|
from collections import deque
from collections import defaultdict
import heapq
N,M=list(map(int, input().split()))
cost=list(map(int, input().split()))
if M==N-1:
print(0)
quit()
nl=[ [] for i in range(N) ]
for i in range(M):
x,y=list(map(int,input().split()))
nl[x].append(y)
nl[y].append(x)
d=[ None for i in range(N) ]
V=[ None for i in range(N) ]
group_cost=defaultdict(lambda: [])
def dfs(start):
q = deque([])
V[start]=start
d[start]=0
heapq.heappush(group_cost[start],cost[start])
q.append(start)
while len(q)!=0:
v=q.pop()
for i in nl[v]:
if V[i] is None:
V[i]=start
q.append(i)
heapq.heappush(group_cost[start],cost[i])
for i in range(N):
if V[i] is None:
dfs(i)
H = []
ans=0
for v in list(group_cost.values()):
v=sorted(v)
ans+=v[0]
H.append(v[1:])
nokori_cost=list(heapq.merge(*H))
if N < 2*(N-M-1):
print("Impossible")
elif M == N-1:
print(0)
else:
ans += sum(nokori_cost[:2*(N-M-1) - len(list(group_cost.keys()))])
print(ans)
|
from collections import deque
from collections import defaultdict
import heapq
N,M=list(map(int, input().split()))
cost=list(map(int, input().split()))
par=[i for i in range(N)]
def root(x):
if par[x]==x:
return x
else:
r=root(par[x])
par[x]=r
return r
def unite(x,y):
x=root(x)
y=root(y)
if x==y: return
par[x]=y
for i in range(M):
x,y=list(map(int,input().split()))
unite(x,y)
group_cost=defaultdict(lambda: [])
for i in range(N):
root(i)
group_cost[par[i]].append(cost[i])
H = []
ans=0
for v in list(group_cost.values()):
v=sorted(v)
ans+=v[0]
H.append(v[1:])
nokori_cost=list(heapq.merge(*H))
if N < 2*(N-M-1):
print("Impossible")
elif M == N-1:
print(0)
else:
ans += sum(nokori_cost[:2*(N-M-1) - len(list(group_cost.keys()))])
print(ans)
|
p03440
|
def examA():
N = I()
ans = 0
print(ans)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
#############################################################
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
self.n = n
# 正==子: 根の頂点番号 / 負==根: 連結頂点数
def find(self, x):
# 要素xが属するグループの根を返す
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
# 要素xが属するグループと要素yが属するグループとを併合する
x, y = self.find(x), self.find(y)
if x == y:
return False
else:
if self.size(x) < self.size(y):
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
def same(self, x, y):
# 要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def size(self, x):
# 要素xが属するグループのサイズ（要素数）を返す
x = self.find(x)
return -self.parent[x]
def is_root(self, x):
# 要素の根をリストで返す
return self.parent[x] < 0
def roots(self):
# すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parent) if x < 0]
def members(self, x):
# 要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def group_count(self):
# グループの数を返す
return len(self.roots())
def all_group_members(self):
# {ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
return {r: self.members(r) for r in self.roots()}
################################################################################
N, M = LI()
a = LI()
A = []
for i,j in enumerate(a):
A.append([j,i])
A.sort()
ans = 0
uf = UnionFind(N)
for _ in range(M):
x,y = LI()
if not uf.same(x,y):
uf.unite(x,y)
D = defaultdict(list)
que_tot = deque()
rep = defaultdict(bool)
r = uf.roots()
for i in r:
keep = -1
for j in uf.members(i):
if not D[i] or D[i]>a[j]:
D[i] = a[j]
keep = j
rep[keep] = True
ans += D[i]
# print(rep)
loop = uf.group_count()-2
if loop==-1:
print((0))
return
cur = 0
for i in range(N):
if cur>=loop:
break
if not rep[A[i][1]]:
cur +=1
ans += A[i][0]
if cur<loop:
print("Impossible")
return
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LFI(): return list(map(float,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examD()
"""
"""
|
def examA():
N = I()
ans = 0
print(ans)
return
def examB():
ans = 0
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
#############################################################
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
self.n = n
# 正==子: 根の頂点番号 / 負==根: 連結頂点数
def find(self, x):
# 要素xが属するグループの根を返す
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
# 要素xが属するグループと要素yが属するグループとを併合する
x, y = self.find(x), self.find(y)
if x == y:
return False
else:
if self.size(x) < self.size(y):
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
def same(self, x, y):
# 要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def size(self, x):
# 要素xが属するグループのサイズ（要素数）を返す
x = self.find(x)
return -self.parent[x]
def is_root(self, x):
# 要素の根をリストで返す
return self.parent[x] < 0
def roots(self):
# すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parent) if x < 0]
def members(self, x):
# 要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def group_count(self):
# グループの数を返す
return len(self.roots())
def all_group_members(self):
# {ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
return {r: self.members(r) for r in self.roots()}
################################################################################
N, M = LI()
a = LI()
ans = 0
uf = UnionFind(N)
for _ in range(M):
x,y = LI()
if not uf.same(x,y):
uf.unite(x,y)
D = defaultdict(int)
rep = defaultdict(bool)
r = uf.roots()
keep = [-1]*N
for i in range(N):
parent = uf.find(i)
if (not D[parent]) or D[parent] > a[i]:
D[parent] = a[i]
keep[parent] = i
for i in range(N):
if keep[i]==-1:
continue
rep[keep[i]] = True
ans += D[i]
loop = uf.group_count()-2
if loop==-1:
print((0))
return
A = []
for i,j in enumerate(a):
A.append([j,i])
A.sort()
cur = 0
for i in range(N):
if cur>=loop:
break
if not rep[A[i][1]]:
cur +=1
ans += A[i][0]
if cur<loop:
print("Impossible")
return
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LFI(): return list(map(float,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examD()
"""
"""
|
p03440
|
(n,m),a,*q=[map(int,t.split())for t in open(0)]
t=[-1]*n
def r(x):
while-1<t[x]:x=t[x]
return x
def u(x):
x,y=map(r,x)
if x!=y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
[*map(u,q)]
i=c=0
k,*b=n+~m<<1,
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
print(k<1and'0'or(k>n)*'Impossible'or exec('for p in d:x,*y=sorted(p)+[0];c+=x;b+=y[:-1];k-=p>[]')or c+sum(sorted(b)[:k]))
|
(n,m,*b),a,*q=[list(map(int,t.split()))for t in open(0)]
t=[-1]*n
def r(x):
while-1<t[x]:x=t[x]
return x
def u(x):
x,y=list(map(r,x))
if x!=y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
[*list(map(u,q))]
i=c=0
k=j=n+~m<<1
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
for p in d:x,*y=sorted(p)+[0];c+=x;b+=y[:-1];j-=p>[]
print((k<1and'0'or(k>n)*'Impossible'or c+sum(sorted(b)[:j])))
|
p03440
|
(n,m,*b),a,*q=[list(map(int,t.split()))for t in open(0)]
t=[-1]*n
def r(x):
while-1<t[x]:x=t[x]
return x
def u(x):
x,y=list(map(r,x))
if x-y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
[*list(map(u,q))]
i=c=0
k=j=n+~m<<1
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
for p in d:x,*y=sorted(p)+[0];c+=x;b+=y[:-1];j-=p>[]
print(((c+sum(sorted(b)[:j]),'Impossible')[k>n]*(k>0)))
|
(n,m,*b),a,*q=[list(map(int,t.split()))for t in open(0)]
t=[-1]*n
def r(x):
while-1<t[x]:x=t[x]
return x
def u(x):
x,y=list(map(r,x))
if x-y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
[*list(map(u,q))]
i=c=0
k=j=n+~m<<1
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
for p in d:
if p:x,*y=sorted(p);c+=x;b+=y;j-=1
print(((c+sum(sorted(b)[:j]),'Impossible')[k>n]*(k>0)))
|
p03440
|
s=sorted
(n,m,*b),a,*q=[list(map(int,t.split()))for t in open(0)]
t=[-1]*n
def r(x):
while-1<t[x]:x=t[x]
return x
def u(x):
x,y=list(map(r,x))
if x-y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
[*list(map(u,q))]
i=c=0
k=j=n+~m<<1
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
for p in d:
if p:x,*y=s(p);c+=x;b+=y;j-=1
print(((c+sum(s(b)[:j]),'Impossible')[k>n]*(k>0)))
|
s=sorted
(n,m,*b),a,*q=[list(map(int,t.split()))for t in open(0)]
t=[-1]*n
r=lambda x:r(t[x])if-1<t[x]else x
def u(x):
x,y=list(map(r,x))
if x-y:
if t[x]>t[y]:x,y=y,x
t[x]+=t[y];t[y]=x
*list(map(u,q)),
i=c=0
k=j=n+~m<<1
*d,=eval('[],'*n)
for v in a:d[r(i)]+=v,;i+=1
for p in d:
if p:x,*y=s(p);c+=x;b+=y;j-=1
print(((c+sum(s(b)[:j]),'Impossible')[k>n]*(k>0)))
|
p03440
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group(self):
return [self.members(r) for r in self.roots()]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.readline
import heapq
n, m = list(map(int, input().split()))
if m == n-1:
print((0))
exit()
if n < 2*(n-m-1):
print("Impossible")
exit()
A = tuple(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x, y = list(map(int, input().split()))
uf.unite(x, y)
ans = 0
L = []
for l in uf.all_group():
K = sorted((A[i] for i in l), reverse=True)
ans += K.pop()
for k in K:
heapq.heappush(L, k)
for _ in range(n-m-2):
ans += heapq.heappop(L)
print(ans)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
import heapq
n, m = list(map(int, input().split()))
if m == n-1:
print((0))
exit()
if n < 2*(n-m-1):
print("Impossible")
exit()
A = tuple(map(int, input().split()))
G = [[] for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
G[x].append(y)
G[y].append(x)
ans = 0
L = []
seen = [False]*n
def dfs(v):
global ans
K = []
stack = [v]
while stack:
v = stack.pop()
heapq.heappush(K, A[v])
seen[v] = True
for nv in G[v]:
if seen[nv]:
continue
stack.append(nv)
ans += heapq.heappop(K)
for k in K:
heapq.heappush(L, k)
for i in range(n):
if not seen[i]:
dfs(i)
for _ in range(n-m-2):
ans += heapq.heappop(L)
print(ans)
|
p03440
|
N,M = list(map(int,input().split()))
src = list(map(int,input().split()))
es = [tuple(map(int,input().split())) for i in range(M)]
if M == N-1:
print((0))
exit()
if M + N//2 < N-1:
print('Impossible')
exit()
parent = [i for i in range(N)]
rank = [0] * N
def root(a):
if parent[a] == a:
return a
else:
parent[a] = root(parent[a])
return parent[a]
def same(a,b):
return root(a) == root(b)
def unite(a,b):
ra = root(a)
rb = root(b)
if ra == rb: return
if rank[ra] < rank[rb]:
parent[ra] = rb
else:
parent[rb] = ra
if rank[ra] == rank[rb]: rank[ra] += 1
for a,b in es:
unite(a,b)
trees = {}
for i in range(N):
root(i)
for i in range(N):
trees[root(i)] = False
costs = []
for i,c in enumerate(src):
costs.append((c,i))
costs.sort()
used = [False] * N
ans = used_n = 0
for c,v in costs:
t = root(v)
if trees[t]:
continue
else:
trees[t] = used[v] = True
used_n += 1
ans += c
for c,v in costs:
if used_n == 2*(N-M-1): break
if used[v]: continue
used_n += 1
ans += c
print(ans)
|
N,M = list(map(int,input().split()))
src = list(map(int,input().split()))
es = [tuple(map(int,input().split())) for i in range(M)]
if M == N-1:
print((0))
exit()
if M + N//2 < N-1:
print('Impossible')
exit()
parent = [i for i in range(N)]
rank = [0] * N
def root(a):
if parent[a] == a:
return a
else:
parent[a] = root(parent[a])
return parent[a]
def same(a,b):
return root(a) == root(b)
def unite(a,b):
ra = root(a)
rb = root(b)
if ra == rb: return
if rank[ra] < rank[rb]:
parent[ra] = rb
else:
parent[rb] = ra
if rank[ra] == rank[rb]: rank[ra] += 1
for a,b in es:
unite(a,b)
trees = {}
for i in range(N):
trees[root(i)] = False
costs = []
for i,c in enumerate(src):
costs.append((c,i))
costs.sort()
used = [False] * N
ans = used_n = 0
for c,v in costs:
t = root(v)
if trees[t]:
continue
else:
trees[t] = used[v] = True
used_n += 1
ans += c
for c,v in costs:
if used_n == 2*(N-M-1): break
if used[v]: continue
used_n += 1
ans += c
print(ans)
|
p03440
|
N = int(eval(input()))
print(((N + 1) // 2))
#sjdjsdajkjkafffjfjfjfjfjjfjf
|
n = int(eval(input()))
if n % 2 == 0:
print((n//2))
else:
print((n//2 + 1))
|
p02759
|
import math
n = int(eval(input()))
print((math.ceil(n/2)))
|
n = int(eval(input()))
print((int((n+1)/2)))
|
p02759
|
N = int(eval(input()))
print(((N+1)>>1))
|
print(((int(eval(input()))+1)//2))
|
p02759
|
import math
print((math.ceil(int(eval(input()))/2)))
|
print(((int(eval(input()))+1)//2))
|
p02759
|
n=int(eval(input()))
if n%2==1:
print((n//2+1))
else:
print((n//2))
|
n=int(eval(input()))
print(((n+1)//2))
|
p02759
|
from math import ceil
print((ceil(int(eval(input()))/2)))
|
print((-~int(eval(input()))//2))
|
p02759
|
import math
N=int(eval(input()))
print((math.ceil(N/2)))
|
print(((int(eval(input()))+1)//2))
|
p02759
|
import math
print((math.ceil(int(eval(input()))/2)))
|
print(((-int(eval(input()))//2)*-1))
|
p02759
|
import math
N=int(eval(input()))
print((math.ceil(N/2)))
|
N=int(eval(input()))
print((N//2+N%2))
|
p02759
|
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
answer = (N+1) // 2
print(answer)
|
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
answer = (N+1) // 2
print(answer)
|
p02759
|
S = int(eval(input()))
A = 0
if S % 2 == 1:
A = S // 2 + 1
else:
A = S // 2
print(A)
|
N = int(eval(input())) #数字
print((N // 2 if N % 2 == 0 else N // 2 + 1))
|
p02759
|
import itertools
import math
import fractions
import functools
n = int(eval(input()))
if n % 2 == 1:
print((n//2+1))
else: print((n//2))
|
n = int(eval(input()))
print(((n+1)//2))
|
p02759
|
N = int(eval(input()))
if N%2==0:
print((N//2))
else:
print((N//2 + 1))
|
N = int(eval(input()))
print(((N+1)//2))
|
p02759
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.