input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
N, M = [int(x) for x in input().split()]
class value():
def __init__(self, a, b):
self.a = a
self.b = b
def __gt__(self, other):
return self.a > other.a
def __ge__(self, other):
return self.a >= other.a
V = []
for i in range(N):
a, b = [int(x) for x in input().split()]
V.append(value(a, b))
V.sort()
money = 0
i = 0
while True:
v = V[i]
if M <= v.b:
break
else:
money += v.a * v.b
M -= v.b
i += 1
money += v.a * M
print(money)
|
N, M = [int(x) for x in input().split()]
V = [tuple(map(int, input().split())) for i in range(N)]
V.sort()
money = 0
count = 0
for a, b in V:
if count + b < M:
count += b
money += a * b
else:
money += (M - count) * a
break
print(money)
|
p03103
|
import heapq
n,m = list(map(int,input().split(" ")))
li = []
heapq.heapify(li)
for i in range(n):
a,b = list(map(int,input().split(" ")))
for j in range(b):
heapq.heappush(li,a)
result = 0
for i in range(m):
result += heapq.heappop(li)
print(result)
|
n,m = list(map(int,input().split(" ")))
li = []
for i in range(n):
a,b = list(map(int,input().split(" ")))
li.append((a,b))
li.sort()
result = 0
count = 0
flag = False
for i in range(m):
for j in range(li[i][1]):
result += li[i][0]
count += 1
if count == m:
flag = True
break
if flag:
break
print(result)
|
p03103
|
N, M = list(map(int, input().split()))
AB = []
for i in range(N):
AB.append(list(map(int, input().split())))
AB.sort(key=lambda x:x[0])
kane = 0
hon = 0
for i in range(N):
if hon + AB[i][1] < M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
continue
elif hon + AB[i][1] == M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
print(kane)
break
else:
for j in range(AB[i][1]):
hon += 1
kane += AB[i][0]
if hon == M:
print(kane)
break
|
N, M = list(map(int, input().split()))
AB = []
for i in range(N):
AB.append(list(map(int, input().split())))
AB.sort(key=lambda x:x[0])
kane = 0
hon = 0
for i in range(N):
if hon + AB[i][1] < M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
continue
elif hon + AB[i][1] == M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
print(kane)
break
else:
kane += (M - hon) * AB[i][0]
print(kane)
break
|
p03103
|
N, M = list(map(int, input().split()))
AB = []
for i in range(N):
AB.append(list(map(int, input().split())))
AB.sort(key=lambda x:x[0])
kane = 0
hon = 0
for i in range(N):
if hon + AB[i][1] < M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
continue
elif hon + AB[i][1] == M:
hon += AB[i][1]
kane += AB[i][0] * AB[i][1]
print(kane)
break
else:
kane += (M - hon) * AB[i][0]
print(kane)
break
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
AB = sorted(AB, key=lambda x:x[0])
ans = 0
for a, b in AB:
if b <= M:
ans += a * b
M -= b
else:
ans += a * M
break
if M == 0:
break
print(ans)
|
p03103
|
a, b = list(map(int, input().split()))
c = [list(map(int, input().split())) for i in range(a)]
c.sort()
d = 0
e = 0
for i in range(a):
if c[i][1] + d < b:
e += c[i][1] * c[i][0]
d += c[i][1]
else:
e += (b - d) * c[i][0]
d += b - d
print(e)
|
a, b = list(map(int, input().split()))
c = []
for i in range(a):
d, e = list(map(int, input().split()))
c.append([d, e])
c.sort()
g = 0
for i in range(a):
f = min(b, c[i][1])
b -= f
g += f * c[i][0]
if b == 0:
break
print(g)
|
p03103
|
N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
while cnt < M:
shop = shops.pop(0)
if cnt + shop[1] >= M:
ans += (M - cnt) * shop[0]
cnt = M
else:
ans += shop[0] * shop[1]
cnt += shop[1]
print(ans)
|
N, M = list(map(int, input().split()))
shops = [None] * N
for i in range(N):
shops[i] = list(map(int, input().split()))
shops.sort()
cnt = 0
ans = 0
for i in range(N):
shop = shops[i]
ans += shop[0] * shop[1]
cnt += shop[1]
if cnt > M:
ans -= (cnt - M) * shop[0]
break
print(ans)
|
p03103
|
def key_func(n):
return n[0]
n,m = list(map(int, input().split(" ")))
a_b = []
for i in range(n):
a_b.append(list(map(int,input().split(" "))))
money = 0
while m > 0:
ind = a_b.index(min(a_b,key=key_func))
i = min(m,a_b[ind][1])
money = money + a_b[ind][0]*i
m = m - i
del a_b[ind]
print(money)
|
def key_func(n):
return n[0]
n,m = list(map(int, input().split(" ")))
a_b = []
for i in range(n):
a_b.append(list(map(int,input().split(" "))))
a_b.sort(key=key_func)
money = 0
for item in a_b:
i = min(m,item[1])
money = money + item[0]*i
m = m - i
if m <= 0:
break
print(money)
|
p03103
|
n, m = list(map(int, input().split()))
ll = []
for i in range(n):
l = list(map(int, input().split()))
ll.append(l)
i = 0
while i < n-1:
k = i+1
while k <= n-1:
if ll[i][0] > ll[k][0]:
ll[i], ll[k] = ll[k], ll[i]
k += 1
i+=1
s = 0
cst = 0
while m > 0:
cst += ll[s][0] * ll[s][1]
m -= ll[s][1]
s += 1
print((cst + m*ll[s-1][0]))
|
n, m = list(map(int, input().split()))
ll = []
for i in range(n):
l = list(map(int, input().split()))
ll.append(l)
ll.sort()
t = 0
cst = 0
i = 0
while t < m:
t += ll[i][1]
cst += ll[i][0]*ll[i][1]
if t > m:
cst -= ll[i][0]*(t-m)
i += 1
print(cst)
|
p03103
|
N,M = (int(x) for x in input().split())
A=[]
B=[]
for i in range(N):
a,b = (int(x) for x in input().split())
A.append(a)
B.append(b)
ans = 0
while M > 0:
ind = A.index(min(A))
b = B.pop(ind)
if M < b:
b = M
M = 0
else:
M -= b
ans += A.pop(ind) * b
print(ans)
|
N, M = list(map(int, input().split()))
drink = []
for _ in range(N):
drink.append(list(map(int, input().split())))
drink.sort()
ans = 0
while M > 0:
AB = drink.pop(0)
b = min(M, AB[1])
ans += b * AB[0]
M -= b
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
drink = []
for _ in range(N):
drink.append(list(map(int, input().split())))
drink.sort()
ans = 0
while M > 0:
AB = drink.pop(0)
b = min(M, AB[1])
ans += b * AB[0]
M -= b
print(ans)
|
N, M = list(map(int, input().split()))
drink, sumA, sumB = [], 0, 0
for _ in range(N):
A,B = list(map(int, input().split()))
drink.append([A, B])
sumA += A*B
sumB += B
if M == sumB:
print(sumA)
elif M > sumB // 2:
drink.sort(reverse=True)
ans, exM = sumA, sumB - M
while exM > 0:
AB = drink.pop(0)
b = min(exM, AB[1])
ans -= b * AB[0]
exM -= b
print(ans)
else:
drink.sort()
ans = 0
while M > 0:
AB = drink.pop(0)
b = min(M, AB[1])
ans += b * AB[0]
M -= b
print(ans)
|
p03103
|
N, M= list(map(int, input().split()))
A = []
B = []
for i in range(N):
a,b = list(map(int, input().split()))
A.append(a)
B.append(b)
count = 0
cost = 0
while count < M:
pos = A.index(min(A))
cost += A[pos] * min(B[pos],M-count)
count += min(B[pos],M-count)
A.pop(pos)
B.pop(pos)
print(cost)
|
N, M= list(map(int, input().split()))
A = []
for i in range(N):
a = list(map(int, input().split()))
A.append(a)
A = sorted(A)
count = 0
cost = 0
i = 0
while count < M:
cost += A[i][0] * min(A[i][1],M-count)
count += min(A[i][1],M-count)
i += 1
print(cost)
|
p03103
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(N)]
nl = []
for i in range(N):
for j in range(l[i][1]):
nl.append(l[i][0])
sorted_nl = sorted(nl)
ans = 0
for i in range(M):
ans += sorted_nl[i]
print(ans)
|
N, M = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(N)]
sl = sorted(l)
buy = 0
ans = 0
for i in range(N):
for j in range(sl[i][1]):
if buy < M:
ans += sl[i][0]
buy += 1
else:
break
print(ans)
|
p03103
|
N, M = [int(c) for c in input().split()]
shops = []
for _ in range(N):
ab = [int(c) for c in input().split()]
shops.append(ab)
cost = 0
bought = 0
for i in range(N):
if i < N - 1:
target = shops[i][0]
min_i = i
for j in range(i+1, N):
if shops[j][0] < shops[min_i][0]:
min_i = j
shops[min_i], shops[i] = shops[i], shops[min_i]
k = 0
while k < shops[i][1]:
if bought == M:
break
cost += shops[i][0]
k += 1
bought += 1
if bought == M:
break
print(cost)
|
N, M = [int(c) for c in input().split()]
shops = []
for _ in range(N):
ab = [int(c) for c in input().split()]
shops.append(ab)
cost = 0
bought = 0
s_shops = sorted(shops)
for shop in s_shops:
buying = 0
while buying < shop[1]:
if bought == M:
break
cost += shop[0]
buying += 1
bought += 1
if bought == M:
break
print(cost)
|
p03103
|
N, M = list(map(int, input().split()))
e = []
for _ in range(N):
a, b = list(map(int, input().split()))
e.append([a, b])
e = list(sorted(e, key=lambda x: x[0]))
# 安値から
cost = 0
cnt = M
e_i = 0
while cnt > 0:
can_buy = min(cnt, e[e_i][1])
# 必要本数か売っている本数のうち少ない方
cost += can_buy * e[e_i][0]
e[e_i][1] -= can_buy
cnt -= can_buy
if e[e_i][1] == 0:
e_i += 1
print(cost)
|
n, m = list(map(int, input().split()))
e = [tuple(map(int, input().split())) for _ in range(n)]
e.sort() # 金額昇順
ans = 0
rest = m
for a, b in e:
use = min(rest, b)
ans += use * a
rest -= use
if rest == 0:
break
print(ans)
|
p03103
|
from functools import reduce
N, M = list(map(int, input().split()))
A, B = list(zip(*sorted((list(map(int, input().split())) for _ in range(N)))))
ans = reduce(lambda acc, t: (acc[0] + t[0] * min(max(0, M - acc[1]), t[1]), acc[1] + t[1]), list(zip(A, B)), (0, 0))[0]
print(ans)
|
from functools import reduce
# 入力
N, M = list(map(int, input().split()))
A, B = list(zip(*(list(map(int, input().split())) for _ in range(N))))
# 1本あたりの値段が安い店から順に購入
ans = reduce(
lambda acc, t: (
acc[0] + t[0] * min(t[1], M - acc[1]),
acc[1] + t[1]
) if acc[1] < M else
acc,
sorted(zip(A, B)),
(0, 0)
)[0]
# 出力
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
cnt = 0
yen = 0
sortkey = lambda val: val[0]
AB.sort(key=sortkey)
for i in range(N):
for j in range(int(AB[i][1])):
cnt += 1
yen += AB[i][0]
if cnt == M:
print(yen)
break
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
cnt = 0
yen = 0
sortkey = lambda val: val[0]
AB.sort(key=sortkey)
for i in range(N):
if M >= AB[i][1]:
cnt += AB[i][1]
yen += AB[i][0] * AB[i][1]
M -= AB[i][1]
elif M < AB[i][1]:
cnt += M
yen += AB[i][0] * M
M = 0
if M == 0:
print(yen)
break
|
p03103
|
from operator import itemgetter
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(n)]
ab.sort()
#print(ab)
i = 0
ans = 0
while m >0:
if ab[i][1]<=m:
m -= ab[i][1]
ans += ab[i][0]*ab[i][1]
else:
ans += ab[i][0]*m
m = 0
i+=1
print(ans)
|
n,m=list(map(int,input().split()))
ab=[]
for i in range(n):
a,b=list(map(int,input().split()))
ab.append([a,b])
ab.sort()
ans=0
t=m
for i in range(n):
if ab[i][1]<t:
ans+=ab[i][0]*ab[i][1]
t-=ab[i][1]
else:
ans+=ab[i][0]*t
print(ans)
exit()
|
p03103
|
N,M = list(map(int, input().split(" ")))
A=["" for i in range(N)]
B=["" for i in range(N)]
for i in range(N):
A[i],B[i] = list(map(int, input().split(" ")))
total_num=0
total_mon=0
while True:
min_a = min(A)
ind = A.index(min_a)
add = B[ind]
total_num+=add
if total_num>=M:
add = add - (total_num-M)
total_mon+=add*min_a
break
total_mon+=add*min_a
A.pop(ind)
B.pop(ind)
print(total_mon)
|
N,M = list(map(int, input().split(" ")))
AB=["" for i in range(N)]
for i in range(N):
A,B = list(map(int, input().split(" ")))
AB[i] = [A,B]
total_num=0
total_mon=0
AB = sorted(AB)
for i,t in enumerate(AB):
add = t[1]
total_num+=add
if total_num>=M:
add = add - (total_num-M)
total_mon+=add*t[0]
break
total_mon+=add*t[0]
print(total_mon)
|
p03103
|
n,m = list(map(int,input().split()))
cost = []
for i in range(n):
a,b = list(map(int,input().split()))
cost.append([a,b])
cost.sort()
cnt = 0
price = 0
for i in range(n):
if cnt + cost[i][1] <= m:
price += cost[i][0] * cost[i][1]
cnt += cost[i][1]
else:
price += (m-cnt)*cost[i][0]
print(price)
exit()
print(price)
|
n,m = list(map(int,input().split()))
drink = []
for i in range(n):
a,b = list(map(int,input().split()))
drink.append((a,b))
drink.sort()
ans = 0
for i in range(n):
if m == 0:
break
if m >= drink[i][1]:
ans += drink[i][0] * drink[i][1]
m -= drink[i][1]
else:
ans += m*drink[i][0]
m = 0
print(ans)
|
p03103
|
N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort(key=lambda x:x[0])
answer = 0
for ab in AB:
if M - ab[1] <= 0:
answer += M * ab[0]
break
else:
answer += ab[0] * ab[1]
M -= ab[1]
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, M = lr()
AB = [lr() for _ in range(N)]
AB.sort()
drink = 0
answer = 0
for i in range(N):
cost = AB[i][0]
limit = AB[i][1]
if drink + limit < M:
answer += cost * limit
drink += limit
else:
x = M - drink
answer += cost * x
break
print(answer)
|
p03103
|
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M = lr()
AB = [lr() for _ in range(N)]
AB.sort()
drink = 0
answer = 0
for i in range(N):
cost = AB[i][0]
limit = AB[i][1]
if drink + limit < M:
answer += cost * limit
drink += limit
else:
x = M - drink
answer += cost * x
break
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, M = lr()
AB = [lr() for _ in range(N)]
AB.sort()
answer = 0
for cost, num in AB:
if M - num > 0:
answer += cost * num
M -= num
else:
answer += cost * M
break
print(answer)
|
p03103
|
import sys
N, M = list(map(int, input().split()))
lis_A = []
lis_B = []
for _ in range(N):
A, B = list(map(int, input().split()))
lis_A.append(A)
lis_B.append(B)
cost = 0
count = 0
while True:
if N == 1:
print((lis_A[0] * lis_B[0]))
sys.exit()
saiyasu = lis_A.index(min(lis_A))
#ものを買う時に、Mをオーバーするなら処理
if (lis_B[saiyasu] + count) <= M:
cost = ((lis_B[saiyasu] * lis_A[saiyasu]) + cost)
count = lis_B[saiyasu] + count
lis_A.pop(saiyasu)
lis_B.pop(saiyasu)
else:
cost = (((M - count) * lis_A[saiyasu]) + cost)
break
print(cost)
|
import sys
N, M = list(map(int, input().split()))
lis_A = []
lis_B = []
for _ in range(N):
A, B = list(map(int, input().split()))
lis_A.append(A)
lis_B.append(B)
c = list(zip(lis_A, lis_B))
sorted_c = sorted(c)
lis_A, lis_B = list(zip(*sorted_c))
cost = 0
count = 0
while True:
if N == 1:
print((lis_A[0] * lis_B[0]))
sys.exit()
for i in range(len(lis_A)):
if (lis_B[i] + count) <= M:
cost = (lis_A[i]*lis_B[i]) + cost
count = lis_B[i] + count
else:
cost = (((M - count) * lis_A[i]) + cost)
print(cost)
sys.exit()
|
p03103
|
def main():
N, M = list(map(int, input().split()))
A = []
B = []
for i in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
cost = 0
while True:
mc = 0
minp = min(A)
for i in range(N):
if A[i] == minp:
mc = B[i]
A[i] = 10**10
break
if M <= mc:
for i in range(mc):
M -= 1
cost += minp
if M <= 0:
print(cost)
return
else:
M -= mc
cost += minp * mc
return
if __name__ == '__main__':
main()
|
def main():
N, M = list(map(int, input().split()))
S = []
for i in range(N):
a, b = list(map(int, input().split()))
S.append([a, b])
sorted_shop_list = sorted(S, key=lambda x: x[0])
cost = 0
for i in sorted_shop_list:
a = i[0]
b = i[1]
if b < M:
M -= b
cost += a * b
else:
cost += a * M
break
print(cost)
return
if __name__ == '__main__':
main()
|
p03103
|
def main():
N, M = list(map(int, input().split()))
S = []
for i in range(N):
a, b = list(map(int, input().split()))
S.append([a, b])
sorted_shop_list = sorted(S, key=lambda x: x[0])
cost = 0
for i in sorted_shop_list:
a = i[0]
b = i[1]
if b < M:
M -= b
cost += a * b
else:
cost += a * M
break
print(cost)
return
if __name__ == '__main__':
main()
|
N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB = sorted(AB, key = lambda ab:ab[0])
cost = 0
count = 0
for a, b in AB:
if b < M - count:
cost += a * b
count += b
else:
t = M - count
cost += a * t
count += t
break
print(cost)
|
p03103
|
import sys
N,M = list(map(int,input().split()))
shops = dict()
price = []
takahashi = 0
money = 0
for i in range(N):
bottle,stock = list(map(int,input().split()))
if bottle not in shops:
shops[bottle] = 0
shops[bottle] += stock
if bottle not in price:
price.append(bottle)
price.sort()
for y in price:
if shops[y] <= (M-takahashi):
takahashi += shops[y]
money += shops[y]*y
shops[y] = 0
if takahashi == M:
print(money)
sys.exit(0)
else:
money += y*(M-takahashi)
takahashi += (M-takahashi)
shops[y] -= (M-takahashi)
if takahashi == M:
print(money)
sys.exit(0)
|
N,M = list(map(int,input().split()))
shops = []
for i in range(N):
price,B = list(map(int,input().split()))
shops.append([price,B])
shops.sort()
i = 0
money = 0
while M > 0:
if shops[i][1] > M:
money += M*shops[i][0]
break
else:
money += shops[i][1] * shops[i][0]
M -= shops[i][1]
i += 1
print(money)
|
p03103
|
n_store, n_drink = [int(i) for i in input().split()]
stores = [[int(i) for i in input().split()] for _ in range(n_store)] # price, n_stock
stores.sort(key=lambda x: x[0], reverse=True) # priceでソート
ans = 0
while True:
if n_drink == 0:
# n_drinkが0になったら終了
break
store = stores.pop()
price, n_stock = store
n_buy = min(n_stock, n_drink) # stockがなくなるかn_drinkに到達するまで買う
ans += n_buy * price
n_drink -= n_buy
print(ans)
|
n_store, n_drink = [int(i) for i in input().split()]
stores = [[int(i) for i in input().split()] for _ in range(n_store)] # price, n_stock
stores.sort(key=lambda x: x[0], reverse=True) # priceでソート
ans = 0
while n_drink:
store = stores.pop()
price, n_stock = store
n_buy = min(n_stock, n_drink) # stockがなくなるかn_drinkに到達するまで買う
ans += n_buy * price
n_drink -= n_buy
print(ans)
|
p03103
|
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 13 02:42:27 2020
@author: liang
"""
N, M = list(map(int, input().split()))
drinks = list()
for i in range(N):
a, b = list(map(int,input().split()))
for j in range(b):
drinks.append(a)
drinks.sort()
ans = sum(drinks[:M])
print(ans)
|
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 13 02:42:27 2020
@author: liang
"""
N, M = list(map(int, input().split()))
drinks = list()
for i in range(N):
a, b = list(map(int,input().split()))
drinks.append((a,b))
drinks.sort(key = lambda x: x[0])
#print(drinks)
ans = 0
while M > 0:
a, b = drinks.pop(0)
if M <= b:
ans += a*M
M = 0
else:
ans += a*b
M -= b
#print(ans,M)
print(ans)
|
p03103
|
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 13 02:42:27 2020
@author: liang
"""
N, M = list(map(int, input().split()))
drinks = list()
for i in range(N):
a, b = list(map(int,input().split()))
drinks.append((a,b))
drinks.sort(key = lambda x: x[0])
#print(drinks)
ans = 0
while M > 0:
a, b = drinks.pop(0)
if M <= b:
ans += a*M
M = 0
else:
ans += a*b
M -= b
#print(ans,M)
print(ans)
|
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 13 02:42:27 2020
@author: liang
"""
N, M = list(map(int, input().split()))
drinks = list()
for i in range(N):
a, b = list(map(int,input().split()))
drinks.append((a,b))
drinks.sort(key = lambda x: x[0])
#print(drinks)
ans = 0
i = 0
while M > 0:
a, b = drinks[i]
i += 1
if M <= b:
ans += a*M
M = 0
else:
ans += a*b
M -= b
#print(ans,M)
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
AB.sort()
cost = 0
while M > 0:
if AB[0][1] < M:
cost = cost + AB[0][0]*AB[0][1]
M=M-AB[0][1]
AB.pop(0)
else:
cost = cost + AB[0][0]*M
M = 0
print(cost)
|
N, M = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(N)]
S.sort()
ans = 0
k = M
for i in range(N):
if k == 0:
break
elif S[i][1] <= k:
k -= S[i][1]
ans += S[i][0] * S[i][1]
else:
ans += S[i][0] * k
k = 0
print(ans)
|
p03103
|
N,M=list(map(int,input().split()))
AB=[]
for i in range(N):
ab=list(map(int,input().split()))
AB.append(ab)
AB=sorted(AB)
K=M
c=-1
while K>0:
K-=AB[c+1][1]
c+=1
S=[(AB[c][1]+K)*AB[c][0]]
for k in range(c):
S.append(AB[k][0]*AB[k][1])
print((sum(S)))
|
N,M=list(map(int,input().split()))
AB=[]
for i in range(N):
ab=list(map(int,input().split()))
AB.append(ab)
AB=sorted(AB)
c=-1
while M>0:
M-=AB[c+1][1]
c+=1
S=[(AB[c][1]+M)*AB[c][0]]
for k in range(c):
S.append(AB[k][0]*AB[k][1])
print((sum(S)))
|
p03103
|
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
d = {}
for i in range(n):
a,b = list(map(int,input().split()))
if a in list(d.keys()):
d[a] += b
else:
d.setdefault(a,b)
l = list(d.keys())
l.sort()
count = 0
mon = 0
i = 0
while count < m:
mon += l[i]*d[l[i]]
count += d[l[i]]
i += 1
i -= 1
if count > m:
mon -= (count-m)*l[i]
print(mon)
|
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
l = []
for i in range(n):
a,b = list(map(int,input().split()))
l.append([a,b])
l.sort()
i = 0
count = 0
money = 0
while count < m:
count += l[i][1]
money += l[i][0]*l[i][1]
i += 1
i -= 1
if count > m:
money -= (count-m)*l[i][0]
print(money)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
cost = 0
for A, B in sorted(AB):
if M >= B:
cost += A*B
M -= B
if M == 0:
break
else:
cost += A*M
break
print(cost)
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
cost = 0
for A, B in sorted(AB):
if M >= B:
cost += A*B
M -= B
else:
cost += A*M
break
print(cost)
|
p03103
|
N,M = list(map(int,input().split()))
A = sorted([list(map(int,input().split())) for _ in range(N)],key=lambda x:x[0])
cnt = 0
pay = 0
for i in range(N):
if cnt+A[i][1]<=M:
pay += A[i][0]*A[i][1]
cnt += A[i][1]
else:
m = M-cnt
pay += A[i][0]*m
break
print(pay)
|
N,M = list(map(int,input().split()))
A = sorted([list(map(int,input().split())) for _ in range(N)],key=lambda x:x[0])
cnt = 0
cost = 0
for i in range(N):
a,b = A[i]
if cnt+b<=M:
cnt += b
cost += a*b
else:
d = M-cnt
cost += a*d
break
print(cost)
|
p03103
|
li_a = []
ans = 0
N,M = list(map(int,input().split()))
for i in range(N):
a,b = list(map(int,input().split()))
li_a +=[[a,b]]
li_a.sort()
for i in range(N):
if li_a[i][-1] >= M:
ans += M * li_a[i][0]
print(ans)
break
else:
ans += li_a[i][-1] * li_a[i][0]
M -= li_a[i][-1]
|
n,m = list(map(int,input().split()))
ab = [0] * n
ans = 0
for i in range(n):
a,b = list(map(int,input().split()))
ab[i]= (a,b)
ab.sort()
for i in range(n):
if m > ab[i][1]:
m -= ab[i][1]
ans += ab[i][0] * ab[i][1]
else:
ans += ab[i][0] * m
break
print(ans)
|
p03103
|
N,M=(list(map(int,input().split())))
C=[input().split() for i in range(N)]
B=[]
for i in C:
B.append(list(map(int,i)))
B.sort()
k=0
l=0#何番目の店
m=0#その店で買う数
money=0
X=0#持ち数
while M>X:
Min=B[0][0]
for i in B:#どの店で買うか
if Min>=i[0]:
Min=i[0]
l=k
k+=1
for x in range(B[l][1]):#何個かえるか
m+=1
if M==X+m:#max
money+=m*Min
print(money)
break
money+=m*Min
X+=m
B.pop(l)#取り出す
#リセット
k=0
l=0
m=0#その店で買う数
|
N,M=(list(map(int,input().split())))
C=[input().split() for i in range(N)]
B=[]
for i in C:
B.append(list(map(int,i)))
B.sort()
k=0
l=0#何番目の店
m=0#その店で買う数
money=0
X=0#持ち数
for a,b in B:
if(M<=0):
break
if(b<=M):
money+=a*b
else:
money+=M*a
M-=b
print(money)
|
p03103
|
storeNum, canNum = input().split()
storeNum = int(storeNum)
canNum = int(canNum)
costs = [0] * storeNum
maxCanNumbers = [0] * storeNum
for i in range(storeNum):
costs[i], maxCanNumbers[i] = input().split()
costs[i] = int(costs[i])
maxCanNumbers[i] = int(maxCanNumbers[i])
currentStoreHasMoreCans = False
totalPrice = 0
while canNum > 0 and not currentStoreHasMoreCans:
currentStoreHasMoreCans = True
minCostIndex = costs.index(min(costs))
if canNum >= maxCanNumbers[minCostIndex]:
totalPrice = totalPrice + costs[minCostIndex] * maxCanNumbers[minCostIndex]
canNum = canNum - maxCanNumbers[minCostIndex]
else:
totalPrice = totalPrice + costs[minCostIndex] * canNum
canNum = 0
currentStoreHasMoreCans = False
costs[minCostIndex] = 1000000001
print(totalPrice)
|
storeNum, canNum = input().split()
storeNum = int(storeNum)
canNum = int(canNum)
costs = [0] * storeNum
maxCanNumbers = [0] * storeNum
for i in range(storeNum):
costs[i], maxCanNumbers[i] = input().split()
costs[i] = int(costs[i])
maxCanNumbers[i] = int(maxCanNumbers[i])
currentStoreHasMoreCans = False
totalPrice = 0
costs, maxCanNumbers = (list(x) for x in zip(*sorted(zip(costs, maxCanNumbers))))
for i in range(storeNum):
if canNum >= maxCanNumbers[i]:
totalPrice = totalPrice + costs[i] * maxCanNumbers[i]
canNum = canNum - maxCanNumbers[i]
if canNum is 0:
break
else:
totalPrice = totalPrice + costs[i] * canNum
canNum = 0
break
print(totalPrice)
|
p03103
|
# C
n, m = list(map(int, input().split()))
ab = [[int(i) for i in input().split()] for i in range(n)]
ab.sort(key=lambda x: x[0])
index = 0
ans = 0
while m > 0 and index <= n:
if ab[index][1] <= m:
ans += ab[index][0] * ab[index][1]
m -= ab[index][1]
else:
ans += ab[index][0] * m
m = 0
index += 1
print(ans)
|
# C
n, m = list(map(int, input().split()))
ab = [[int(i) for i in input().split()] for i in range(n)]
ab.sort(key=lambda x:x[0])
cost = 0
for i in range(n):
value = ab[i][0]
num = ab[i][1]
if num > m:
cost += value * m
break
else:
cost += value * num
m -= num
print(cost)
|
p03103
|
n, m = list(map(int, input().split()))
a, b = [], []
for i in range(n):
x, y = list(map(int, input().split()))
a.append([x, i])
b.append([y, i])
a.sort()
ans = 0
idx = 0
while True:
if m <= 0:
break
i = a[idx][1]
for j in range(len(b)):
if b[j][1] == i:
kosuu = b[j][0]
if kosuu <= m:
ans += kosuu * a[idx][0]
m -= kosuu
idx += 1
else:
ans += m * a[idx][0]
m = 0
print(ans)
|
n, m = list(map(int, input().split()))
arr = []
for i in range(n):
a, b = list(map(int, input().split()))
arr.append([a, b])
arr.sort()
ans = 0
idx = 0
while True:
if m <= 0:
break
ans += arr[idx][0] * min(arr[idx][1], m)
m -= min(arr[idx][1], m)
idx += 1
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [0] * N
for i in range(N):
AB[i] = list(map(int, input().split()))
AB = sorted(AB)
cnt = 0
ans = 0
for e in AB:
if cnt + e[1] < M:
ans += e[0] * e[1]
cnt += e[1]
else:
ans += e[0] * (M - cnt)
break
print(ans)
|
import sys
N, M = list(map(int, sys.stdin.readline().split()))
AB = [None] * N
for i in range(N):
AB[i] = list(map(int, sys.stdin.readline().split()))
AB.sort()
cnt = 0
ans = 0
for a,b in AB:
if cnt + b < M:
ans += a * b
cnt += b
else:
ans += a * (M - cnt)
break
print(ans)
|
p03103
|
import itertools
import math
import fractions
import functools
import copy
n, m = list(map(int, input().split()))
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
ab.sort(key=lambda x: x[0])
yen = 0
amount = 0
index = 0
for i in range(n):
if amount < m:
yen += ab[i][0] * ab[i][1]
amount += ab[i][1]
index = i
else: break
b = 0
for i in range(index):
b += ab[i][1]
print((yen - ab[index][1]*ab[index][0] + ab[index][0]*(m-b)))
|
def main():
# n = int(input())
n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# s = input()
# h = [int(input()) for _ in rane(n)]
ab = []
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a, b])
cost = 0
temp_i = 0
ab.sort(key=lambda x: x[0])
for i in range(n):
cost += ab[i][0] * ab[i][1]
m -= ab[i][1]
if m <= 0:
temp_i = i
break
if m == 0:
print(cost)
elif m < 0:
cost += ab[temp_i][0] * m
print(cost)
if __name__ == '__main__':
main()
|
p03103
|
N, M = list(map(int, input().split()))
A = [0]*N
for i in range(N):
A[i] = [0,0]
A[i][0],A[i][1] = list(map(int, input().split()))
A.sort()
sum = 0
for a in A:
if a[1]<M:
sum += a[0]*a[1]
M -= a[1]
else:
sum += a[0]*M
print(sum)
exit()
|
def solve():
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
ans = 0
cnt = 0
for a in A:
if cnt + a[1] <= M:
ans += a[1]*a[0]
cnt += a[1]
else:
ans += a[0]*(M-cnt)
break
return ans
print((solve()))
|
p03103
|
N, M = list(map(int, input().split()))
A = []
for i in range(N):
a, b = list(map(int, input().split()))
A.append([a, b])
A.sort(key=lambda x:x[0])
money = 0
cnt = 0
for i in range(N):
for j in range(A[i][1]):
money += A[i][0]
cnt += 1
if cnt == M:
print(money)
break
|
N, M = list(map(int, input().split()))
A = []
for i in range(N):
a, b = list(map(int, input().split()))
A.append([a, b])
A.sort(key=lambda x:x[0])
money = 0
cnt = 0
for i in range(N):
if cnt + A[i][1] < M:
money += A[i][0]*A[i][1]
cnt += A[i][1]
else:
money += A[i][0]*(M-cnt)
print(money)
break
|
p03103
|
# -*- coding:utf-8 -*-
class Shop():
def __init__(self, yen, num):
self.yen = yen # ドリンクの単価
self.num = num # 販売している個数
def solve():
N, M = list(map(int, input().split(" ")))
A, B = [], []
shops = []
for i in range(N):
a, b = list(map(int, input().split(" ")))
A.append(a)
B.append(b)
shops.append(Shop(a, b))
shops = sorted(shops, key=lambda x: x.yen)
ans = 0
rest_count = M
for i in range(N):
if rest_count <= shops[i].num:
ans += shops[i].yen * rest_count
break
ans += shops[i].yen * shops[i].num
rest_count -= shops[i].num
print(ans)
if __name__ == "__main__":
solve()
|
# -*- coding:utf-8 -*-
class Shop():
def __init__(self, v, n):
self.value = v
self.zaiko = n
def solve():
N, M = list(map(int, input().split()))
shops = []
for i in range(N):
a, b = list(map(int, input().split()))
shops.append(Shop(a, b))
shops.sort(key=lambda x: x.value)
rest = M
ans = 0
for i in range(N):
if shops[i].zaiko <= rest:
ans += shops[i].value * shops[i].zaiko
rest -= shops[i].zaiko
else:
ans += shops[i].value * rest
break
print(ans)
if __name__ == "__main__":
solve()
|
p03103
|
N, M = list(map(int, input().split()))
A, B = [0] * N, [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
total = 0
while len(A) > 0:
i = A.index(min(A))
if B[i] == M:
total += A[i] * B[i]
break
elif B[i] > M:
total += A[i] * M
break
else:
total += A[i] * B[i]
M -= B[i]
A.pop(i)
B.pop(i)
print(total)
|
N, M = list(map(int, input().split()))
shop = []
for i in range(N):
shop.append(list(map(int, input().split())))
shop.sort()
total = 0
for i in range(len(shop)):
if shop[i][1] == M:
total += shop[i][0] * shop[i][1]
break
elif shop[i][1] > M:
total += shop[i][0] * M
break
else:
total += shop[i][0] * shop[i][1]
M -= shop[i][1]
print(total)
|
p03103
|
# sys.stdin.readline()
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
c = []
for i in range(n):
a, b = list(map(int, input().split()))
c += [a]*min(b,m)
c.sort()
print((sum(c[:m])))
|
# sys.stdin.readline()
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
ab = []
ans = 0
for i in range(n):
a, b = list(map(int, input().split()))
ab.append((a,b))
ab = sorted(ab)
for c, d in ab:
if m >= d:
ans += c*d
m -= d
else:
ans += c*m
break
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
a = []
b = []
for i in range(n):
k, l = list(map(int, input().split()))
a.append(k)
b.append(l)
sum = 0
money = 0
index = a.index(min(a))
while sum + b[index]< m:
sum += b[index]
money += a[index] * b[index]
del a[index]
del b[index]
index = a.index(min(a))
money += (m - sum) * a[index]
print(money)
|
n, m = list(map(int, input().split()))
a = []
b = []
data = []
for i in range(n):
data.append(list(map(int, input().split())))
data.sort()
sum = 0
money = 0
index = 0
while sum + data[index][1]< m:
sum += data[index][1]
money += data[index][0] * data[index][1]
del data[index]
money += (m - sum) * data[index][0]
print(money)
|
p03103
|
from collections import defaultdict
n,m=list(map(int,input().split()))
price_list=[0]*n
num_dic=defaultdict(int)
def mergesort(a):
def _merge_sort(a, left: int, right: int):
if left < right:
center = (left+right)//2
_merge_sort(a,left,center)
_merge_sort(a,center+1,right)
#pは前半部をbuffにコピーする際のインデックス、jで取り出す
p=j=0
i=k=left
#配列の前半部をbuffにコピー
while i <= center:
buff[p]=a[i]
p+=1
i+=1
#後半部をコピーされた前半部と比較、小さい方をaに格納していく
while i<= right and j < p:
if buff[j] <= a[i]:
a[k]=buff[j]
j+=1
else:
a[k]=a[i]
i+=1
k+=1
while j < p:
a[k] =buff[j]
k+=1
j+=1
n=len(a)
#merge結果を一時的に格納
buff=[None]*n
_merge_sort(a,0,n-1)
del buff
for i in range(n):
a,b=list(map(int,input().split()))
price_list[i]=a
if num_dic[price_list[i]] is None:
num_dic[price_list[i]]=b
else:
num_dic[price_list[i]]+=b
mergesort(price_list)
#同じ値段と違う値段で場合分け
price_sum=0
drink_count=0
for i in range(n):
if i!=0 and price_list[i-1]==price_list[i]:
continue
else:
#i番目のドリンクを買い占め
p=price_list[i]*num_dic[price_list[i]]
price_sum+=p
drink_count+=num_dic[price_list[i]]
if drink_count>=m:
stop=i
break
while drink_count!=m:
drink_count-=1
price_sum-=price_list[i]
print(price_sum)
|
from collections import defaultdict
n,m=list(map(int,input().split()))
price_list=[0]*n
num_dic=defaultdict(int)
def mergesort(a):
def _merge_sort(a, left: int, right: int):
if left < right:
center = (left+right)//2
_merge_sort(a,left,center)
_merge_sort(a,center+1,right)
#pは前半部をbuffにコピーする際のインデックス、jで取り出す
p=j=0
i=k=left
#配列の前半部をbuffにコピー
while i <= center:
buff[p]=a[i]
p+=1
i+=1
#後半部をコピーされた前半部と比較、小さい方をaに格納していく
while i<= right and j < p:
if buff[j] <= a[i]:
a[k]=buff[j]
j+=1
else:
a[k]=a[i]
i+=1
k+=1
while j < p:
a[k] =buff[j]
k+=1
j+=1
n=len(a)
#merge結果を一時的に格納
buff=[None]*n
_merge_sort(a,0,n-1)
del buff
for i in range(n):
a,b=list(map(int,input().split()))
price_list[i]=a
if num_dic[price_list[i]] is None:
num_dic[price_list[i]]=b
else:
num_dic[price_list[i]]+=b
mergesort(price_list)
#同じ値段と違う値段で場合分け
price_sum=0
drink_count=0
for i in range(n):
if i!=0 and price_list[i-1]==price_list[i]:
continue
else:
#i番目のドリンクを買い占め
drink_count+=num_dic[price_list[i]]
if drink_count>m:
drink_count-=num_dic[price_list[i]]
stop=i
break
p=price_list[i]*num_dic[price_list[i]]
price_sum+=p
k=m-drink_count
price_sum+=price_list[i]*k
print(price_sum)
|
p03103
|
a,b=list(map(int,input().split()))
e=[]
for i in range(a):
c,d=list(map(int, input().split()))
e+=[c]*d
e.sort()
print((sum(e[:b])))
|
a,b=list(map(int,input().split()))
e=[]
for i in range(a):
c,d=list(map(int, input().split()))
e+=[[c,d]]
e.sort()
a=i=j=0
while i < b:
a+=(e[j][0]*e[j][1])
i+=e[j][1]
j+=1
print((a-((i-b)*e[j-1][0])))
|
p03103
|
n, m = list(map(int, input().split()))
sum = 0
money = 0
A = list()
B = list()
for i in range(n):
a, b = input().split()
A.append(int(a))
B.append(int(b))
for i in range(n):
index = A.index(min(A))
if(B[index] >= m - sum):
money += A[index] * (m - sum)
sum = m
break
else:
sum += B[index]
money += A[index]*B[index]
del A[index]
del B[index]
print(money)
|
n, m = list(map(int, input().split()))
sum = 0
money = 0
list_ab = list()
for i in range(n):
list_ab.append(list(map(int, input().split())))
list_ab = sorted(list_ab)
for i in range(n):
if(list_ab[i][1] >= m - sum):
money += list_ab[i][0] * (m - sum)
break
else:
sum += list_ab[i][1]
money += list_ab[i][0]*list_ab[i][1]
print(money)
|
p03103
|
# -*- coding: utf-8 -*-
N,M = list(map(int,input().split()))
res_dict = {0:0}
for _ in range(N):
#M本になるまでは買い続け、M本より多くなった場合は、価格の高いものから
a,b = list(map(int,input().split()))
cur_max_price = max(res_dict.keys())
if sum(res_dict.values()) - M < 0 or a < cur_max_price:
#追加操作
if a in res_dict:
res_dict[a] += b
else:
res_dict[a] = b
decrease = sum(res_dict.values()) - M
while decrease > 0:
max_price = max(res_dict.keys())
if decrease < res_dict[max_price]:
res_dict[max_price] -= decrease
break
else:
decrease -= res_dict[max_price]
res_dict.pop(max_price)
print((sum([k * v for k,v in list(res_dict.items())])))
|
# -*- coding: utf-8 -*-
N,M = list(map(int,input().split()))
l = [list(map(int,input().split())) for _ in range(N)]
l = sorted(l, key=lambda x:x[0])
a_cnt = 0
b_cnt = 0
for a,b in l:
if b <= M:
b_cnt += b
M -= b
a_cnt += a*b
elif b > M and M > 0:
b_cnt += M
a_cnt += a*M
break
else:
break
print(a_cnt)
|
p03103
|
n, m = list(map(int, input().split()))
a = []
for _ in range(n):
a.append(list(map(int, input().split())))
a.sort()
pm = s = 0
for item in a:
if pm + item[1] >= m:
print((s + item[0] * (m - pm)))
break
else:
pm += item[1]
s += item[0] * item[1]
|
n, m = list(map(int, input().split()))
a = []
for _ in range(n):
a.append(list(map(int, input().split())))
a.sort()
pm = s = 0
m_minus_1 = m - 1
for item in a:
tmp = pm + item[1]
if tmp > m_minus_1:
print((s + item[0] * (m - pm)))
break
else:
pm = tmp
s += item[0] * item[1]
|
p03103
|
n, m = list(map(int, input().split()))
a = []
for _ in range(n):
a.append(list(map(int, input().split())))
b = sorted(a)
pm = s = 0
m_minus_1 = m - 1
for item in b:
tmp = pm + item[1]
if tmp > m_minus_1:
print((s + item[0] * (m - pm)))
break
else:
pm = tmp
s += item[0] * item[1]
|
n, m = list(map(int, input().split()))
a = []
for _ in range(n):
a.append(list(map(int, input().split())))
a.sort()
pm = s = 0
m_minus_1 = m - 1
for item in a:
pm += item[1]
if pm > m_minus_1:
print((s + item[0] * (m - pm + item[1])))
break
else:
s += item[0] * item[1]
|
p03103
|
from operator import itemgetter
n, m = list(map(int, input().split()))
shops = []
for _ in range(n):
a, b = list(map(int, input().split()))
shops.append((a, b))
shops = sorted(shops, key=itemgetter(0))
drink = [[a] * b for (a, b) in shops]
drink = sum(drink, [])
# print(drink)
answer = sum(drink[:m])
print(answer)
|
from operator import itemgetter
n, m = list(map(int, input().split()))
shops = []
for _ in range(n):
a, b = list(map(int, input().split()))
shops.append((a, b))
shops = sorted(shops, key=itemgetter(0))
rest = m
cost = 0
for a, b in shops:
if rest > b:
cost += a * b
rest -= b
else:
cost += a * rest
break
print(cost)
|
p03103
|
N, M = list(map(int, input().split()))
lis = []
for _ in range(N):
a, b = list(map(int, input().split()))
for l in range(b):
lis.append(a)
lis.sort()
total = 0
for i in range(M):
total = total + lis[i]
print(total)
|
N, M = list(map(int, input().split()))
lis = []
for _ in range(N):
a, b = list(map(int, input().split()))
lis.append((a, b))
def eval(data):
return data[0]
lis.sort(key=eval)
total = 0
num = 0
mark = 0
for i in range(N):
num = num + lis[i][1]
total = total + lis[i][0]*lis[i][1]
if num > M:
mark = i
total = total - lis[i][0]*lis[i][1]
num = num - lis[i][1]
break
total = total + (M - num)*lis[mark][0]
print(total)
|
p03103
|
n, m = list(map(int, input().split()))
a = []
b = []
al = []
ans = 0
for i in range(n):
al.append(list(map(int, input().split())))
for i in range(n):
a.append(al[i][0])
b.append(al[i][1])
ans = 0
while(m > 0):
if m > b[a.index(min(a))]:
m -= b[a.index(min(a))]
ans += a[a.index(min(a))]*b[a.index(min(a))]
b.pop(a.index(min(a)))
a.pop(a.index(min(a)))
else :
ans += a[a.index(min(a))]*m
break
print(ans)
|
n, m = list(map(int, input().split()))
ab = sorted([list(map(int,input().split()))for i in range(n)],key=lambda x:x[0])
ans = 0
i = 0
while m-ab[i][1]>0:
m -= ab[i][1]
ans += ab[i][0]*ab[i][1]
i += 1
ans += ab[i][0] * m
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
a =[]
for i in range(n):
a.append(ab[i][0])
b = []
for i in range(n):
b.append(ab[i][1])
x = 0 #本数
y = 0 #金額
while m > x:
if b[a.index(min(a))] > 0:
y += min(a)
b[a.index(min(a))] -= 1
x += 1
else:
del b[a.index(min(a))]
del a[a.index(min(a))]
continue
print(y)
|
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort(key=lambda x:x[0])
cnt = 0
price = 0
i = 0
while cnt < m:
price += ab[i][0] * ab[i][1]
cnt += ab[i][1]
if cnt > m:
price -= ab[i][0] * (cnt - m)
break
i += 1
print(price)
|
p03103
|
# ABC 121 C
N, M = list(map(int, input().split()))
arr = []
for i in range(N):
arr.append(list(map(int, input().split())))
arr.sort()
sum = 0
for i in range(N):
if arr[i][1] < M:
sum += arr[i][0] * arr[i][1]
M -= arr[i][1]
else:
sum += arr[i][0] * M
break
print(sum)
|
def resolve():
n, m = list(map(int, input().split()))
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append([a, b])
l.sort()
ans = 0
for ab in l:
if ab[1] < m:
m -= ab[1]
ans += ab[0] * ab[1]
else:
ans += ab[0] * m
m = 0
break
print(ans)
return
if __name__ == "__main__":
resolve()
|
p03103
|
N, M = list(map(int, input().split()))
AB = [[] for i in range(N)]
for i in range(N):
AB[i] = list(map(int, input().split()))
remain_drink = M
price = 0
while remain_drink > 0:
min_ind = -1
min_price = 10 ** 10
for i in range(N):
if AB[i][0] < min_price:
min_price = AB[i][0]
min_ind = i
if AB[min_ind][1] <= remain_drink:
price += AB[min_ind][0] * AB[min_ind][1]
remain_drink -= AB[min_ind][1]
else:
price += AB[min_ind][0] * remain_drink
remain_drink = 0
AB[min_ind][0] = 10 ** 10
print(price)
|
N, M = list(map(int, input().split()))
AB = [[] for i in range(N)]
for i in range(N):
AB[i] = list(map(int, input().split()))
AB = sorted(AB)
remain_drink = M
price = 0
i = 0
while remain_drink > 0:
if AB[i][1] <= remain_drink:
price += AB[i][0] * AB[i][1]
remain_drink -= AB[i][1]
else:
price += AB[i][0] * remain_drink
remain_drink = 0
i += 1
print(price)
|
p03103
|
N = list(map(int,input().split()))
drinks = [list(map(int,input().split())) for i in range(N[0])]
counter=0
amount=0
flag=0
for i in range(N[0]):
v = drinks[i]
x = drinks[i][0]
j = i-1
while(j >= 0 and drinks[j][0]>x):
drinks[j+1] = drinks[j]
j -= 1
drinks[j+1] = v
x = drinks[j+1][0]
for i in range(N[0]):
if flag==1:
break
while(drinks[i][1]!=0):
drinks[i][1] -=1
counter +=1
amount += drinks[i][0]
if counter==N[1]:
flag=1
break
print(amount)
|
N = list(map(int,input().split()))
drinks = [list(map(int,input().split())) for i in range(N[0])]
drinks.sort()
counter=0
amount=0
flag=0
for i in range(N[0]):
if flag==1:
break
while(drinks[i][1]!=0):
drinks[i][1] -=1
counter +=1
amount += drinks[i][0]
if counter==N[1]:
flag=1
break
print(amount)
|
p03103
|
n, m = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
a.sort()
ta = 0
tc = 0
for i in range(len(a)):
tc += min(m, a[i][1])
ta += min(m, a[i][1]) * a[i][0]
m -= min(m, a[i][1])
if m == 0:
print(ta)
exit()
|
n, m = list(map(int, input().split()))
ab = sorted([list(map(int, input().split())) for _ in range(n)])
cnt = 0
t = 0
for i in ab:
mi = min(m - cnt, i[1])
t += i[0] * mi
cnt += mi
if cnt == m:
print(t)
exit()
|
p03103
|
a = 0
listA = []
N, M = list(map(int, input().split()))
for i in range(N):
A, B = list(map(int, input().split()))
for i in range(B):
listA.append(A)
listA.sort()
for i in range(M):
a += listA[i]
print(a)
|
a = 0
l = []
f = 0
N, M = list(map(int, input().split()))
for i in range(N):
A, B = list(map(int, input().split()))
l.append([A, B])
l_sorted = sorted(l, key=lambda x: x[0])
while True:
if l_sorted[f][1] < M:
a += l_sorted[f][1] * l_sorted[f][0]
M -= l_sorted[f][1]
f += 1
else:
a += M * l_sorted[f][0]
break
print(a)
|
p03103
|
N,M = list(map(int,input().split()))
ABlist = [list(map(int,input().split())) for n in range(N)]
Alist = [ab[0] for ab in ABlist]
Blist = [ab[1] for ab in ABlist]
sum = 0
flg = False
while True:
min_ = min(Alist)
min_index = Alist.index(min_)
b_num = Blist[min_index]
for i in range(b_num):
M -= 1
sum += min_
if M==0:
flg = True
break
Blist.remove(b_num)
Alist.remove(Alist[min_index])
if flg == True:
break
print(sum)
|
N,M = list(map(int,input().split()))
ABlist = [tuple(map(int,input().split())) for _ in range(N)]
ABlist.sort()
money = 0
for AB in ABlist:
maz_num = AB[1]
maz_pri = AB[0]
add_m = maz_pri*maz_num
if M > 0:
money += add_m
M -= maz_num
if M == 0:
break
if M < 0:
while M!=0:
money -= maz_pri
M += 1
break
print(money)
|
p03103
|
N,M=list(map(int,input().split()))
s=[list(map(int,input().split())) for i in range(N)]
s=sorted(s,key=lambda x:x[0])
ans=0
cnt=0
for i in range(N):
cnt+=s[i][1]
if M >= cnt:
ans+=s[i][0]*s[i][1]
elif M < cnt:
cnt-=s[i][1]
ans+=(M-cnt)*s[i][0]
break
print(ans)
|
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(N)]#[～円,～本]
AB=sorted(AB,key=lambda x:x[0])
ans=0
cnt=0
for i in range(N):
cnt+=AB[i][1]
if M>=cnt:
ans+=AB[i][1]*AB[i][0]
else:
ans+=(M-(cnt-AB[i][1]))*AB[i][0]
break
print(ans)
|
p03103
|
N, M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB = sorted(AB, key=lambda x: x[0])
ans = 0
s = 0
for i in range(N):
t = AB[i][1]
c = min(M-s, t)
ans += c*AB[i][0]
s += c
if s>=M: break
print(ans)
|
N, M = list(map(int,input().split()))
PNs = [list(map(int,input().split())) for _ in range(N)]
#price_and_number_of_drinks
PNs.sort(key=lambda x: x[0])
ans = 0
sum_drinks = 0 #sum of drinks which Takahashi has bought
for i in range(N):
nos = PNs[i][1] #number of drinks at i_th shop
ans += nos*PNs[i][0] #add money he spent at the shop
sum_drinks += nos
if sum_drinks>=M:
ans -= (sum_drinks-M)*PNs[i][0]
break
print(ans)
|
p03103
|
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
ab = [[int(x) for x in input().split()] for _ in range(n)]
ab.sort(key=lambda x: x[0])
temp = sum(ab, []) # 疑似Flatten
a, b = temp[0::2], temp[1::2]
count, index, remainder = 0, 0, 0
for i in range(n):
if count + b[i] < m:
count += b[i]
else:
index = i
remainder = m - count
break
total = a[index] * remainder
total += sum([a[i] * b[i] for i in range(index)])
print(total)
|
# cf. https://rion778.hatenablog.com/entry/2019/03/10/004006
import sys
input = sys.stdin.readline
N, M = [int(i) for i in input().split()]
plices = [[int(i) for i in input().split()] for _ in range(N)]
plices.sort(key = lambda x:x[0])
m = 0
cost = 0
for i in range(N):
if m < M:
buy = min(M - m, plices[i][1])
cost += plices[i][0] * buy
m += buy
else:
break
print(cost)
|
p03103
|
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, M = inpl()
X = sorted([inpl() for _ in range(N)], key=lambda x: x[0])
ans = 0
for a, b in X:
cnt = min(M, b)
ans += a*cnt
M -= cnt
print(ans)
|
def inpl(): return list(map(int, input().split()))
N, M = inpl()
X = sorted([inpl() for _ in range(N)], key=lambda x: -x[0])
ans = 0
while M:
a, b = X.pop()
buy = min(M, b)
ans += a*buy
M -= buy
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
d = []
c = 0
for i in range(n):
d.append(tuple(map(int, input().split())))
d.sort()
while m > 0:
a, b = d[0]
c += min(a * b, m * a)
m -= b
d = d[1:]
print(c)
|
n, m = list(map(int, input().split()))
d = []
c = 0
last = 0
for i in range(n):
d.append(tuple(map(int, input().split())))
d.sort()
while m > 0:
a, b = d[last]
c += min(a * b, m * a)
m -= b
last+=1
print(c)
|
p03103
|
import bisect
n, m = list(map(int, input().split()))
ans=[]
def targetAdd(a):
bisect.insort_left(ans, a)
for i in range(n):
a, b = list(map(int, input().split()))
for j in range(b):
targetAdd(a)
print((sum(ans[:m])))
|
import bisect
n, m = list(map(int, input().split()))
ab=[]
for i in range(n):
ab.append(list(map(int, input().split())))
ab = sorted(ab, key=lambda x: x[0])
def func():
c=0
ans=0
for target in ab:
for i in range(target[1]):
ans+=target[0]
c+=1
if c == m:
return ans
print((func()))
|
p03103
|
from collections import defaultdict
d=defaultdict(int)
N,M=list(map(int,input().split()))
ans=0
t=M
for i in range(N):
a,b=list(map(int,input().split()))
d[a]+=b
while t>0:
for i in range(d[min(d)]):
ans+=min(d)
t-=1
if t==0:break
d.pop(min(d))
print(ans)
|
N,m=list(map(int,input().split()))
L=sorted([list(map(int,input().split())) for _ in range(N)])
ans=0
for i in range(N):
ans+=L[i][0]*min(m,L[i][1])
m-=min(m,L[i][1])
print(ans)
|
p03103
|
from sys import stdin
from operator import itemgetter
input = stdin.readline
N, M = list(map(int, input().split()))
AB = [[int(j) for j in input().split()] for i in range(N)]
def main():
AB.sort(key=itemgetter(0))
num = 0
yen = 0
for i in range(N):
if M < num + AB[i][1]:
yen += AB[i][0] * (M - num)
break
else:
yen += AB[i][0] * AB[i][1]
num += AB[i][1]
print(yen)
return
main()
|
from sys import stdin
N, M = list(map(int, input().split()))
*AB, = list(map(int, stdin.read().split()))
def main():
A = AB[::2]
B = AB[1::2]
Z = list(zip(A, B))
Z = sorted(Z)
num = 0
yen = 0
for a, b in Z:
if M < num + b:
yen += a * (M - num)
break
else:
yen += a * b
num += b
print(yen)
return
main()
|
p03103
|
from sys import stdin
def main():
N, M = list(map(int, input().split()))
*AB, = list(map(int, stdin.read().split()))
A = AB[::2]
B = AB[1::2]
Z = list(zip(A, B))
Z = sorted(Z)
num = 0
yen = 0
for a, b in Z:
if M < num + b:
yen += a * (M - num)
break
else:
yen += a * b
num += b
print(yen)
return
main()
|
from sys import stdin
def main():
N, M = list(map(int, input().split()))
*AB, = list(map(int, stdin.read().split()))
A = AB[::2]
B = AB[1::2]
num = 0
yen = 0
for a, b in sorted(zip(A, B)):
if M < num + b:
yen += a * (M - num)
break
else:
yen += a * b
num += b
print(yen)
return
main()
|
p03103
|
n,m=list(map(int,input().split()))
data=sorted([tuple(map(int,input().split())) for i in range(n)])
ans=0
while True:
if m == 0:
print(ans)
exit()
elif data[0][1]<=m:
ans+=data[0][0]*data[0][1]
m-=data[0][1]
data=data[1:]
else:
ans+=data[0][0]*m
m=0
|
n,m=list(map(int,input().split()))
dataset=sorted([tuple(map(int,input().split())) for i in range(n)])
ans=0
for data in dataset:
if m==0:
print(ans)
exit()
tmp=min(data[1],m)
ans+=tmp*data[0]
m-=tmp
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x: x[0])
ans = 0
bought = 0
for a, b in AB:
m = min(M - bought, b)
bought += m
ans += a * m
print(ans)
|
N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x: x[0])
ans = bought = 0
for a, b in AB:
m = min(M - bought, b)
bought += m
ans += a * m
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
AB.sort(key=lambda x: x[0])
ans = 0
for i in range(N):
if M >= AB[i][1]:
ans += AB[i][0] * AB[i][1]
M -= AB[i][1]
else:
ans += AB[i][0] * M
M = 0
if M == 0:
break
print(ans)
|
N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for i in range(N)]
AB.sort()
ans = 0
for a, b in AB:
if M > b:
M -= b
ans += a*b
else:
ans += a*M
break
print(ans)
|
p03103
|
a = input().split()
a = [int(i) for i in a]
drink_nume = []
drink_price = []
for i in range(a[0]):
b = input().split()
b = [int(i) for i in b]
drink_nume.append(b[1])
drink_price.append(b[0])
count = 0
while (a[1] > 0):
min_index = drink_price.index(min(drink_price))
if drink_nume[min_index] > a[1]:
count += drink_price[min_index] * a[1]
a[1] = 0
else:
count += drink_price[min_index] * drink_nume[min_index]
a[1] -= drink_nume[min_index]
drink_nume.pop(min_index)
drink_price.pop(min_index)
print(count)
|
import sys
a = input().split()
a = [int(i) for i in a]
drink = []
for i in range(a[0]):
b = input().split()
b = [int(i) for i in b]
drink.append(b)
count = 0
drink = sorted(drink, key=lambda x: x[0])
while (a[1] > 0):
if drink[0][1] > a[1]:
count += drink[0][0] * a[1]
a[1] = 0
else:
count += drink[0][0] * drink[0][1]
a[1] -= drink[0][1]
drink.pop(0)
print(count)
|
p03103
|
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
a.sort(key=lambda x:(x[0],x[1]))
c = 0
ans = 0
for i in range(n):
for j in range(a[i][1]):
if c < m:
c += 1
ans += a[i][0]
print(ans)
|
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
a.sort(key=lambda x:(x[0]))
c = 0
ans = 0
for i in a:
if c + i[1] < m:
c += i[1]
ans += i[0]*i[1]
else:
for j in range(i[1]):
c += 1
ans += i[0]
if c >=m:
break
break
print(ans)
|
p03103
|
b=list(map(int,input().split()))
LL=[]
for i in range(b[0]):
LL.append(list(map(int,input().split())))
LL.sort(key=lambda x: x[0])
x=0
z=0
y=b[1]
while y>=0 and not LL==[]:
if y<=LL[0][1]:
print((x+LL[0][0]*y))
break
else:
y-=LL[0][1]
x+=LL[0][1]*LL[0][0]
LL=LL[1:]
|
b=list(map(int,input().split()))
LL=[]
for i in range(b[0]):
LL.append(list(map(int,input().split())))
LL.sort()
x=0
z=0
y=b[1]
i=-1
while y>=0 and not LL==[]:
i+=1
if y<=LL[i][1]:
print((x+LL[i][0]*y))
break
else:
y-=LL[i][1]
x+=LL[i][1]*LL[i][0]
|
p03103
|
N,M = list(map(int,input().split()))
A = []
B = []
ans = 0
for _ in range(N):
i = list(map(int,input().split()))
A.append(i[0])
B.append(i[1])
while M != 0:
ind_ = A.index(min(A))
if M - B[ind_] > 0:
M -= B[ind_]
ans += A[ind_]*B[ind_]
B[ind_] -= B[ind_]
else:
ans += A[ind_]*M
break
if B[ind_] <= 0:
B.pop(ind_)
A.pop(ind_)
print(ans)
|
N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(N)]
AB.sort()
ans = 0
for _ in range(N):
if AB[_][1] >= M:
ans += AB[_][0]*M
break
else:
ans += AB[_][0]*AB[_][1]
M -= AB[_][1]
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
drink = []
ans = 0
for i in range(N):
A, B = list(map(int, input().split()))
for j in range(B):
drink.append(A)
drink.sort()
for i in range(M):
ans += drink[i]
print(ans)
|
N, M = list(map(int, input().split()))
drink = []
sum = 0
count = 0
for i in range(N):
A, B = list(map(int, input().split()))
drink.append([A, B])
drink.sort()
for d in drink:
if count >= M:
break
for i in range(d[1]):
sum += d[0]
count += 1
if count >= M:
break
print(sum)
|
p03103
|
N, M = list(map(int, input().split()))
drink = []
sum = 0
count = 0
for i in range(N):
A, B = list(map(int, input().split()))
drink.append([A, B])
drink.sort()
for d in drink:
if count >= M:
break
for i in range(d[1]):
sum += d[0]
count += 1
if count >= M:
break
print(sum)
|
N, M = list(map(int, input().split()))
AB = [ list(map(int, input().split())) for i in range(N)]
AB.sort()
sum = 0
for ab in AB:
if M <= ab[1]:
sum += ab[0] * M
print(sum)
exit()
else:
sum += ab[0] * ab[1]
M -= ab[1]
|
p03103
|
n, m = list(map(int, input().split()))
A = []
B = []
for i in range(n):
x, y = list(map(int, input().split()))
A.append(x)
B.append(y)
ans = 0
while m > 0:
idx = A.index(min(A))
p = A.pop(idx)
a = B.pop(idx)
if a >= m:
ans += p * m
m -= a
else:
ans += p * a
m -= a
print(ans)
|
n, m = list(map(int, input().split()))
A = []
B = []
for i in range(n):
x, y = list(map(int, input().split()))
A.append(x)
B.append(y)
ans = 0
for price, amount in sorted(zip(A, B)):
ans += price * min(m, amount)
m -= amount
if m <= 0:
break
print(ans)
|
p03103
|
N, M = [int(nm) for nm in input().split()]
AB = []
for n in range(N):
A, B = [int(ab) for ab in input().split()]
AB.append([A, B])
money = 0
while M > 0:
AB_mn = min(AB)
Ai, Bi = AB_mn[0], AB_mn[1]
if Bi <= M:
money += Ai * Bi
M -= Bi
else:
money += Ai * M
M = 0
AB.remove(AB_mn)
print(money)
|
N, M = [int(nm) for nm in input().split()]
AB = []
for n in range(N):
A, B = [int(ab) for ab in input().split()]
AB.append([A, B])
AB.sort()
money = 0
while M > 0:
Ai, Bi = AB[0][0], AB[0][1]
if Bi <= M:
money += Ai * Bi
M -= Bi
else:
money += Ai * M
M = 0
AB.remove(AB[0])
print(money)
|
p03103
|
N, M = list(map(int, input().split()))
drinks = sorted(tuple(map(int, input().split())) for _ in range(N))
ans = 0
for A, B in drinks:
if M > B:
ans += A * B
M -= B
else:
ans += A * M
break
print(ans)
|
import sys
def input():
return sys.stdin.readline().strip()
N, M = list(map(int, input().split()))
drinks = sorted(tuple(map(int, input().split())) for _ in range(N))
ans = 0
for A, B in drinks:
if M > B:
ans += A * B
M -= B
else:
ans += A * M
break
print(ans)
|
p03103
|
N,M = list(map(int, input().split()))
AB_array = []
for _ in range(N):
AB_array.append(list(map(int, input().split())))
count = 0
while True:
select = 0
min_val = AB_array[0][0]
for i in range(1,len(AB_array)):
if AB_array[i][0] < min_val:
min_val = AB_array[i][0]
select = i
if M <= AB_array[select][1]:
count += AB_array[select][0] * M
break
else:
M -= AB_array[select][1]
count += AB_array[select][0] * AB_array[select][1]
AB_array.pop(select)
print(count)
|
N,M = list(map(int, input().split()))
AB_array = []
for _ in range(N):
AB_array.append(list(map(int, input().split())))
AB_array_s = sorted(AB_array, key=lambda x: x[0])
count = 0
for i in range(len(AB_array_s)):
A,B = AB_array_s[i]
if M <= B:
count += A * M
break
else:
M -= B
count += A * B
print(count)
|
p03103
|
N,M = list(map(int, input().split()))
AB = []
for i in range(N) :
tmp_AB = [int(i) for i in input().split()]
AB.append(tmp_AB)
P_list = []
for i in range(N) :
for j in range(AB[i][1]) :
P_list.append(AB[i][0])
P_list_sorted = sorted(P_list)
sum = 0
for i in range(M) :
sum += P_list_sorted[i]
print(sum)
|
N,M = list(map(int, input().split()))
AB = []
for i in range(N) :
tmp_AB = [int(i) for i in input().split()]
AB.append(tmp_AB)
P = sorted(AB)
sum = 0
cnt = 0 # Mに達したら終了
for i in range(len(P)) :
for j in range(P[i][1]) :
if cnt < M:
sum += P[i][0]
cnt += 1
else :
break
if cnt >= M :
break
print(sum)
|
p03103
|
n,m=list(map(int,input().split()))
l=sorted([list(map(int,input().split())) for _ in range(n)])
c=[]
for a,b in l:
for _ in range(b):
c.append(a)
print((sum(c[:m])))
|
n,m=list(map(int,input().split()))
l=sorted([list(map(int,input().split())) for _ in range(n)])
ans=0
for a,b in l:
if b<m:
ans+=(a*b)
m-=b
else:
ans+=(a*m)
break
print(ans)
|
p03103
|
n, m = (int(i) for i in input().split())
lis = []
for i in range(n):
k, v= (int(i) for i in input().split())
lis += [k] * v
lis.sort()
print((sum(lis[:m])))
|
n, m = (int(i) for i in input().split())
a = [[int(i) for i in input().split()] for i in range(n)]
dic = {}
lis = []
a.sort()
ans = 0
for x in a:
if x[1] >= m:
ans += x[0] * m
break
else:
ans += x[0] * x[1]
m -= x[1]
print(ans)
|
p03103
|
def main():
N, M = list(map(int, input().split()))
A, B = [], []
for i in range(N):
a,b = list(map(int, input().split()))
A.append(a)
B.append(b)
# print(A, B)
# 最小のコスト順に買っていけばよい
# 同じコストのときはどうするか
sum = 0
count = 0
flg = False
for i in range(N):
l = A.index(min(A)) # 最安値となっている要素
for j in range(B[l]): # 買い占め
count = count + 1
sum = sum + A[l]
if count == M:
flg = True
break
A[l] = max(A) + 1 # 配列Aを書き換え
if flg:
break
print(sum)
# print(count)
main()
|
def main():
N, M = list(map(int, input().split()))
lis = []
for i in range(N):
lis.append(list(map(int, input().split())))
# 最小のコスト順に買っていけばよい
# 同じコストのときはどうするか
lis.sort() # 一列目をソート，二列目を対応してくれる，同じ値のときは二列目が低い方を優先
sum = 0
count = 0
flg = False
for i in range(N):
if (count+lis[i][1]<M) :
sum = sum + lis[i][0]*lis[i][1]
count = count + lis[i][1] # Bi全部
elif (count+lis[i][1]==M):
sum = sum + lis[i][0]*lis[i][1]
count = count + lis[i][1] # Bi全部
break
else:
for j in range(lis[i][1]):
sum = sum + lis[i][0]
count = count + 1
if count==M:
flg = True
break
if flg:
break
print(sum)
# print(count)
main()
|
p03103
|
[N, M] = list(map(int,input().split()))
A = [0]*N
B = [0]*N
for i in range(N):
[A_tmp, B_tmp] = list(map(int,input().split()))
A[i] = A_tmp
B[i] = B_tmp
tmp = M
ans = 0
while (tmp > 0):
idx_tmp = A.index(min(A))
# break condition
if B[idx_tmp] >= tmp:
ans += tmp*A[idx_tmp]
tmp = 0
else:
ans += A[idx_tmp]*B[idx_tmp]
tmp = tmp - B[idx_tmp]
A.pop(idx_tmp)
B.pop(idx_tmp)
print(ans)
|
[N, M] = list(map(int,input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
AB.sort(key=lambda x:x[0])
tmp = M
ans = 0
for i in range(N):
#break
if tmp <= AB[i][1]:
ans += tmp * AB[i][0]
break
ans += AB[i][0] * AB[i][1]
tmp = tmp - AB[i][1]
print(ans)
|
p03103
|
N, M, = (int(i) for i in input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x:x[0])
money = 0
items = 0
for i in range(N):
if (items + AB[i][1] < M):
money += AB[i][0] * AB[i][1]
items += AB[i][1]
else:
for j in range(1,AB[i][1]+1):
if (items+j == M):
money += AB[i][0] * j
items +=j
print(money)
|
N, M, = (int(i) for i in input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x:x[0])
money = 0
items = 0
for i in range(N):
if (items + AB[i][1] < M):
money += AB[i][0] * AB[i][1]
items += AB[i][1]
else:
j = (M - items)
money += AB[i][0] * j
items +=j
# for j in range(1,AB[i][1]+1):
# if (items+j == M):
# money += AB[i][0] * j
# items +=j
print(money)
|
p03103
|
if __name__ == '__main__':
input_list = list(map(int, input().split()))
N = input_list[0]
M = input_list[1]
A = [0]*N
B = [0]*N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
for i in range(N):
if i == 0:
prices = [A[0]]*B[0]
else:
prices.extend([A[i]]*B[i])
sorted_prices = sorted(prices)
answer = 0
for i in range(M):
answer += sorted_prices[i]
print(answer)
|
if __name__ == '__main__':
input_list = list(map(int, input().split()))
N = input_list[0]
M = input_list[1]
AB = [list(map(int, input().split())) for i in range(N)]
sorted_AB = sorted(AB, key=lambda x:x[0])
answer = 0
cnt = 0
for e in sorted_AB:
pre_cnt = cnt
Ai = e[0]
Bi = e[1]
cnt = min(M, cnt+Bi)
answer += Ai * (cnt - pre_cnt)
if cnt == M:
break
print(answer)
|
p03103
|
N,M = list(map(int,input().split()))
a = []
for i in range(N):
array = list(map(int,input().split()))
a.append(array)
a.sort()
ans = 0
bought = 0
while bought!=M:
b=a.pop(0)
if bought+b[1]>M:
ans+= b[0]*(M-bought)
bought=M
print(ans)
exit()
ans += b[0]*b[1]
bought += b[1]
print(ans)
|
N,M = list(map(int,input().split()))
a = []
for i in range(N):
array = list(map(int,input().split()))
a.append(array)
a.sort()
ans = 0
bought = 0
for i in range(N):
if bought+a[i][1]>M:
ans+= a[i][0]*(M-bought)
bought=M
print(ans)
exit()
ans += a[i][0]*a[i][1]
bought += a[i][1]
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
a_b_list = []
for i in range(n):
a, b = list(map(int, input().split()))
a_b_list.append({'yen':a, 'n_drink':b})
a_b_list.sort(key=lambda x: x['yen'])
n_leftover = m
yen_spent = 0
for i in range(n):
n_drink = a_b_list[i]['n_drink']
yen = a_b_list[i]['yen']
if a_b_list[i]['n_drink'] < n_leftover:
yen_spent += n_drink * yen
n_leftover -= n_drink
else:
yen_spent += n_leftover * yen
print(yen_spent)
exit()
|
N, M = list(map(int, input().split()))
AB_list = [list(map(int, input().split())) for _ in range(N)]
AB_list = sorted(AB_list, key=lambda x: x[0])
sum_cost = 0
n_drink = 0
for AB in AB_list:
A, B = AB
if n_drink + B < M:
n_drink += B
sum_cost += A * B
elif n_drink + B >= M:
sum_cost += A * (M - n_drink)
print(sum_cost)
exit()
|
p03103
|
n,m = list(map(int,input().split()))
a = [0]*n
b = [0]*n
for i in range(n) :
a[i], b[i] = list(map(int,input().split()))
a_order = a.copy()
a_order.sort()
c = m + 0
ans = 0
while c > 0 :
a_index_now = a.index(a_order[0]) + 0
b_now = b[a_index_now] + 0
if c >= b_now :
ans += a_order[0] * b_now
c -= b_now
a.pop(a_index_now)
b.pop(a_index_now)
a_order.pop(0)
else :
ans += a_order[0] * c
c = 0
print(ans)
|
n,m = list(map(int,input().split()))
ls = [0]*n
for i in range(n) :
a,b = list(map(int,input().split()))
ls[i] = [a,b]
ls.sort(key=lambda x:x[0])
c = m + 0
ans = 0
while c > 0 :
if c >= ls[0][1] :
ans += ls[0][0] * ls[0][1]
c -= ls[0][1]
ls.pop(0)
else :
ans += ls[0][0] * c
c = 0
print(ans)
|
p03103
|
n,m=list(map(int,input().split()))
money=[]
for _ in range(n):
a,b=list(map(int,input().split()))
money=money+[a]*b
money.sort()
print((sum(money[:m])))
|
n,m=list(map(int,input().split()))
ab=sorted([list(map(int,input().split())) for _ in range(n)])
ans=0
i=0
while i<n:
if m>=ab[i][1]:
ans+=(ab[i][0])*ab[i][1]
m-=ab[i][1]
i+=1
else:
ans+=(ab[i][0])*(m)
break
print(ans)
|
p03103
|
n,m = list(map(int,input().split()))
# A_2=0
# B_2=0
list_A=[]
list_B=[]
sum_num=0
for i in range(n):
A,B = list(map(int,input().split()))
list_A.append(A)
list_B.append(B)
for i in range(n):
minj = i
for j in range(i,n):
if list_A[j]<list_A[minj]:
minj=j
hokan=list_A[i]
list_A[i]=list_A[minj]
list_A[minj]=hokan
hokan_b=list_B[i]
list_B[i]=list_B[minj]
list_B[minj]=hokan_b
list_AB = []
for i in range(n):
list_AB.append( (list_A[i], list_B[i]))
list_AB.sort()
list_A , list_B = list(zip(*list_AB))
# list_A.sort()
# list_B.sort()
# print(list_A)
# print(list_B)
m_1=m
for i in range(n):
m_2=m_1
m_1=m_1-int(list_B[i])
if m_1<0:
sum_num=sum_num + int(list_A[i])*m_2
else:
sum_num=sum_num +int(list_A[i])*int(list_B[i])
#print(sum_num)
#print("m_1",m_1,"m_2",m_2)
if m_1<0:
break
print(sum_num)
|
n,m = list(map(int,input().split()))
# A_2=0
# B_2=0
list_A=[]
list_B=[]
sum_num=0
for i in range(n):
A,B = list(map(int,input().split()))
list_A.append(A)
list_B.append(B)
list_AB = []
for i in range(n):
list_AB.append( (list_A[i], list_B[i]))
list_AB.sort()
list_A , list_B = list(zip(*list_AB))
# list_A.sort()
# list_B.sort()
# print(list_A)
# print(list_B)
m_1=m
for i in range(n):
m_2=m_1
m_1=m_1-int(list_B[i])
if m_1<0:
sum_num=sum_num + int(list_A[i])*m_2
else:
sum_num=sum_num +int(list_A[i])*int(list_B[i])
#print(sum_num)
#print("m_1",m_1,"m_2",m_2)
if m_1<0:
break
print(sum_num)
|
p03103
|
N,M = (int(i) for i in input().split())
AB = []
values = []
for i in range(N):
A,B = (int(i) for i in input().split())
values.extend([A]*B)
values.sort()
count = 0
ans = 0
for i in range(len(values)):
if count < M:
count +=1
ans += values[i]
else:
break
print(ans)
|
N,M = (int(i) for i in input().split())
AB = []
for i in range(N):
AB.append([int(i) for i in input().split()])
AB = sorted(AB,key=lambda x:x[0])
count = 0
ans = 0
for A,B in AB:
if count + B > M:
ans += A*(M-count)
break
else:
ans += A*B
count += B
print(ans)
|
p03103
|
n,m = input().split()
n,m = int(n),int(m)
price = []
honsu = []
for i in range(n):
a,b = input().split()
price.append(int(a))
honsu.append(int(b))
for j in range(n):
k = j + 1
while(k<n):
if price[j] > price[k]:
temp1,temp2 = price[j],honsu[j]
price[j] = price[k]
honsu[j] = honsu[k]
price[k] = temp1
honsu[k] = temp2
k+=1
money = 0
l = 0
while m > 0:
if(m-honsu[l]>0):
m -= honsu[l]
money += honsu[l] * price[l]
else:
c = abs(m-honsu[l])
m -= honsu[l]-c
money += (honsu[l]-c) * price[l]
l += 1
print(money)
|
n,m = list(map(int,input().split()))
price = []
honsu = []
c = []
for i in range(n):
a,b = list(map(int,input().split()))
c.append([a,b])
c = sorted(c)
price,honsu=list(zip(*c))
money = 0
l = 0
while m > 0:
if(m-honsu[l]>0):
m -= honsu[l]
money += honsu[l] * price[l]
else:
c = abs(m-honsu[l])
m -= honsu[l]-c
money += (honsu[l]-c) * price[l]
l += 1
print(money)
|
p03103
|
N, M = list(map(int, input().split()))
shop = []
for _ in range(N):
a, b = list(map(int, input().split()))
shop.append([a,b])
shop.sort()
cur = 0
cur_v = 0
for a, b in shop:
for i in range(b):
cur += 1
cur_v += a
if cur == M:
print(cur_v)
break
|
N, M = list(map(int, input().split()))
shop = []
for _ in range(N):
a, b = list(map(int, input().split()))
shop.append([a,b])
shop.sort()
cur = 0
cur_v = 0
for a, b in shop:
if cur + b > M:
cur_v += (M - cur) * a
break
else:
cur += b
cur_v += a * b
print(cur_v)
|
p03103
|
import sys
n_shops, n_drinks = list(map(int, input().split()))
shop_info = sorted([tuple(map(int, line.split())) for line in sys.stdin.readlines()])
cost = 0
purchased_n_drinks = 0
for _ in range(len(shop_info)):
info = shop_info.pop(0)
if (purchased_n_drinks + info[1]) >= n_drinks:
cost += ( n_drinks - purchased_n_drinks) * info[0]
break
purchased_n_drinks += info[1]
cost += info[0] * info[1]
print(cost)
|
import sys
readline = sys.stdin.readline
def main():
N, M = list(map(int, readline().rstrip().split()))
AB = [list(map(int, readline().rstrip().split())) for _ in range(N)]
AB.sort()
pro = 0
cost = 0
for a, b in AB:
if pro + b >= M:
cost += (M - pro) * a
break
pro += b
cost += a * b
print(cost)
if __name__ == '__main__':
main()
|
p03103
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.