input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
A, B, C, D, E, F = list(map(int, input().split()))
ans = [100 * A, 0]
c = 0
for i in range(1, F // (100 * A) + 1):
for j in range((F - 100 * A * i) // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
for k in range((F - a) // C + 1):
for l in range((F - a - C * k) // D + 1):
b = k * C + l * D
concentration = 100 * b / (a + b)
if (A * i + B * j) * E >= b:
if concentration > c:
c = concentration
ans = [a + b, b]
else:
break
print((' '.join(map(str, ans)))) | A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = min(i // 100 * E, F - i)
sugar = [0]
for j in range(max_sugar // C + 1):
for k in range((max_sugar - j * C) // D + 1):
sugar.append(j * C + k * D)
max_sugar = max(sugar)
concentration = max_sugar / (i + max_sugar)
if c < concentration:
c = concentration
ans = [i + max_sugar, max_sugar]
print((' '.join(map(str, ans)))) | p03599 |
A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = min(i // 100 * E, F - i)
sugar = 0
for j in range(max_sugar // C + 1):
for k in range((max_sugar - j * C) // D + 1):
sugar = max(sugar, j * C + k * D)
concentration = sugar / (i + sugar)
if c < concentration:
c = concentration
ans = [i + sugar, sugar]
print((' '.join(map(str, ans)))) | A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = min(i // 100 * E, F - i)
sugar = 0
for j in reversed(list(range(max_sugar // C + 1))):
for k in range((max_sugar - j * C) // D + 1):
sugar = max(sugar, j * C + k * D)
if max_sugar == sugar:
break
else:
continue
break
concentration = sugar / (i + sugar)
if c < concentration:
c = concentration
ans = [i + sugar, sugar]
print((' '.join(map(str, ans)))) | p03599 |
import sys
import math
cadena = list()
sub = list()
sub2 =list()
s =""" Since <fontstyle="vertical−align:inherit;"><fontstyle="vertical−align:inherit;">1+2=3<⁄font><⁄font>, the output should be <fontstyle="vertical−align:inherit;"><fontstyle="vertical−align:inherit;">3<⁄font><⁄font>."""
salida = """<fontstyle="vertical−align:inherit;"><fontstyle="vertical−align:inherit;">3<⁄font><⁄font>."""
kl = salida.find(">3<")
x = s.split()
j = s.find("1+2=3")
l = s.find(">3<")
sub2.append(s[l+1])
sub.append(s[j:j+5])
c = sub[0]
from itertools import permutations
lines = sys.stdin.readlines()
for linea in lines:
c = linea.split()
c = list(map(str,c))
x1 = int(c[0])
x2 =int(c[2])
operador = c[1]
if operador == "+":
op = x1+x2
if operador == "-":
op = x1-x2
elif operador == "*":
op = x1*x2
if operador == "/":
op = x1/x2
str(op)
operacion1 = s[j:j+2]
my_lst_str = ''.join(map(str, c))
operacion1 = s[j:j+3]
men = s.replace(operacion1, my_lst_str)
s = men
numero =s[j+4]
men1 = salida.replace(salida[74], str(op))
men = s.replace(numero, str(op))
print(op)
| s = input().split()
if s[1] == "-":
print((int(s[0])-int(s[2])))
if s[1] == "+":
print((int(s[0])+int(s[2]))) | p03844 |
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
print((a + b))
else:
print((a - b))
| print((eval(input()))) | p03844 |
l = input().split()
print((int(l[0]) + int(l[2]) if l[1] == '+' else int(l[0]) - int(l[2])))
| print((eval(input()))) | p03844 |
print((eval(input()))) | a,b,c=input().split()
if b=="-":
print((int(a)-int(c)))
else:
print((int(a)+int(c)))
| p03844 |
val = input().split()
if val[1] == "+":
print((int(val[0])+int(val[2])))
else:
print((int(val[0]) - int(val[2])))
| print((eval(input()))) | p03844 |
def main():
A, op, B = input().split()
A = int(A)
B = int(B)
if op == "+":
print((A + B))
else:
print((A - B))
if __name__ == "__main__":
main() | print((eval(input()))) | p03844 |
print((eval(''.join(input().split())))) | print((eval(input()))) | p03844 |
S = input().split()
a, b = int(S[0]), int(S[2])
if S[1] == '+':
print((a + b))
else:
print((a - b))
| print((eval(input()))) | p03844 |
print((eval(input().replace(' ','')))) | print((eval(input()))) | p03844 |
a = input().split()
if a[1] == '+':
ans = int(a[0]) + int(a[2])
else:
ans = int(a[0]) - int(a[2])
print(ans)
| print((eval(input()))) | p03844 |
'''
ABC050 A - Addition and Subtraction Easy
https://atcoder.jp/contests/abc050/tasks/abc050_a
'''
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
ans = a+b
elif op == '-':
ans = a-b
print(ans)
| '''
ABC050 A - Addition and Subtraction Easy
https://atcoder.jp/contests/abc050/tasks/abc050_a
'''
def main():
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
ans = a+b
elif op == '-':
ans = a-b
print(ans)
if __name__ == '__main__':
main()
| p03844 |
A, op, B = input().split()
print((int(A) + int(B) if op == '+' else int(A) - int(B))) | A, op, B = input().split()
A = int(A); B = int(B)
print((A + B if op == '+' else A - B)) | p03844 |
import functools
import os
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
def inp():
return int(eval(input()))
def inpf():
return float(eval(input()))
def inps():
return eval(input())
def inl():
return list(map(int, input().split()))
def inlf():
return list(map(float, input().split()))
def inls():
return input().split()
def inpm(line):
return [inp() for _ in range(line)]
def inpfm(line):
return [inpf() for _ in range(line)]
def inpsm(line):
return [inps() for _ in range(line)]
def inlm(line):
return [inl() for _ in range(line)]
def inlfm(line):
return [inlf() for _ in range(line)]
def inlsm(line):
return [inls() for _ in range(line)]
def Yesif(cond):
print(('Yes' if cond else 'No'))
def YESIF(cond):
print(('YES' if cond else 'NO'))
def yesif(cond):
print(('yes' if cond else 'no'))
a, o, b = inls()
if o=='+':
print((int(a) + int(b)))
else:
print((int(a) - int(b)))
| import functools
import os
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
def inp():
return int(eval(input()))
def inpf():
return float(eval(input()))
def inps():
return eval(input())
def inl():
return list(map(int, input().split()))
def inlf():
return list(map(float, input().split()))
def inls():
return input().split()
def inpm(line):
return [inp() for _ in range(line)]
def inpfm(line):
return [inpf() for _ in range(line)]
def inpsm(line):
return [inps() for _ in range(line)]
def inlm(line):
return [inl() for _ in range(line)]
def inlfm(line):
return [inlf() for _ in range(line)]
def inlsm(line):
return [inls() for _ in range(line)]
def Yesif(cond):
print(('Yes' if cond else 'No'))
def YESIF(cond):
print(('YES' if cond else 'NO'))
def yesif(cond):
print(('yes' if cond else 'no'))
print((eval(input())))
| p03844 |
s = list((input().split()))
if s[1] =='+':
ans = int(s[0]) + int(s[2])
elif s[1] =='-':
ans = int(s[0]) - int(s[2])
print(ans) | s = input().split()
if s[1] =='+':
print((int(s[0])+ int(s[2])))
else:
print((int(s[0])- int(s[2]))) | p03844 |
a,o,b=input().split()
a=int(a)
b=int(b)
print(([a+b,a-b][o=="-"])) | print((eval(input()))) | p03844 |
A,op,B=input().split()
if op=="+":
print((int(A)+int(B)))
else:
print((int(A)-int(B))) | A,op,B=input().split()
print((int(A)+int(B)if op=="+" else int(A)-int(B)))
| p03844 |
A,op,B=input().split()
A,B=list(map(int,[A,B]))
print((A+B if op=="+" else A-B)) | print((eval(input()))) | p03844 |
print((eval(input()))) | print(eval(input())) | p03844 |
print(eval(input())) | print((eval(input()))) | p03844 |
a,op,b=[i for i in input().split()]
print((int(a)+int(b) if op=='+' else int(a)-int(b))) | print((eval(input()))) | p03844 |
a, op, b = input().split()
print((eval(a+op+b))) | A, op, B = input().split()
print((int(A) + int(B) if op == '+' else int(A) - int(B))) | p03844 |
class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [None for _ in range(self.n)]
self.parent[root] = -1
self.depth = [None for _ in range(self.n)]
self.depth[root] = 0
self.order = []
self.order.append(root)
stack = [root]
while stack:
node = stack.pop()
for adj in self.tree[node]:
if self.parent[adj] is None:
self.parent[adj] = node
self.depth[adj] = self.depth[node] + 1
self.order.append(adj)
stack.append(adj)
def rerooting(self, func, merge, ti, ei):
dp = [ti for _ in range(self.n)]
lt = [ei for _ in range(self.n)]
rt = [ei for _ in range(self.n)]
inv = [ei for _ in range(self.n)]
self.setroot(0)
for node in self.order[::-1]:
if len(self.tree[node]) == 1 and node != 0:
continue
tmp = ti
for adj in self.tree[node]:
if self.parent[adj] == node:
lt[adj] = tmp
tmp = func(tmp, dp[adj])
tmp = ti
for adj in self.tree[node][::-1]:
if self.parent[adj] == node:
rt[adj] = tmp
tmp = func(tmp, dp[adj])
dp[node] = tmp / (len(self.tree[node]) - 1) if node != 0 else tmp / len(self.tree[node])
for node in self.order:
if node == 0:
continue
merged = merge(lt[node], rt[node])
par = self.parent[node]
inv[node] = func(merged, inv[par])
inv[node] = inv[node] / (len(self.tree[par]) - 1) if len(self.tree[par]) != 1 else 0
dp[node] = func(dp[node] * (len(self.tree[node]) - 1), inv[node])
dp[node] /= len(self.tree[node])
return dp
'''
def rerooting(self, func, merge, ti, ei):
dp = [ti for _ in range(self.n)]
lt = [ei for _ in range(self.n)]
rt = [ei for _ in range(self.n)]
inv = [ei for _ in range(self.n)]
self.setroot(0)
for node in self.order[::-1]:
tmp = ti
for adj in self.tree[node]:
if self.parent[adj] == node:
lt[adj] = tmp
tmp = func(tmp, dp[adj])
tmp = ti
for adj in self.tree[node][::-1]:
if self.parent[adj] == node:
rt[adj] = tmp
tmp = func(tmp, dp[adj])
dp[node] = tmp
for node in self.order:
if node == 0:
continue
merged = merge(lt[node], rt[node])
par = self.parent[node]
inv[node] = func(merged, inv[par])
dp[node] = func(dp[node], inv[node])
return dp
'''
import sys
input = sys.stdin.readline
N = int(eval(input()))
E = [tuple(map(int,input().split())) for _ in range(N - 1)]
T = Tree(N, E)
ti = 0
ei = -1
func = lambda x, y: x + y + 1
merge = lambda x, y: x + y
D = T.rerooting(func, merge, ti, ei)
res = []
for i in range(N):
res.append(D[i])
print(('\n'.join(map(str, res)))) | class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [None for _ in range(self.n)]
self.parent[root] = -1
self.depth = [None for _ in range(self.n)]
self.depth[root] = 0
self.order = []
self.order.append(root)
stack = [root]
while stack:
node = stack.pop()
for adj in self.tree[node]:
if self.parent[adj] is None:
self.parent[adj] = node
self.depth[adj] = self.depth[node] + 1
self.order.append(adj)
stack.append(adj)
def rerooting(self, func, merge, ti, ei):
dp = [ti for _ in range(self.n)]
lt = [ei for _ in range(self.n)]
rt = [ei for _ in range(self.n)]
inv = [ei for _ in range(self.n)]
self.setroot(0)
for node in self.order[::-1]:
if len(self.tree[node]) == 1 and node != 0:
continue
tmp = ti
for adj in self.tree[node]:
if self.parent[adj] == node:
lt[adj] = tmp
tmp = func(tmp, dp[adj])
tmp = ti
for adj in self.tree[node][::-1]:
if self.parent[adj] == node:
rt[adj] = tmp
tmp = func(tmp, dp[adj])
dp[node] = tmp / (len(self.tree[node]) - 1) if node != 0 else tmp / len(self.tree[node])
for node in self.order:
if node == 0:
continue
merged = merge(lt[node], rt[node])
par = self.parent[node]
inv[node] = func(merged, inv[par]) / (len(self.tree[par]) - 1) if len(self.tree[par]) != 1 else 0
dp[node] = func(dp[node] * (len(self.tree[node]) - 1), inv[node]) / len(self.tree[node])
return dp
'''
def rerooting(self, func, merge, ti, ei):
dp = [ti for _ in range(self.n)]
lt = [ei for _ in range(self.n)]
rt = [ei for _ in range(self.n)]
inv = [ei for _ in range(self.n)]
self.setroot(0)
for node in self.order[::-1]:
tmp = ti
for adj in self.tree[node]:
if self.parent[adj] == node:
lt[adj] = tmp
tmp = func(tmp, dp[adj])
tmp = ti
for adj in self.tree[node][::-1]:
if self.parent[adj] == node:
rt[adj] = tmp
tmp = func(tmp, dp[adj])
dp[node] = tmp
for node in self.order:
if node == 0:
continue
merged = merge(lt[node], rt[node])
par = self.parent[node]
inv[node] = func(merged, inv[par])
dp[node] = func(dp[node], inv[node])
return dp
'''
import sys
input = sys.stdin.readline
N = int(eval(input()))
E = [tuple(map(int,input().split())) for _ in range(N - 1)]
T = Tree(N, E)
ti = 0.0
ei = -1.0
func = lambda x, y: x + y + 1.0
merge = lambda x, y: x + y
D = T.rerooting(func, merge, ti, ei)
res = []
for i in range(N):
res.append(D[i])
print(('\n'.join(map(str, res)))) | p03754 |
import sys
input = sys.stdin.readline
from collections import deque, Counter
N = int(input())
X = [[] for i in range(N)]
L = [0]*N
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
L[x-1] += 1
L[y-1] += 1
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
C = Counter(P)
##### Settings
unit = 0
merge = lambda a, b: a + b
adj_bu = lambda a, i: (a+1)/C[P[i]]
adj_td = lambda a, i, p: ((XX[P[i]]*L[P[i]]-XX[i]*C[P[i]])/max(1,L[P[i]]-1)+1)/max(1,C[i])
adj_fin = lambda a, i: a*max(1,C[i])/L[i]
#####
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in R[1:][::-1]:
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_fin(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in reversed(X[i]):
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_fin(merge(ME[j], TD[j]), j)
print(*XX, sep = "\n")
| import sys
input = sys.stdin.readline
from collections import deque, Counter
N = int(input())
X = [[] for i in range(N)]
L = [0]*N
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
L[x-1] += 1
L[y-1] += 1
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
C = Counter(P)
##### Settings
unit = 0
merge = lambda a, b: a + b
adj_bu = lambda a, i: (a+1)/C[P[i]]
adj_td = lambda a, i, p: ((XX[p]*L[p]-XX[i]*C[p])/max(1,L[p]-1)+1)/max(1,C[i])
adj_fin = lambda a, i: a*max(1,C[i])/L[i]
#####
ME = [unit] * N
XX = [0] * N
TD = [unit] * N
for i in R[1:][::-1]:
XX[i] = adj_bu(ME[i], i)
p = P[i]
ME[p] = merge(ME[p], XX[i])
XX[R[0]] = adj_fin(ME[R[0]], R[0])
for i in R:
ac = TD[i]
for j in X[i]:
TD[j] = ac
ac = merge(ac, XX[j])
ac = unit
for j in reversed(X[i]):
TD[j] = adj_td(merge(TD[j], ac), j, i)
ac = merge(ac, XX[j])
XX[j] = adj_fin(merge(ME[j], TD[j]), j)
print(*XX, sep = "\n")
| p03754 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
fl = defaultdict(lambda : 0)
fr = defaultdict(lambda : 0)
def dfs(x):
sx = s[x]
ex = e[x]
nsx = sx-1
for y in v[x]:
if ans[y]:continue
sy,ey = s[y],e[y]
if nsx:
nex = ((ex-1)*sx-ey)/nsx+1
else:
nex = 1
nsy = sy+1
ney = ((ey-1)*sy+nex)/nsy+1
ans[y] = ney
s[x] = nsx
e[x] = nex
s[y] = nsy
e[y] = ney
dfs(y)
s[x] = sx
e[x] = ex
s[y] = sy
e[y] = ey
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
q = [0]
q2 = []
s = [0]*n
e = [0]*n
e[0] = 1
while q:
x = q.pop()
for y in v[x]:
if not e[y]:
s[x] += 1
e[y] = 1
q.append(y)
q2.append((y,x))
while q2:
y,x = q2.pop()
e[x] += e[y]/s[x]
ans = [0]*n
ans[0] = e[0]
dfs(0)
for i in ans:
print((i-1))
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dfs(x):
sx = s[x]
ex = e[x]
nsx = sx-1
for y in v[x]:
if ans[y]:continue
sy,ey = s[y],e[y]
if nsx:
nex = ((ex-1)*sx-ey)/nsx+1
else:
nex = 1
nsy = sy+1
ney = ((ey-1)*sy+nex)/nsy+1
ans[y] = ney
s[x] = nsx
e[x] = nex
s[y] = nsy
e[y] = ney
dfs(y)
s[x] = sx
e[x] = ex
s[y] = sy
e[y] = ey
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
q = [0]
q2 = []
s = [0]*n
e = [0]*n
e[0] = 1
while q:
x = q.pop()
for y in v[x]:
if not e[y]:
s[x] += 1
e[y] = 1
q.append(y)
q2.append((y,x))
while q2:
y,x = q2.pop()
e[x] += e[y]/s[x]
ans = [0]*n
ans[0] = e[0]
dfs(0)
for i in ans:
print((i-1))
return
#Solve
if __name__ == "__main__":
solve()
| p03754 |
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
parent[start] = -1
while stack:
v = stack[-1]
marker = 0
for u in edge[v]:
if u==parent[v]:
continue
if parent[u]==N: #子へ降ろす
marker = 1
parent[u]=v
stack.append(u)
else: #子から吸い上げる
pass
#吸い上げる際の個々の処理
ans[v] += ans[u]+1
if marker==0:
stack.pop()
if v==start:
#根へ吸い上げる時のまとめ処理
ans[v] /= len(edge[v])
elif ans[v]>0:
ans[v] /= len(edge[v])-1
return
def dfs2(start):
stack = [start]
parent = [N]*N
parent[start] = -1
p_value = [0]*N
while stack:
v = stack.pop()
for i,u in enumerate(edge[v]):
if u==parent[v]:
continue
parent[u] = v
if len(edge[v])==1:
p_value[u] = 0
else:
p_value[u] = (ans[v]*len(edge[v])-(ans[u]+1))/(len(edge[v])-1)
ans[u] *= len(edge[u])-1
ans[u] += p_value[u]+1
ans[u] /= len(edge[u])
stack.append(u)
return
ans = [0]*N
dfs(0)
dfs2(0)
print(*ans, sep='\n')
| import sys,os,io
# input = sys.stdin.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
parent[start] = -1
while stack:
v = stack[-1]
marker = 0
for u in edge[v]:
if u==parent[v]:
continue
if parent[u]==N: #子へ降ろす
marker = 1
parent[u]=v
stack.append(u)
else: #子から吸い上げる
pass
#吸い上げる際の個々の処理
ans[v] += ans[u]+1
if marker==0:
stack.pop()
if v==start:
#根へ吸い上げる時のまとめ処理
ans[v] /= len(edge[v])
elif ans[v]>0:
ans[v] /= len(edge[v])-1
return
def dfs2(start):
stack = [start]
parent = [N]*N
parent[start] = -1
p_value = [0]*N
while stack:
v = stack.pop()
for i,u in enumerate(edge[v]):
if u==parent[v]:
continue
parent[u] = v
if len(edge[v])==1:
p_value[u] = 0
else:
p_value[u] = (ans[v]*len(edge[v])-(ans[u]+1))/(len(edge[v])-1)
ans[u] *= len(edge[u])-1
ans[u] += p_value[u]+1
ans[u] /= len(edge[u])
stack.append(u)
return
ans = [0]*N
dfs(0)
dfs2(0)
print(*ans, sep='\n')
| p03754 |
import itertools
[n,k] = [int(x) for x in input().split()]
data = [int(x) for x in input().split()]
kumi = list(itertools.combinations(list(range(n)), k))
answer = sum(data)
for comb in kumi:
total = 0
for x in comb:
total += data[x]
if total < answer:
answer = total
print(answer)
| [n,k] = [int(x) for x in input().split()]
data = [int(x) for x in input().split()]
data.sort()
print((sum(data[:k]))) | p02628 |
def main():
N , K = list(map(int, input().split()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
import itertools
p = itertools.permutations(A_list, K)
ans = 100000000000
for val in p :
ans_new = sum(val)
if ans_new < ans :
ans = ans_new
#print(val)
print(ans)
if __name__ == '__main__':
main()
| def main():
N , K = list(map(int, input().split()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
A_list.sort()
#print(A_list)
ans = 0
for i in range(0,K) :
ans = ans + A_list[i]
print(ans)
if __name__ == '__main__':
main() | p02628 |
import sys
N, K = list(map(int, sys.stdin.readline().strip().split()))
P = list(map(int, sys.stdin.readline().strip().split()))
ans = 0
for i, p in enumerate(sorted(P)):
if i == K:
break
ans += p
print(ans) | import sys
N, K = list(map(int, sys.stdin.readline().split()))
P = list(map(int, sys.stdin.readline().split()))
P.sort()
print((sum(P[0:K]))) | p02628 |
l=list(map(int,open(0).read().split()));print((sum(sorted(l[2:])[:l[1]]))) | a,b,*l=list(map(int,open(0).read().split()));print((sum(sorted(l)[:b]))) | p02628 |
import itertools
n,k = list(map(int,input().split()))
p = [int(i) for i in input().split()]
ans = []
combi = list(itertools.combinations(p,k))
for i in range(len(combi)) :
ans.append(sum(combi[i]))
print((min(ans))) | n,k = list(map(int,input().split()))
p = [int(i) for i in input().split()]
p.sort()
s = 0
for i in range(k) :
s += p[i]
print(s) | p02628 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(k):
ans+=a[i]
print(ans) | n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
ans=0
for i in range(k):
ans+=p[i]
print(ans) | p02628 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
def bubblesort(l):
for index in range(len(l)-1, 0, -1):
for low in range(index):
if l[low] > l[low+1]:
tmp = l[low+1]
l[low+1] = l[low]
l[low] = tmp
return l
bubblesort(P)
sum = 0
for i in range(K):
sum = sum + P[i]
print(sum) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
#print(p)
sum = 0
for i in range(K):
sum = sum + p[i]
print(sum) | p02628 |
import itertools
n,k=list(map(int,input().split()))
price=list(map(int,input().split()))
n_list=[]
for com in itertools.combinations(price,k):
s=sum(com)
n_list.append(s)
print((min(n_list)))
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
print((sum(sorted(p)[:K]))) | p02628 |
import itertools
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
l = [sum(i) for i in itertools.combinations(p, K)]
print((min(l))) | N, K = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:K]))) | p02628 |
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
ans = 0
for i in range(K):
ans += p[i]
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
print((sum(p[: K]))) | p02628 |
# import sys
# input = sys.stdin.readline
# import re
import itertools
def main():
n, k = input_list()
p = input_list()
pp = []
for v in itertools.combinations(p, k):
pp.append(sum(v))
print((min(pp)))
def count_tento(l, cur):
count = 0
for v in l:
if v > cur:
count += 1
return count
def input_list():
return list(map(int, input().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
if __name__ == '__main__':
main()
| # import sys
# input = sys.stdin.readline
# import re
import itertools
def main():
n, k = input_list()
p = input_list()
p.sort()
print((sum(p[:k])))
def count_tento(l, cur):
count = 0
for v in l:
if v > cur:
count += 1
return count
def input_list():
return list(map(int, input().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
if __name__ == '__main__':
main()
| p02628 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,K = list(map(int,S().split()))
p = LI()
p = sorted(p)
ans = 0
for i in range(K):
ans += p[i]
print(ans) | import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def S(): return sys.stdin.readline().rstrip()
N,K = list(map(int,S().split()))
p = LI()
p = sorted(p)
print((sum(p[i] for i in range(K)))) | p02628 |
#!/usr/bin/env python3
import sys
from itertools import chain
from itertools import combinations as comb
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
answer = min(list(map(sum, comb(p, K))))
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K, p = map(int, line.split())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, K, p)
print(answer)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from itertools import chain
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
p = sorted(p)
return sum(p[:K])
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K, p = map(int, line.split())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, K, p)
print(answer)
if __name__ == "__main__":
main()
| p02628 |
import itertools
total =[]
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in itertools.combinations(p, K):
total.append(sum(i))
print((min(total)))
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
m = []
for i in range(K):
a = min(p)
m.append(a)
p.remove(a)
print((sum(m))) | p02628 |
import itertools
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = 1000000
for v in itertools.combinations(p, K):
tmp = sum(v)
if ans > tmp:
ans = tmp
print(ans) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans=0
p.sort()
for i in range(K):
ans += p[i]
print(ans) | p02628 |
import itertools
N, K= list(map(int,input().split()))
p = list(map(int, input().split()))
ans = 1000000
for i in itertools.combinations(p, K):
s = sum(i)
ans = min(ans, s)
print(ans)
| import itertools
N, K= list(map(int,input().split()))
p = list(map(int, input().split()))
p.sort()
ans = sum(p[:K])
print(ans)
| p02628 |
import itertools
n, k = list(map(int, input().split()))
prices = list(map(int, input().split()))
ans = 1000000
for i in itertools.permutations(prices, k):
ans = min(ans, sum(i))
print(ans) | import itertools
n, k = list(map(int, input().split()))
prices = list(map(int, input().split()))
prices = sorted(prices)
print((sum(prices[:k]))) | p02628 |
n,k=list(map(int,input().split()))
t=list(map(int,input().split()))
t.sort()
ans=0
for i in range(k):
ans+=t[i]
print(ans)
| n,k=list(map(int,input().split()))
t=[int(i) for i in input().split()]
t.sort()
print((sum(t[:k]))) | p02628 |
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
import itertools
c = itertools.combinations(p, K)
L = [sum(item) for item in c]
print((min(L))) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
a = list(map(int, input().split()))
b = list(map(int, input().split()))
count = 0
result = []
while count < a[1]:
result.append(min(b))
b.remove(min(b))
count += 1
print((sum(result))) | n, k = list(map(int,input().split()))
p = list(map(int, input().split()))
ans = 0
for _ in range(k):
m = min(p)
ans += m
p.remove(m)
print(ans) | p02628 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, k = list(map(int, readline().split()))
a = list(map(int, readline().split()))
a.sort()
print((sum(a[:k])))
if __name__ == '__main__':
main()
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = sum(a[:k])
print(ans) | p02628 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
ans = 0
for p in P[:K]:
ans += p
print(ans)
| N, K = list(map(int, input().split()))
P = sorted(list(map(int, input().split())))
print((sum(P[:K]))) | p02628 |
from itertools import product, permutations, combinations
import math
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = math.inf
for pt in combinations(P, K):
ans = min(ans, sum(pt))
print(ans)
exit()
| from itertools import product, permutations, combinations
import math
N, K = list(map(int, input().split()))
P = list(sorted((list(map(int, input().split())))))
print((sum([P[i] for i in range(K)])))
exit()
| p02628 |
import itertools
S = list(map(int, input().strip().split()))
N = S[0]
K = S[1]
p = list(map(int, input().strip().split()))
lists = [1000000000000]
for l in list(itertools.combinations(p, K)):
sums = sum(list(l))
if sums <= min(lists):
lists.append(sums)
print((min(lists)))
| S = list(map(int, input().strip().split()))
N = S[0]
K = S[1]
p = list(map(int, input().strip().split()))
lists = []
for l in range(K):
lists.append(min(p))
p.remove(min(p))
print((sum(lists)))
| p02628 |
import itertools
N,K = list(map(int,input().split()))
plist = list(map(int,input().split()))
minprice = sum(plist)
sumlist =[]
for v in itertools.permutations(plist, K):
sumlist.append(sum(v))
print((min(sumlist))) | N,K = list(map(int,input().split()))
plist = list(map(int,input().split()))
plist.sort()
sum = 0
for i in range(K):
sum+=plist[i]
print (sum) | p02628 |
import itertools
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
Sigmas = []
for M in itertools.combinations(P,K):
Sigma = sum(list(M))
Sigmas.append(Sigma)
print((min(Sigmas)))
| import itertools
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
Sigma = sorted(P,reverse = False)
print((sum(Sigma[:K])))
| p02628 |
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
cheap = []
for m in range(k):
for i in range(len(l)):
flag = False
for j in range(len(l)):
if l[i] > l[j]:
flag = True
break
if flag == False:
cheap.append(l[i])
l.remove(l[i])
break
print((sum(cheap))) | n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
l.sort()
cheap = l[:k]
print((sum(cheap))) | p02628 |
n, k = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:k]))) | import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
n, k = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:k])))
if __name__ == '__main__':
main() | p02628 |
N,K=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:K])))
| n,k=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:k])))
| p02628 |
NK = input().split()
n = int(NK[0])
k = int(NK[1])
arr = list(map(int, input().split()))
arr.sort()
print((sum(arr[0:k])))
| n, k = input().split()
p = list(map(int, input().split()))
p = sorted(p)
ans = 0
for i in range(int(k)):
ans += p[i]
print(ans)
| p02628 |
import itertools
n, k = list(map(int, input().split()))
p_list = list(map(int, input().split()))
ans = 1000*1000
for i in itertools.permutations(p_list,k):
ans = min(ans, sum(i))
print(ans) | n, k = list(map(int, input().split()))
p_list = list(map(int, input().split()))
p_list_min = sorted(p_list)
ans = sum(p_list_min[0:k])
print(ans) | p02628 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
i=0
while True:
if len(p)==1:
break
if p[i]<=p[i+1]:
i+=1
else:
a=p[i]
p[i]=p[i+1]
p[i+1]=a
i=0
if i==len(p)-1:
break
ans=0
for i in range(k):
ans+=p[i]
print(ans)
| n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
ans=0
if n!=1:
for i in range(k):
min=p[i]
for j in range(i+1,n):
if min>p[j]:
min=p[j]
p[j]=p[i]
p[i]=min
ans+=min
else:
ans=p[0]
print(ans)
| p02628 |
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
if __name__ == "__main__":
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans) | import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
def main():
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans)
if __name__ == "__main__":
main() | p02628 |
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
result = 0
for i in range(k):
result += p[i]
print(result)
|
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[:k])))
| p02628 |
import itertools
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = 10**19
for i in itertools.permutations(p,k):
s = sum(i)
if s < ans:
ans = s
print(ans) | n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
q = sorted(p)
print((sum(q[:k]))) | p02628 |
from itertools import combinations
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
buy = list(combinations(P, K))
sum_money = [sum(b) for b in buy]
print((min(sum_money))) | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
print((sum(P[:K]))) | p02628 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
count=0
p.sort()
for i in range(k):
count+=p[i]
print(count) | n,k=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:k]))) | p02628 |
from itertools import combinations as comb
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
min=None
for x in comb(list(range(n)),k):
sm=0
for i in range(len(x)):
sm+=p[x[i]]
if not min : min=sm
if sm<min : min=sm
print(min) | n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
sm=sum(p[:k])
print(sm) | p02628 |
from itertools import combinations
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
com = list(combinations(p,k))
ans = list(map(sum,com))
print((min(ans))) | n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
i += 1
print(ans) | p02628 |
import itertools
def main():
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
min_ = float('inf')
all_ = list(range(N))
for items in itertools.combinations(all_, K):
sum_ = sum([P[i] for i in items])
min_ = min(min_, sum_)
print(min_)
if(__name__ == '__main__'):
main() | def main():
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
print((sum(P[:K])))
if(__name__ == '__main__'):
main() | p02628 |
import itertools
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
t = list(list(itertools.combinations(A,K)))
ans = sum(t[0])
for i in t:
ans = min(ans,sum(i))
print(ans)
| N,K = list(map(int,input().split()))
A = sorted(map(int,input().split()))
print((sum(A[:K])))
| p02628 |
N,K=list(map(int,input().split()))
P=sorted(map(int,input().split()))
r=0
for i in range(K):
r+=P[i]
print(r) | N,K=list(map(int,input().split()))
P=sorted(map(int,input().split()))
print((sum(P[:K]))) | p02628 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = float("inf")
for i in range(1 << len(P)):
sum = 0
cnt = 0
for j in range(len(P)):
if (i >> j) & 1 == 1:
sum += P[j]
cnt += 1
if cnt == K:
ans = min(ans, sum)
print(ans)
| N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P = sorted(P)
print((sum(P[:K])))
| p02628 |
x,y = list(map(int,input().split()))
n = sorted(list(map(int,input().split())))
print((sum(n[:y]))) | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | p02628 |
N,K=list(map(int,input().split()))
p=sorted(map(int,input().split()))
print((sum(p[:K]))) | N, K = list(map(int, input().split()))
p = sorted(map(int, input().split()))
print((sum(p[0:K]))) | p02628 |
N, K = list(map(int, input().split()))
p = sorted(map(int, input().split()))
print((sum(p[:K]))) | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
print((sum(sorted(p)[0:K]))) | p02628 |
A = list(map(int, input().split()))
B = list(map(int, input().split()))
import itertools
l=[]
for v in itertools.combinations(B, A[1]):
l.append(sum(v))
print((min(l))) | A = list(map(int, input().split()))
B = list(map(int, input().split()))
B.sort()
print((sum(B[:A[1]])))
| p02628 |
import math
import sys
import itertools
from math import gcd
from math import sqrt
from sys import stdin
def input() : return stdin.readline().rstrip()
def mips():
return list(map(int,input().split()))
def ii():
return int(eval(input()))
sys.setrecursionlimit(10**9)
N,K = mips()
ans = 10**9
P = [p for p in mips()]
L = list(map(list,itertools.permutations(P,K)))
for el in L:
ans = min(ans,sum(el))
print(ans)
| import math
import sys
import itertools
from math import gcd
from math import sqrt
from sys import stdin
def input() : return stdin.readline().rstrip()
def mips():
return list(map(int,input().split()))
def ii():
return int(eval(input()))
sys.setrecursionlimit(10**9)
N,K = mips()
ans = 0
P = [p for p in mips()]
P.sort()
for i in range(K):
ans += P[i]
print(ans)
| p02628 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
s = 0
for i in range(k):
s += a[i]
print(s) | n,k = list(map(int,input().split()))
p = [int(x) for x in input().split()]
p.sort()
s = 0
for i in range(k):
s+=p[i]
print(s)
| p02628 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans)
| n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
ps.sort()
ans = sum(ps[:k])
print(ans)
| p02628 |
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction
n, k = list(map(int, input().split()))
nums = list(map(int, stdin.readline().split()))
nums.sort()
print((sum(nums[:k])))
| n, k = list(map(int, input().split()))
nums = list(map(int, input().split()))
print((sum(sorted(nums)[:k]))) | p02628 |
from itertools import combinations
n,k = list(map(int,input().split()))
list1 = list(map(int,input().split()))
list2 = []
for i in combinations(list1,k) :
list2.append(sum(i))
print((min(list2))) | from itertools import combinations
n,k = list(map(int,input().split()))
list1 = list(map(int,input().split()))
print((sum(sorted(list1)[:k]))) | p02628 |
import itertools
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
# tmp = itertools.combinations_with_replacement(P, K)
tmp = itertools.combinations(P, K)
hoge = []
for i in tmp:
hoge.append(sum(i))
print((min(hoge)))
| # import itertools
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
# tmp = itertools.combinations_with_replacement(P, K)
# tmp = itertools.combinations(P, K)
P.sort()
print((sum(P[0:K])))
# hoge = []
# for i in tmp:
# hoge.append(sum(i))
# print(min(hoge))
| p02628 |
n, k = list(map(int, input().split()))
price_list = list(map(int, input().split()))
sum = 0
min_index = 0
for i in range(k):
min_index = price_list.index(min(price_list))
sum += price_list.pop(min_index)
print(sum) | n, k = list(map(int, input().split()))
price_list = list(map(int, input().split()))
price_list.sort()
sum = 0
for i in range(k):
sum += price_list[i]
print(sum) | p02628 |
import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
min_ = float('inf')
combi = itertools.combinations(p, k)
for c in combi:
min_ = min(min_, sum(c))
print(min_) | n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p = sorted(p)
ans = sum(p[:k])
print(ans) | p02628 |
from itertools import combinations
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
res = 10**16
for t in combinations(list(range(N)), K):
res = min(res, sum([P[i] for i in t]))
print(res)
| N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
P.sort()
print((sum(P[:K]))) | p02628 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | import sys
def Ii():return int(sys.stdin.readline())
def Mi():return list(map(int,sys.stdin.buffer.readline().split()))
def Li():return list(map(int,sys.stdin.buffer.readline().split()))
n,k = Mi();
p = Li();
p.sort();
print((sum(p[:k])))
| p02628 |
from itertools import combinations
N,K=list(map(int, input().split()))
P=list(map(int, input().split()))
ans=float('INF')
L=list(combinations(list(range(N)),K))
for a in L:
sums=0
for i in range(K):
sums+=P[a[i]]
# print(sums)
ans=min(ans,sums)
print(ans) | N,K=list(map(int, input().split()))
P=list(map(int, input().split()))
P.sort()
L=P[:K]
print((sum(L))) | p02628 |
import itertools
N,K,*p = list(map(int,open(0).read().split()))
print((min([sum(x) for x in itertools.combinations(p,K)]))) | N,K,*p = list(map(int,open(0).read().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
N,K = list(map(int,input().split()))
P = sorted(list(map(int,input().split())))
print((sum(P[:K]))) | N,K = list(map(int,input().split()))
print((sum(sorted(list(map(int,input().split())))[:K]))) | p02628 |
def resolve():
import itertools
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
minA = 10**9
for a in itertools.combinations(A, K):
minA = min(minA, sum(a))
print(minA)
resolve()
| def resolve():
N, K = [int(i) for i in input().split()]
A = sorted([int(i) for i in input().split()])
sumA = 0
for a in A[:K]:
sumA += a
print(sumA)
resolve()
| p02628 |
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n,k,p_lst):
pp_lst = sorted(p_lst)
return sum(pp_lst[0:k])
def main():
n,k = list(map(int, input().split()))
p_lst = list(map(int, input().split()))
ans = str(solve(n,k,p_lst))
print(ans)
return ans
### DEBUG I/O ###
_DEB = 0 # 1:ON / 0:OFF
_INPUT = """\
5 4
50 100 80 120 80
"""
_EXPECTED = """\
210
"""
def logd(str):
"""usage:
if _DEB: logd(f"{str}")
"""
if _DEB: print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
ans = main()
if _DEB:
print()
if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
else: print(f"!! Failed... !!\nANSWER: {ans}\nExpected: {_EXPECTED}") | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | p02628 |
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p = sorted(p)
ans = 0
for i in range(k):
ans += p[i]
print(ans) | n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
A = sorted(A)
ans = 0
for i in range(k):
ans += A[i]
print(ans) | p02628 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
li = []
for i in range(n):
li.append(p[i-1])
li_int = sorted([int(n) for n in li])
li_ans = li_int[:k]
print((sum(li_ans))) | n, k = list(map(int, input().split()))
p = list(map(int,input().split()))
p.sort()
list = []
for i in range(k):
list.append(p[i])
print((sum(list))) | p02628 |
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
# combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce
mod = int(1e9+7)
# mod = 998244353
INF = 1<<50
def readInt():
return list(map(int,input().split()))
def main():
n,k = readInt()
p = readInt()
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans)
return
if __name__=='__main__':
main()
| n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans) | p02628 |
N, K, *p = list(map(int, open(0).read().split()))
import itertools
lis = list(itertools.combinations(list(range(N)), K))
mi = 0
for x in lis:
cur = 0
for pos in x:
cur += p[pos]
if mi == 0:
mi = cur
else:
mi = min(mi, cur)
print(mi) | N, K, *p = list(map(int, open(0).read().split()))
sortp = sorted(p)
ans = 0
for x in range(K):
ans += sortp[x]
print(ans)
| p02628 |
import itertools
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = []
for v in itertools.combinations(p,K):
ans.append(sum(v))
print((min(ans))) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
s = sorted(p)
ans = 0
for i in range(N):
ans += s[i]
if i == K-1:
break
print(ans) | p02628 |
n, k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[0:k])))
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
total = 0
for i in range(k):
total += p[i]
print(total) | p02628 |
import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum0 = 100100100
for i in itertools.combinations(p, k):
sum1 = sum(i)
if sum0 > sum1:
sum0 = sum1
print(sum0)
| import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
sum = p[0]
for i in range(1,k):
sum += p[i]
print(sum) | p02628 |
N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
import itertools
l=list(itertools.combinations(p,K))
M=999999999999999999
for i in l:
M=min(M,sum(i))
print(M)
| N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
ans=0
for i in range(K):
ans+=p[i]
print(ans)
| p02628 |
from itertools import combinations
N, K = list(map(int,input().split()))
lists = combinations(list(range(N)),K)
s = list(map(int,input().split()))
min_result = 1000000000000
for li in lists:
total = 0
for l in li:
total += s[l]
min_result = min(min_result,total)
print(min_result) | N, K = list(map(int,input().split()))
s = list(map(int,input().split()))
s.sort()
print((sum(s[:K]))) | p02628 |
from itertools import combinations
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = float('inf')
for buy_list in list(combinations(P, K)):
ans_ = 0
for buy in buy_list:
ans_ += buy
ans = min(ans, ans_)
print(ans) | N, K = list(map(int, input().split()))
p_list = list(map(int, input().split()))
p_list = sorted(p_list)
print((sum(p_list[:K]))) | p02628 |
import itertools
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = itertools.combinations(p, K)
ans = 10**10
for i in c:
ans = min(ans, sum(i))
print(ans) | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.