input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
#import sys
#import numpy as np
#import math
#import itertools
#from fractions import Fraction
#import itertools
from collections import deque
#import heapq
#from fractions import gcd
#input=sys.stdin.readline
n,m=list(map(int,input().split()))
b=[list(map(int,input().split())) for _ in range(n)]
res=0
ans=0
b.sort(key=lambda x: x[0])
for i in range(n):
if res+b[i][1]<=m:
ans+=b[i][0]*b[i][1]
res+=b[i][1]
else:
ans+=b[i][0]*(m-res)
break
print(ans)
|
#python 2.7
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])
res=ans=0
for i in range(n):
if res+ab[i][1]>=m:
ans+=(ab[i][0])*(m-res)
break
else:
ans+=(ab[i][0])*ab[i][1]
res+=ab[i][1]
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
A = []
#B = []
for i in range(N):
# print(i)
# a, b = map(int, input().split())
A.append(list(map(int, input().split())))
# B.append(b)
A.sort(key=lambda x: x[0])
ans = 0
for i in range(N):
if A[i][1] > M:
ans += A[i][0] * M
break
else:
ans += A[i][0] * A[i][1]
M -= A[i][1]
print(ans)
|
N, M = list(map(int, input().split()))
A = []
#B = []
for i in range(N):
# print(i)
# a, b = map(int, input().split())
A.append(list(map(int, input().split())))
# B.append(b)
A.sort(key=lambda x: x[0])
ans = 0
for i in range(N):
if A[i][1] > M:
ans += A[i][0] * M
break
else:
ans += A[i][0] * A[i][1]
M -= A[i][1]
print(ans)
|
p03103
|
import sys
input=sys.stdin.readline
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()
x = 0
for a in A:
if M == 0:
break
while a[1] > 0:
a[1] -= 1
M -= 1
x += a[0]
if M == 0:
break
print(x)
|
import sys
input=sys.stdin.readline
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()
ans = 0
for a,b in A:
if M == 0:
break
n = M if M <= b else b
M -= n
ans += n * a
print(ans)
|
p03103
|
import sys
input=sys.stdin.readline
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()
ans = 0
for a,b in A:
if M == 0:
break
n = M if M <= b else b
M -= n
ans += n * a
print(ans)
|
import sys
input=sys.stdin.readline
def main():
N,M = list(map(int, input().split()))
A = []
for _ in range(N):
a,b = list(map(int, input().split()))
A.append((a,b))
A.sort()
ans = 0
for a,b in A:
if M == 0:
break
n = M if M <= b else b
M -= n
ans += n * a
print(ans)
if __name__ == '__main__':
main()
|
p03103
|
# ABC121C - Energy Drink Collector
import sys
input = sys.stdin.readline
n, m = list(map(int, input().rstrip().split()))
lst = sorted([list(map(int, input().rstrip().split())) for _ in range(n)])
ans = 0
for i in lst:
while i[1] > 0 and m > 0:
ans += i[0]
i[1] -= 1
m -= 1
print(ans)
|
# ABC121C - Energy Drink Collector
import sys
input = sys.stdin.readline
def main():
n, m = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, input().split())) for _ in range(n))
ans = 0
for i in lst:
while i[1] > 0 and m > 0:
ans += i[0]
i[1] -= 1
m -= 1
print(ans)
if __name__ == "__main__":
main()
|
p03103
|
# ABC121C - Energy Drink Collector
import sys
input = sys.stdin.readline
def main():
n, m = list(map(int, input().rstrip().split()))
lst = sorted(list(map(int, input().split())) for _ in range(n))
ans = 0
for i in lst:
while i[1] > 0 and m > 0:
ans += i[0]
i[1] -= 1
m -= 1
print(ans)
if __name__ == "__main__":
main()
|
# ABC121C - Energy Drink Collector
def main():
N, M, *AB = list(map(int, open(0).read().split()))
AB = list(zip(*[iter(AB)] * 2))
AB.sort()
ans = 0
for a, b in AB:
while b > 0 and M > 0:
ans += a
b -= 1
M -= 1
print(ans)
if __name__ == "__main__":
main()
|
p03103
|
N, M = list(map(int, input().split(" ")))
stores = dict()
p = 10000000000
for i in range(N):
if p==1 and stores[p] >= M:
break
Ai, Bi = list(map(int, input().split(" ")))
if Ai in stores:
stores[Ai] += Bi
else:
stores[Ai] = Bi
p = min(p, Ai)
price = 0
while True:
if p in stores:
if M <= stores[p]:
price += p * M
break
else:
price += p * stores[p]
M -= stores[p]
p += 1
print(price)
|
N, M = list(map(int, input().split(" ")))
stores = []
for i in range(N):
Ai, Bi = list(map(int, input().split(" ")))
stores.append((Ai, Bi))
price = 0
for a, b in sorted(stores, key=lambda x: x[0]):
if M <= b:
price += a * M
break
else:
price += a * b
M -= b
print(price)
|
p03103
|
def mergesort(a, left, right):
if left + 1 < right:
mid = int((left + right)/2)
mergesort(a, left, mid)
mergesort(a, mid, right)
merge(a, left, mid, right)
return a
def merge(a, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [a[left + i] for i in range(n1)]
R = [a[mid + i] for i in range(n2)]
L.append(1e10)
R.append(1e10)
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[j]:
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
store_num, drink_num = [int(i) for i in input().split(" ")]
a_list = []
for i in range(store_num):
a, b = [int(i) for i in input().split(" ")]
for j in range(b):
a_list.append(a)
b_list = mergesort(a_list, 0, len(a_list))
ans = 0
for i_ in range(drink_num):
ans += b_list[i_]
print(ans)
|
n, m = list(map(int, input().split()))
a = []
for i in range(n):
i,j = (list(map(int, input().split())))
a += [[i,j]]
a = sorted(a)
count = 0
value = 0
for (i,j) in a:
if count + j >= m:
value += (m - count) * i
break
else:
value += i * j
count += j
print(value)
|
p03103
|
N, M = list(map(int, input().split()))
A_list = []
for i in range(N):
A, B = list(map(int, input().split()))
A_list += [A for i in range(B)]
A_list.sort()
value = sum(A_list[0:M])
print(value)
|
N, M = list(map(int, input().split()))
AB_list = [list(map(int, input().split())) for i in range(N)]
AB_list.sort()
ans, cnt = 0, 0
for a, b in AB_list:
ans += a*b
cnt += b
if cnt > M:
ans = ans-(a*(cnt-M))
break
print(ans)
|
p03103
|
n,m=list(map(int,input().split(" ")))
al=[0 for i in range(n)]
bl=[0 for i in range(n)]
for i in range(n):
al[i],bl[i]=tuple(map(int,input().split(" ")))
have=0
yen=0
while have<m:
k=al.index(min(al))
pri=al.pop(k)
num=bl.pop(k)
have+=num
yen+=pri*num
if have>m:
yen-=(have-m)*pri
print(yen)
|
n,m=list(map(int,input().split(" ")))
l=[]
l=[list(map(int,input().split(" "))) for i in range(n)]
have=0
yen=0
i=0
l.sort(key=lambda x: x[0])
while have<m:
pri=l[i][0]
num=l[i][1]
i+=1
have+=num
yen+=pri*num
if have>m:
yen-=(have-m)*pri
print(yen)
|
p03103
|
# coding: utf-8
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for __ in range(N)]
AB.sort(key=lambda x : x[0])
ans = 0
while M > 0:
if AB[0][1] == 0:
AB = AB[1:]
ans += AB[0][0]
M -= 1
AB[0][1] -= 1
print(ans)
|
# coding: utf-8
# import sys
# input = sys.stdin.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for __ in range(N)]
AB.sort(key=lambda x : x[0])
k = 0
ans = 0
while M > 0:
if M > AB[k][1]:
M -= AB[k][1]
ans += AB[k][0] * AB[k][1]
else:
ans += AB[k][0] * M
break
k += 1
print(ans)
|
p03103
|
# coding: utf-8
# import sys
# input = sys.stdin.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for __ in range(N)]
AB.sort(key=lambda x : x[0])
k = 0
ans = 0
while M > 0:
if M > AB[k][1]:
M -= AB[k][1]
ans += AB[k][0] * AB[k][1]
else:
ans += AB[k][0] * M
break
k += 1
print(ans)
|
# coding: utf-8
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for __ in range(N)]
AB.sort(key=lambda x : x[0])
k = 0
ans = 0
while M > 0:
if M > AB[k][1]:
M -= AB[k][1]
ans += AB[k][0] * AB[k][1]
else:
ans += AB[k][0] * M
break
k += 1
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 += [a]
B += [b]
AA = []
BB = []
while True:
le = len(A)
if le == 0:
break
else:
for i in range(le):
mini = min(A)
if A[i] == mini:
AA += [A[i]]
BB += [B[i]]
del A[i]
del B[i]
break
rest = M
cost = 0
while True:
if rest - BB[0] <= 0:
cost += rest * AA[0]
break
else:
rest -= BB[0]
cost += AA[0] * BB[0]
del AA[0]
del BB[0]
print(cost)
|
N,M = list(map(int,input().split()))
ab = []
for i in range(N):
ab += [list(map(int,input().split()))]
ab.sort()
rest = M
cost = 0
while True:
if rest - ab[0][1] <= 0:
cost += rest * ab[0][0]
break
else:
rest -= ab[0][1]
cost += ab[0][0] * ab[0][1]
del ab[0]
print(cost)
|
p03103
|
N,M = list(map(int,input().split()))
ab = []
for i in range(N):
ab += [list(map(int,input().split()))]
ab.sort()
rest = M
cost = 0
while True:
if rest - ab[0][1] <= 0:
cost += rest * ab[0][0]
break
else:
rest -= ab[0][1]
cost += ab[0][0] * ab[0][1]
del ab[0]
print(cost)
|
n,m = list(map(int,input().split()))
ab = []
for _ in range(n):
ab.append(list(map(int,input().split())))
ab.sort()
ans = 0
for i in range(n):
a,b = ab[i]
if m > b:
m -= b
ans += a * b
else:
ans += a * m
break
#print(m,ans)
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(n)]
num = []
sum = 0
for i in range(n):
for _ in range(l[i][1]):
num.append(l[i][0])
num = sorted(num)
for i in range(m):
sum += num[i]
print(sum)
|
n, m = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(n)]
l.sort(key=lambda x: x[0])
num = 0
ansum = 0
for i in range(n):
if num + l[i][1] < m:
ansum += l[i][0] * l[i][1]
num += l[i][1]
else:
ansum += l[i][0] * (m - num)
break
print(ansum)
|
p03103
|
N, M = list(map(int, input().split()))
Di = []
for i in range(N):
d = list(map(int, input().split()))
Di.append(d)
Di.sort(key=lambda x: x[0])
yen = 0
num = 0
for d in Di:
if num + d[1] >= M:
yen += (M - num) * d[0]
break
num += d[1]
yen += d[0] * d[1]
print(yen)
|
N, M = list(map(int, input().split()))
Ai = [list(map(int, input().split())) for _ in range(N)]
Ai.sort(key=lambda x:x[0])
cost = 0
remain = M
for a in Ai:
if remain == 0:
break
buy_num = min(a[1], remain)
cost += a[0] * buy_num
remain -= buy_num
print(cost)
|
p03103
|
f = lambda : list(map(int,input().split()))
n,m = f()
ll = sorted([list(f()) for _ in range(n)])
ans = 0
for p, c in ll:
ans += p*min(m,c)
m -= c
if m < 1:
break
print(ans)
|
f=lambda:list(map(int,input().split()))
n,m=f()
l=[]
for _ in range(n):
l+=[tuple(f())]
l.sort()
c=0
for a,b in l:
if b<m:
m-=b
c+=a*b
else:
c+=a*m
break
print(c)
|
p03103
|
N,M=list(map(int,input().split()))
k=M
s=0
A=[list(map(int,input().split())) for i in range(N)]
A=sorted(A,key=lambda x:x[0])
while k>0:
for i in range(N):
if k>A[i][1]:
s+=A[i][0]*A[i][1]
k=k-A[i][1]
else:
s+=A[i][0]*k
k=0
print(s)
|
N,M=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(N)]
A=sorted(A,key=lambda x:x[0])
s=0 #本数
t=0 #値段
for i in range(N):
s+=A[i][1]
if M>s:
t+=A[i][0]*A[i][1]
else:
over=s-M
t+=A[i][0]*A[i][1]-A[i][0]*over
break
print(t)
|
p03103
|
N, M = list(map(int, input().split()))
a, b = [], []
ans = 0
INF = float('inf')
for n in range(N):
tmp1, tmp2 = list(map(int, input().split()))
a.append(tmp1)
b.append(tmp2)
count = 0
while count < M:
mindex = a.index(min(a))
buycount = min(b[mindex], M - count)
count += buycount
ans += a[mindex]*buycount
a[mindex] = INF
print(ans)
|
N, M = list(map(int, input().split()))
ans = 0
drink = M
a, b = [], []
INF = float('inf')
for n in range(N):
a.append(list(map(int, input().split())))
a.sort()
for i in a:
if drink > i[1]:
ans += i[0] * i[1]
drink -= i[1]
else:
ans += i[0] * drink
break
print(ans)
|
p03103
|
def main():
N, M = list(map(int, input().split()))
D = [tuple(map(int, input().split())) for _ in range(N)]
D.sort()
ans = 0
while M > 0:
a, b = D.pop(0)
ans += a * min(M, b)
M -= min(M, b)
print(ans)
if __name__ == "__main__":
main()
|
def main():
N, M = list(map(int, input().split()))
D = [tuple(map(int, input().split())) for _ in range(N)]
D.sort()
ans = 0
i = 0
while M > 0:
a, b = D[i]
ans += a * min(M, b)
M -= min(M, b)
i += 1
print(ans)
if __name__ == "__main__":
main()
|
p03103
|
N, M = list(map(int,input().split()))
L = [list(map(int, input().split())) for i in range(N)]
L.sort(key=lambda x: x[0])
c = 0
for i in range(N):
if M <= L[i][1]:
print((c + L[i][0] * M))
exit()
else:
M -= L[i][1]
c += L[i][0] * L[i][1]
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ 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
break
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
A = []
B = []
for i in range(N):
x1,y1=[int(i) for i in input().split()]
A.append(x1)
B.append(y1)
yen = 0
num = 0
while num < M:
a = min(A)
ind = A.index(a)
if num + B[ind] <= M:
yen += a * B[ind]
num += B[ind]
del A[ind]
del B[ind]
else:
yen += a * (M - num)
break
print(yen)
|
N, M = list(map(int, input().split()))
S = []
C = 0
cost = 0
for i in range(N):
a, b = list(map(int, input().split()))
S.append((a, b))
S.sort()
for i in range(N):
if S[i][1] + C < M:
C += S[i][1]
cost += S[i][0] * S[i][1]
else:
cost += (M-C) * S[i][0]
break
print(cost)
|
p03103
|
n, m = (int(_) for _ in input().split())
ab_list = [[int(i) for i in input().split()] for i in range(n)]
ab_list = sorted(ab_list)
buy = 0
money = 0
j = 0
lst = []
for i in range(n):
lst.append(ab_list[n - i - 1][1])
b_sum = sum(lst)
while (buy < m):
buy += ab_list[j][1]
money += ab_list[j][0] * ab_list[j][1]
j += 1
print((money-(ab_list[j-1][0]*(buy-m))))
|
n, m = (int(_) for _ in input().split())
ab_list = [[int(i) for i in input().split()] for i in range(n)]
ab_list = sorted(ab_list)
buy = 0
money = 0
j = 0
while (buy < m):
buy += ab_list[j][1]
money += ab_list[j][0] * ab_list[j][1]
j += 1
print((money-(ab_list[j-1][0]*(buy-m))))
|
p03103
|
N,M = list(map(int,input().split(' ')))
#A = []
#B = []
Drinks = []
for i in [0]*N:
a,b = list(map(int,input().split(' ')))
#A.append(a)
#B.append(b)
Drinks+=[a]*b
Drinks.sort()
print((sum(Drinks[:M])))
|
N,M = list(map(int,input().split(' ')))
D = []
for i in [0]*N:
a,b = list(map(int,input().split(' ')))
D.append([a,b])
D.sort(key = lambda x : x[0])
ans = 0
for c, s in D:
if s < M:
M -= s
ans += c * s
else:
ans += M * c
break
print(ans)
|
p03103
|
import copy
List = []
N, M = (int(x) for x in input().split())
for i in range(N):
a, b = (int(x) for x in input().split())
List.append([a, b])
def merge(list):
mid = len(list)
if mid > 1:
left = merge(list[:(mid//2)])
right = merge(list[(mid//2):])
list = []
while len(left) != 0 and len(right) != 0:
if left[0][0] < right[0][0]:
list.append(left.pop(0))
else:
list.append(right.pop(0))
if len(left) != 0:
list.extend(left)
elif len(right) != 0:
list.extend(right)
return list
num_of_drink, total_fee = 0, 0
List = copy.copy(merge(List))
temp_M = M
list_of_num = []
for i in range(N):
if temp_M <= List[i][1]:
list_of_num.append(temp_M)
break
else:
list_of_num.append(List[i][1])
temp_M += -List[i][1]
index = 0
for x in list_of_num:
total_fee += List[index][0] * x
index += 1
print(total_fee)
|
List = []
N, M = (int(x) for x in input().split())
for i in range(N):
a, b = (int(x) for x in input().split())
List.append([a, b])
num_of_drink, total_fee = 0, 0
List = sorted(List, key=lambda x:x[0])
temp_M = M
list_of_num = []
for i in range(N):
if temp_M <= List[i][1]:
list_of_num.append(temp_M)
break
else:
list_of_num.append(List[i][1])
temp_M += -List[i][1]
index = 0
for x in list_of_num:
total_fee += List[index][0] * x
index += 1
print(total_fee)
|
p03103
|
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
for i in range(n):
a, b = AB[i]
if b >= m:
ans += a*m
break
else:
ans += a*b
m -= b
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
for a, b in AB:
if b <= m:
ans += a*b
m -= b
else:
ans += a*m
m = 0
if m == 0:
break
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
stores = []
for i in range(n):
store = input().split()
stores.append([int(store[i]) for i in range(2)])
stores.sort()
drinks = 0
cost = 0
for store in stores:
if drinks + store[1] <= m:
drinks += store[1]
cost += store[0]*store[1]
elif drinks + store[1] > m:
cost += (m - drinks)*store[0]
break
print(cost)
|
n, m = list(map(int, input().split()))
stores = [[int(j) for j in input().split()]for i in range(n)]
stores.sort()
drinks = 0
cost = 0
for store in stores:
if drinks + store[1] <= m:
drinks += store[1]
cost += store[0]*store[1]
elif drinks + store[1] > m:
cost += (m - drinks)*store[0]
break
print(cost)
|
p03103
|
n,m = list(map(int, input().split()))
ab = sorted([list(map(int, input().split())) for _ in range(n)])
ans = 0
for i in ab:
t = min(m,i[1])
ans += i[0]*t
m -= t
print(ans)
|
n,m = list(map(int, input().split()))
ab = sorted([list(map(int, input().split())) for _ in range(n)])
ans = 0
for a,b in ab:
ans += a*min(m,b)
m -= min(m,b)
if m == 0: break
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
S = [[0]*2 for i in range(N)]
for i in range(N):
S[i] = list(map(int, input().split()))
S = sorted(S)
quantitys = 0
total = 0
for i in range(N):
quantity = 0
x = 0
for ii in range(S[i][1]):
if quantitys<M:
quantitys += 1
quantity += 1
x += quantity * S[i][0]
total += x
print((str(total)))
|
N, M = list(map(int, input().split()))
S = [[0]*2 for i in range(N)]
for i in range(N):
S[i] = list(map(int, input().split()))
S = sorted(S)
quantitys = 0
total = 0
for i in range(N):
# 【根本註】この for 文の中がソースコードの変更点となります。
# ここまでのコードで、二次元配列 S に「エナジードリンクが安い順」に
# 金額と本数のセットを格納できているわけですから、あとは「その店で何本買えばよいか？」
# を計算し、for 文を使わずに普通の数式ベースで金額・本数の計算を行ってしまうのが正しい方法となります。
#【根本註】必要な本数 M から「今何本購入しているか」を表す quantitys を引くことで、
# 「あと何本購入する必要があるか」を表す変数 need を計算します。
need = M - quantitys
#【根本註】この変数 need：「あと何本必要か」が、今参照している店の在庫本数：S[i][1] 以上ならば、
# その店の在庫を全部購入することができるはずです。（在庫を全部買うと、残りが 0 本ちょうどか 1 本以上に
# なります）
if(need - S[i][1])>=0:
# 【根本註】そのため、この場合は S[i][1] 本のエナジードリンクを S[i][0] 円で買ったものとして、
# quantitys には S[i][1] を足し、金額の合計 total には S[i][0] * S[i][1] の 金額 × 本数 の合計額を
# 足してしまいます。こうすることで、従来は購入する本数分だけ回していた for 文の処理を全て削減し、
# 1 本の数式に落とし込むことができ、処理にかかる時間を非常に大きく削減することが可能になるのです。
quantitys += S[i][1]
total += S[i][0] * S[i][1]
#【根本註】一方で、変数 need：「あと何本必要か」が、今参照している店の在庫本数：S[i][1] より少なければ、
# その店では need 本だけ購入すれば、必要な本数ちょうどに揃えることが可能になります。
else:
# 【根本註】同様に、この場合は need 本のエナジードリンクを S[i][0] 円で買ったものとして、
# quantitys には need を足し、金額の合計 total には S[i][0] * need の 金額 × 本数 の合計額を
# 足してしまいます。
quantitys += need
total += S[i][0] * need
#【根本註】ここまでの処理を終えた段階で、もし M （必要本数）から quantities（購入済の本数）を引いた値が
# ゼロになったならば、必要な本数を買い揃えることができたということになりますから、ループを終了します。
if M-quantitys == 0:
break
print((str(total)))
|
p03103
|
n,m,*l=list(map(int,open(0).read().split()))
ans=0
for s,t in sorted(zip(l[::2],l[1::2])):
ans+=s*min(m,t)
m=max(m-t,0)
if not m:
break
print(ans)
|
n,m,*l=list(map(int,open(0).read().split()))
ans=0
for s,t in sorted(zip(l[::2],l[1::2])):
ans+=s*min(m,t)
m-=t
if m<=0:
print(ans)
break
|
p03103
|
#n=int(input())
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort(key=lambda x: x[0])
#print(l)
money=0
count=0
for i in range(n):
a=l[i][0];b=l[i][1]
if (m-count)>b :
count+=b
money+=a*b
else:
money+=a*(m-count)
count+=(m-count)
break
print(money)
|
#n=int(input())
n,m=list(map(int,input().split()))
#al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
l=[]
for i in range(n):
a,b=list(map(int,input().split()))
l.append([a,b])
l.sort(key=lambda x: x[0])
count=0;cost=0
for i in range(n):
a,b=l[i][0],l[i][1]
if count+b>=m:
cost+=a*(m-count)
break
else:
cost+=a*b
count+=b
print(cost)
|
p03103
|
n,m = list(map(int,input().split(' ')))
cost = 0
count = 0
mlist = list()
for i in range(n):
mlist.append(list(map(int,input().split(' '))))
mlist.sort(key=lambda x: x[0])
for i in range(n):
ablist = mlist[i]
if count+ablist[1] <= m:
count += ablist[1]
cost += ablist[0]*ablist[1]
else:
for j in range(ablist[1]):
count += 1
if count <= m:
cost += ablist[0]
else:
break_t = True
break
if break_t:
break
print(cost)
|
n,m = list(map(int,input().split(' ')))
cost = 0
count = 0
mlist = list()
for i in range(n):
mlist.append(list(map(int,input().split(' '))))
mlist.sort(key=lambda x: x[0])
for i in range(n):
ablist = mlist[i]
if count+ablist[1] <= m:
count += ablist[1]
cost += ablist[0]*ablist[1]
else:
for j in range(ablist[1]):
count += 1
if count <= m:
cost += ablist[0]
else:
break_t = True
break
if break_t:
break
print(cost)
|
p03103
|
n,m = list(map(int,input().split()))
a = []
b = []
ans = 0
for i in range(n):
aa, bb = list(map(int,input().split()))
a.append(aa)
b.append(bb)
ans = 0
mini = 10000000000
while(1):
for i in range(n):
if a[i] < mini:
mini = a[i]
index = i
ans = ans + a[index]*min(m,b[index])
m = m - min(m,b[index])
if m == 0:
break
a.pop(index)
b.pop(index)
n = n - 1
mini = 10000000000
print(ans)
|
n,m = list(map(int,input().split()))
a = []
b = []
raw = []
ans = 0
for i in range(n):
raw.append(list(map(int,input().split())))
raw.sort(key=lambda x:x[0])
for i in range(n):
ans = ans + raw[i][0] * min(raw[i][1],m)
m = m - min(raw[i][1],m)
if m == 0:
break
print(ans)
|
p03103
|
n,m =list(map(int,input().split()))
lm = []
for _ in range(n):
lm.append(list(map(int,input().split())))
s = 0
mon = 0
lm.sort(key = lambda x:x[0])
while s + lm[0][1] < m:
s += lm[0][1]
mon += lm[0][1]*lm[0][0]
lm = lm[1::]
while s < m:
s += 1
mon += lm[0][0]
lm[0][1] -= 1
print(mon)
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(N)]
AB.sort()
Ans = 0
for i in AB:
if i[1] >= M:
Ans += i[0] * M
break
else:
Ans += i[0] * i[1]
M -= i[1]
print(Ans)
|
p03103
|
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
# A[i], B[i] はまとめてしまう
stores = [list(map(int, input().split())) for n in range(N)]
# 最も安い店を探す
def getCheapest():
cheapest = 0
for i in range(1, N):
if (stores[i][0] < stores[cheapest][0] and stores[i][1] > 0):
cheapest = i
return cheapest
remaining = M
cost = 0
while True:
store = stores[getCheapest()]
if store[1] >= remaining: # もしこの店で買いきれるなら
cost += store[0] * remaining
break
else: #買い切れないなら
bought = store[1]
store[1] = 0
cost += store[0] * bought
remaining -= bought
print(cost)
|
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
# A[i], B[i] はまとめてしまう
stores = [list(map(int, input().split())) for n in range(N)]
# 安さ順にソート
stores.sort(key = lambda s: s[0])
remaining = M
cost = 0
while True:
store = stores[0]
if store[1] >= remaining: # もしこの店で買いきれるなら
cost += store[0] * remaining
break
else: #買い切れないなら
cost += store[0] * store[1]
remaining -= store[1]
stores.pop(0)
print(cost)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort()
ans = 0
for a, b in AB:
if M == 0: break
if M >= b:
ans += a * b
M -= b
else:
ans += a * M
M = 0
break
print(ans)
|
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
cnt = 0
ans = 0
for a,b in ab:
cnt += b
ans += a * b
if cnt >= m:
if cnt > m: ans -= a * (cnt-m)
break
print(ans)
|
p03103
|
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
money = 0
drink = 0
for a,b in ab:
money += a*b
drink += b
if drink >= m:
money -= (drink-m) * a
break
print(money)
|
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
money = 0
drink = 0
for a,b in ab:
if drink+b <= m:
drink += b
money += a*b
else:
money += (m-drink) * a
drink = m
if drink == m: break
print(money)
|
p03103
|
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for a,b in ab:
if b <= m:
ans += a*b
m -= b
elif b > m:
ans += m * a
break
print(ans)
|
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for a,b in ab:
if b <= m:
ans += a*b
m -= b
else:
ans += a*m
m = 0
if m == 0: break
print(ans)
|
p03103
|
N,M = (list(map(int, input().split())))
li = [list(map(int,input().split())) for i in range(N)]
li.sort()
li3 = []
for j in range(len(li)):
li3.extend([li[j][0]]*li[j][1])
print((sum(li3[0:M])))
|
N,M = (list(map(int, input().split())))
li = [list(map(int,input().split())) for i in range(N)]
li.sort()
li3 = []
for j in range(len(li)):
li3.extend([li[j][0]]*li[j][1])
if len(li3)>M:
break
print((sum(li3[0:M])))
|
p03103
|
n,m = list(map(int, input().split()))
A = []
B = []
ans = 0
for n in range(n):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
while(m > 0):
minA = min(A)
if B[A.index(minA)] >= m:
ans += minA*m
else:
ans += minA*B[A.index(minA)]
m = m - B[A.index(minA)]
B.pop(A.index(minA))
A.pop(A.index(minA))
print(ans)
|
import itertools
n,m = list(map(int, input().split()))
AB = []
ans = 0
for n in range(n):
a,b = list(map(int,input().split()))
AB.append([a,b])
AB.sort()
A,B = list(zip(*AB))
A,B = list(A), list(B)
i = list(_ for _ in itertools.accumulate(B) if _ <= m)
if i == []:
ans = A[0]*m
else:
B = B[:len(i)] + [m-i[-1]]
A = A[:len(B)]
ans = sum([a*b for a,b in zip(A,B)])
print(ans)
|
p03103
|
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ab=sorted(ab)
cost=[]
for i in range(n):
cost+=[ab[i][0]]*ab[i][1]
print((sum(cost[0:m])))
|
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ab=sorted(ab)
ans=0
d=0
for i in range(n):
s=min(m-d,ab[i][1])
ans+=ab[i][0]*s
d+=s
if d==m:
break
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
l = [0 for _ in range(n)]
for i in range(n):
l[i] = list(map(int, input().split()))
l_sort = sorted(l)
ans = 0
drink = 0
for j in range(n):
cnt_lim = l_sort[j][1]
cnt = 0
while cnt < cnt_lim:
ans += l_sort[j][0]
cnt += 1
drink += 1
if drink == m:
print(ans)
exit()
|
from collections import defaultdict, deque
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
# MOD = 10 ** 9 + 7
# INF = float("inf")
def main():
n, m = list(map(int, input().split()))
dd = defaultdict(int)
for _ in range(n):
a, b = list(map(int, input().split()))
dd[a] += b
dd_sort = sorted(list(dd.items()), key=lambda x: x[0])
ans = 0
r = m
for cost, num in dd_sort:
if r >= num:
ans += cost * num
r -= num
else:
ans += cost * r
break
print(ans)
if __name__ == '__main__':
main()
|
p03103
|
n,m = list(map(int,input().split()))
AB = sorted([list(map(int,input().split())) for i in range(n)])
res = 0
for a,b in AB:
m -= b
if m >= 0:
res += a*b
else:
m += b
res += a*m
break
print(res)
|
n,m = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(n)]
AB.sort()
res = 0
for a,b in AB:
m -= b
if m >= 0:
res += a*b
else:
m += b
res += a*m
break
print(res)
|
p03103
|
n,m = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(n)]
AB.sort()
res = 0
for a,b in AB:
m -= b
if m >= 0:
res += a*b
else:
m += b
res += a*m
break
print(res)
|
n,m = list(map(int,input().split()))
AB = [[int(j) for j in input().split()] for i in range(n)]
AB.sort()
res = 0
for a,b in AB:
m -= b
if m >= 0:
res += a*b
else:
m += b
res += a*m
break
print(res)
|
p03103
|
n,m = list(map(int,input().split()))
AB = [[int(i) for i in input().split()] for j in range(n)]
AB.sort()
res = 0
for a,b in AB:
m -= b
if m >= 0:
res += a*b
else:
m += b
res += a*m
break
print(res)
|
n,m = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(n)]
AB.sort()
res = 0
for a,b in AB:
res += a*min(b,m)
m -= b
if m < 0:
break
print(res)
|
p03103
|
N,M = list(map(int, input().split()))
ab = [[0 for i in range(2)] for j in range(N)]
for i in range(N):
ab[i][0], ab[i][1] = list(map(int, input().split()))
AB = sorted(ab, key=lambda x:x[0])
count = 0
total = 0
for i in range(N):
for j in range(AB[i][1]):
if count < M:
total += AB[i][0]
count += 1
else:
break
print(total)
|
N,M = list(map(int, input().split()))
ab = [[0 for i in range(2)] for j in range(N)]
for i in range(N):
ab[i][0], ab[i][1] = list(map(int, input().split()))
AB = sorted(ab, key=lambda x:x[0])
count = 0
total = 0
for AB_ in AB:
num = min(M, AB_[1])
total += AB_[0]*num
M -= num
print(total)
|
p03103
|
# -*- coding: utf-8 -*-
import bisect
N, M = list(map(int, input().split()))
price_list = []
stock_list = []
for i in range(N):
A, B = list(map(int, input().split()))
index = bisect.bisect_left(price_list, A)
price_list.insert(index, A)
stock_list.insert(index, B)
ans = 0
rest = M
for i in range(N):
if stock_list[i] < rest:
ans += price_list[i] * stock_list[i]
rest -= stock_list[i]
else:
ans += rest * price_list[i]
break
print(ans)
|
# -*- coding: utf-8 -*-
from operator import itemgetter
N, M = list(map(int, input().split()))
a = [0] * N
for i in range(N):
a[i] = list(map(int, input().split()))
def main():
b = sorted(a, key=itemgetter(0))
m = 0
cost = 0
for i in range(N):
if (m + b[i][1]) <= M:
m += b[i][1]
cost += (b[i][0] * b[i][1])
else:
cost += (b[i][0] * (M-m))
return cost
return cost
print((main()))
|
p03103
|
B = [float('inf')]*(10 ** 5)
A = [float('inf')]*(10 ** 5)
def main():
accum = 0
cost = 0
N, M = list(map(int, input().split()))
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
while accum < M:
index = A.index(min(A))
Aind = A.pop(index)
Bind = B.pop(index)
if accum + Bind > M:
cost += Aind * (M - accum)
accum = M
else:
accum += Bind
cost += Aind * Bind
print(cost)
main()
|
from operator import itemgetter
A = []
def main():
accum = 0
cost = 0
N, M = list(map(int, input().split()))
for i in range(N):
A.append(list(map(int, input().split())))
B = sorted(A, key = itemgetter(0))
while accum < M:
eB = B.pop(0)
if accum + eB[1] > M:
cost += eB[0] * (M - accum)
accum = M
else:
accum += eB[1]
cost += eB[0] * eB[1]
print(cost)
main()
|
p03103
|
N,M = list(map(int, input().split()))
shop = []
for i in range(N):
a,b = list(map(int, input().split()))
shop.append([a,b])
shop.sort(reverse=True)
ans = 0
while M > 0:
a,b = shop.pop()
tmp = min(b,M)
ans += tmp * a
M -= tmp
print(ans)
|
N,M = list(map(int, input().split()))
shop = []
for i in range(N):
a,b = list(map(int, input().split()))
shop.append([a,b])
shop.sort()
ans = 0
for i in range(N):
if M <= 0:
break
tmp = min(shop[i][1],M)
ans += tmp * shop[i][0]
M -= tmp
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
a = [0] * (n + 1)
b = [0] * (n + 1)
total = [0] * (n + 1)
ans = 0
# 安い店から選ぶ方法が最適
shop = [tuple(map(int, input().split())) for _ in range(n)]
shop.sort()
for i in range(1, n + 1):
a_i, b_i = shop[i - 1]
# 累積和を作っておく
# b[i]: i番目の店まで利用した際に購入できる栄養ドリンクの最大本数
# total[i]: i番目の店まで利用した際に支払うお金の最大値
b[i] = b[i - 1]
total[i] = total[i - 1]
b[i] += b_i
total[i] += a_i * b_i
# a[i]: i番目の店の栄養ドリンクの単価
a[i] = a_i
for i in range(1, n + 1):
if m <= b[i]:
m = m - b[i - 1]
# 足りない分を追加で計算
ans = total[i - 1] + a[i] * m
break
print(ans)
|
n, m = list(map(int, input().split()))
ans = 0
shop = [tuple(map(int, input().split())) for _ in range(n)]
shop.sort()
for price, num in shop:
num = min(m, num)
ans += price * num
m -= num
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for _ in range(n)]
info.sort()
ans = 0
for i in range(n):
if m >= info[i][1]:
m -= info[i][1]
ans += info[i][0]*info[i][1]
else:
ans += info[i][0]*m
m = 0
if m == 0:
break
print(ans)
|
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for _ in range(n)]
info.sort()
ans = 0
for i in range(n):
if m >= info[i][1]:
m -= info[i][1]
ans += info[i][0]*info[i][1]
else:
ans += info[i][0]*m
break
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
a=[0 for i in range(n)]
b=[0 for i in range(n)]
c=[[0 for i in range(2)] for i in range (n)]
for i in range(n):
a[i],b[i] = list(map(int, input().split()))
for i in range(n):
c[i][0]=a[i]
for i in range(n):
c[i][1]=b[i]
c.sort()
price=0
i=0
while(m>0):
if(m>c[i][1]):
price+=c[i][0]*c[i][1]
m-=c[i][1]
else:
price+=c[i][0]*m
m=0
i+=1
print(price)
|
n, m = list(map(int, input().split()))
c=[[0 for i in range(2)] for i in range (n)]
for i in range(n):
c[i][0],c[i][1] = list(map(int, input().split()))
c.sort()
price=0
i=0
while(m>0):
if(m>c[i][1]):
price+=c[i][0]*c[i][1]
m-=c[i][1]
else:
price+=c[i][0]*m
m=0
i+=1
print(price)
|
p03103
|
def actual(N, M, AB):
count = 0
payment = 0
while count < M:
AB = [x for x in AB if x[1] > 0]
m = min(AB, key=lambda x: x[0])
payment += m[0]
m[1] -= 1
count += 1
return payment
N, M = list(map(int, input().split()))
AB = []
for _ in range(N):
a, b = list(map(int, input().split()))
AB.append([a, b])
print((actual(N, M, AB)))
|
def actual(N, M, AB):
payment = 0
shop_order_by_price_desc = sorted(AB, key=lambda x: x[0])
for price, stock in shop_order_by_price_desc:
if stock >= M:
# 端数があるときは、残りの必要分だけ買えばよい
return payment + (price * M)
else:
# 端数がないなら買い切る
M -= stock
payment += price * stock
N, M = list(map(int, input().split()))
AB = []
for _ in range(N):
a, b = list(map(int, input().split()))
AB.append([a, b])
print((actual(N, M, AB)))
|
p03103
|
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ab.sort()
AB=[[ab[i][0]]*ab[i][1] for i in range(n)]
A=[]
for i in AB:
A+=i
ans=0
for i in range(m):
ans+=A[i]
print(ans)
|
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ab.sort()
ans=0
B=0
cnt=0
for a,b in ab:
B+=b
if B<m:
ans+=a*b
cnt+=b
else:
ans+=a*(m-cnt)
print(ans)
exit()
|
p03103
|
from operator import itemgetter
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort(key=itemgetter(0))
result = 0
for e in ab:
count = min(m, e[1])
result += e[0] * count
m = max(m-count, 0)
print(result)
|
n, m = [int(x) for x in input().split()]
a = sorted([[int(x) for x in input().split()] for _ in range(n)], key=lambda x: x[0])
result = 0
for x in a:
cnt = min(m, x[1])
result += x[0] * cnt
m -= cnt
print(result)
|
p03103
|
n,m=list(map(int,input().split()))
c=0;d={}
for _ in[0]*n:
a,b=list(map(int,input().split()))
if not a in list(d.keys()):
d[a]=0
d[a]+=b
for k in sorted(d.keys()):
if d[k] < m:
c+=k*d[k]
m-=d[k]
else:
c+=k*m
m=0
if m == 0:break
print(c)
|
import sys;n,m=input().split();m=int(m);a=[];i=n=c=0;a=sorted(tuple(map(int,e.split()))for e in sys.stdin)
while m>0:c+=a[i][0]*a[i][1];m-=a[i][1];i+=1
print((c+m*a[~-i][0]))
|
p03103
|
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
def bubble_sort(lst):
for i in reversed(list(range(len(lst)))):
for j in range(i):
if lst[j][0] > lst[j + 1][0]:
lst[j], lst[j + 1] = lst[j + 1], lst[j]
bubble_sort(a)
purchase_price = 0
for price, count in a:
if count < m:
purchase_price += price * count
m -= count
else:
purchase_price += price * m
m = 0
print(purchase_price)
|
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a = sorted(a, key=lambda x: x[0])
purchase_price = 0
for price, count in a:
if count < m:
purchase_price += price * count
m -= count
else:
purchase_price += price * m
m = 0
print(purchase_price)
|
p03103
|
N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort()
res = 0
cnt = 0
for a, b in AB:
tmp = M - cnt
if tmp <= b:
res += a * tmp
break
res += a * b
cnt += b
print(res)
|
import sys
N, M = list(map(int, input().split()))
AB = [list(map(int, sys.stdin.readline().rsplit())) for _ in range(N)]
AB.sort()
res = 0
for a, b in AB:
if M > b:
M -= b
res += a * b
else:
res += a * M
break
print(res)
|
p03103
|
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
N,M = [int(x) for x in input().split()]
ABdict = {}
for _ in range (N):
A,B = [int(x) for x in input().split()]
if A in list(ABdict.keys()):
ABdict[A] += B
else:
ABdict[A] = B
dct = sorted(ABdict.items())
ls = []
for pricenumber in dct:
for i in range (pricenumber[1]):
ls.append(pricenumber[0])
print((sum(ls[:M])))
|
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
N,M = [int(x) for x in input().split()]
ABdict = {}
for _ in range (N):
A,B = [int(x) for x in input().split()]
if A in list(ABdict.keys()):
ABdict[A] += B
else:
ABdict[A] = B
dct = sorted(ABdict.items())
ls = []
ans = 0
for i in dct:
if M >= 0:
ans += min(M,i[1])*i[0]
M -= i[1]
print(ans)
|
p03103
|
### coding: UTF-8
import sys
head = sys.stdin.readline()
[n, m] = [int(x) for x in head.split(" ")]
amount = 0
# 店の件数分読み込み
rows = [sys.stdin.readline() for _ in range(n)]
rows.sort(key=lambda x: int(x.split(" ")[0]))
for row in rows:
[ai, bi] = [int(x) for x in row.strip().split(" ")]
# 購入可能な最大数まで買う
x = bi if m >= bi else m
amount += ai * x
m -= x
if m == 0:
break
print(amount)
|
### coding: UTF-8
import sys
amount = 0
# 安い店から買える最大数分買う。ほしい個数を超えてる場合はほしい個数だけ
[n, m] = [int(x) for x in sys.stdin.readline().split(" ")]
for row in sorted([sys.stdin.readline() for _ in range(n)], key=lambda x: int(x.split(" ")[0])):
[ai, bi] = [int(x) for x in row.strip().split(" ")]
x = bi if m >= bi else m
amount += ai * x
m -= x
if m == 0:
break
print(amount)
|
p03103
|
from sys import stdin
def main():
from builtins import int, list, map, min
readline = stdin.readline
n, m = list(map(int, readline().split()))
data = [list(map(int, readline().split())) for _ in range(n)]
data.sort(key = lambda x: x[0])
purchased = 0
amount = 0
for v in data:
t = min(m - purchased, v[1])
amount += t * v[0]
purchased += t
if purchased == m:
break
print(amount)
main()
|
from sys import stdin
def main():
from builtins import int, list, map, min
readline = stdin.readline
n, m = list(map(int, readline().split()))
data = [list(map(int, readline().split())) for _ in range(n)]
data.sort(key = lambda x: x[0])
purchased = 0
amount = 0
for a, b in data:
t = min(m - purchased, b)
amount += t * a
purchased += t
if purchased == m:
break
print(amount)
main()
|
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)
ans = 0
tmp = 0
while tmp < M:
num = min([M-tmp,B[A.index(min(A))]])
tmp += num
ans += num * min(A)
ind = A.index(min(A))
del A[ind]
del B[ind]
print(ans)
|
from operator import itemgetter
N,M = list(map(int,input().split()))
ls = [list(map(int,input().split())) for _ in range(N)]
ls = sorted(ls,key=itemgetter(0))
ans = 0
pon = 0
for i in range(N):
if pon < M:
pon += ls[i][1]
ans += ls[i][1]*ls[i][0]
else:
i = i-1
break
if pon == M:
print(ans)
else:
ans -= ls[i][0]*(pon - M)
print(ans)
|
p03103
|
N, M = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
A = []
B = []
for i in range(N):
A.append(L[i][0])
B.append(L[i][1])
cost = 0
num = 0
while True:
if num == M:
break
cost = cost + min(A)*min(B[A.index(min(A))], M - num)
num = num + min(B[A.index(min(A))], M - num)
B.pop(A.index(min(A)))
A.remove(min(A))
print(cost)
exit()
|
N, M = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
L.sort()
A = []
B = []
for i in range(N):
A.append(L[i][0])
B.append(L[i][1])
num = 0
cost = 0
i = 0
while num < M:
cost = cost + A[i]*min(B[i], M - num)
num = num + min(B[i], M - num)
i = i + 1
print(cost)
|
p03103
|
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
sorted_items = sorted(
ab,
key=lambda x: x[0]
)
cost = 0
bought = 0
for c, stock in sorted_items:
for s in range(1, stock + 1):
bought += 1
cost += c
if bought == m:
print(cost)
exit()
|
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
shops = sorted(
ab,
key=lambda x: x[0]
)
paid = 0
for cost, stock in shops:
num = min(m, stock)
paid += num * cost
m = m - num
if m == 0:
break
print(paid)
|
p03103
|
N,M = list(map(int,input().split()))
A = []
B = []
count = 0
sum = 0
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
while(count < M):
min_price = min(A)
min_index = A.index(min_price)
A_buy_num = B[min_index]
if((count + A_buy_num) <= M):
count += A_buy_num
sum += (A.pop(min_index))*(B.pop(min_index))
else: #(count + A_buy_num) > M
rest_num = M - count
count += rest_num
sum += (A.pop(min_index))*(rest_num)
break
print(sum)
|
N,M = list(map(int,input().split()))
AB = []
count = 0
sum = 0
for i in range(N):
a,b = list(map(int,input().split()))
s = [a,b]
AB.append(s)
AB.sort()
i = 0
while(1):
if(count >= M):
break
if((count + AB[i][1]) <= M):
sum += AB[i][0]*AB[i][1]
count += AB[i][1]
else:
rest = M - count
sum += AB[i][0]*rest
break
i += 1
print(sum)
|
p03103
|
li = list(map(int,input().split()))
num = li[0]
want = li[1]
cost = []
max_num = []
total_num = 0
total_cost = 0
for i in range(num):
a = list(map(int,input().split()))
cost.append(a[0])
max_num.append(a[1])
while want > total_num:
min_cost = min(cost)
m = cost.index(min_cost)
if total_num + max_num[m] > want:
total_cost += (want - total_num) * cost[m]
total_num = want
else:
total_cost += max_num[m] * cost[m]
total_num += max_num[m]
cost.remove(cost[m])
max_num.remove(max_num[m])
print(total_cost)
|
n,m = list(map(int,input().split()))
li = [list(map(int,input().split())) for _ in range(n)]
li = sorted(li, key=lambda x:x[0])
cnt = 0
coin = 0
for a,b in li:
c_cnt = cnt + b
if c_cnt < m:
cnt += b
coin += a*b
else:
cnt += b-(c_cnt - m)
coin += a*(b-(c_cnt-m))
break
print(coin)
|
p03103
|
N, M = list(map(int, input().split()))
A = []
B = []
sumcost = 0
for i in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
k = 0
while k < M:
min_index = A.index(min(A))
B[min_index] -= 1
sumcost += A[min_index]
if B[min_index]<1:
del A[min_index]
del B[min_index]
k += 1
print(sumcost)
|
N, M = list(map(int, input().split()))
A = []
sumcost = 0
for i in range(N):
a = list(map(int, input().split()))
A.append(a)
k = 0
A.sort()
while k < M:
sumcost += A[0][0]
A[0][1] -= 1
if A[0][1]<1:
A.pop(0)
k += 1
print(sumcost)
|
p03103
|
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
A.sort()
sumcost = 0
k = 0
for i in range(M):
if M-k>A[0][1]:
sumcost += A[0][0]*A[0][1]
k += A[0][1]
A.pop(0)
else:
sumcost += A[0][0]*(M-k)
break
print(sumcost)
|
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
A.sort()
sumcost = 0
k = 0
t = 0
while M-k>0:
buy = min(M-k, A[t][1])
sumcost += A[t][0]*buy
k += buy
t += 1
print(sumcost)
|
p03103
|
N, M = list(map(int, input().split()))
A = list([0] * N) # A yen
B = list([0] * N) # B hon
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
require = M
price = 0
while(require > 0):
# print("require = {}, price = {}".format(require, price))
minidx = A.index(min(A))
# print("found idx = " + str(minidx))
a = A.pop(minidx)
b = B.pop(minidx)
if(require >= b):
# print("buy = {}, price = {}".format(b, a))
price = price + a * b
require = require - b
else:
# print("buy = {}, price = {}".format(require, A[minidx]))
price = price + a * require
require = 0
print(price)
|
YEN = 0
NUM = 1
N, M = list(map(int, input().split()))
shop = list([])
for i in range(N):
a, b = list(map(int, input().split()))
shop.append([a, b])
shop.sort()
require = M
price = 0
minidx = 0
while(require > 0):
# print("require = {}, price = {}".format(require, price))
# print("idx = {}, num = {}, price = {}".format(minidx, shop[minidx][NUM], shop[minidx][YEN]))
if(require >= shop[minidx][NUM]):
price = price + shop[minidx][YEN] * shop[minidx][NUM]
require = require - shop[minidx][NUM]
minidx = minidx + 1
else:
# print("buy = {}, price = {}".format(require, A[minidx]))
price = price + shop[minidx][YEN] * require
require = 0
print(price)
|
p03103
|
n, m = list(map(int, input().split()))
A = []
B = []
cnt = 0
ans = 0
for _ in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
while cnt < m:
A_min = min(A)
A_min_index = A.index(A_min)
if cnt + B[A_min_index] < m:
ans += A_min * B[A_min_index]
cnt += B[A_min_index]
A.pop(A_min_index)
B.pop(A_min_index)
else:
for i in range(B[A_min_index]):
if cnt == m:
break
ans += A_min
cnt += 1
print(ans)
|
n, m = list(map(int, input().split()))
drink = sorted([list(map(int, input().split())) for _ in range(n)])
ans = 0
for a,b in drink:
ans += a*min(b,m)
m -= min(b,m)
if m == 0:
break
print(ans)
|
p03103
|
import sys
input = sys.stdin.readline
def main():
ans = 0
n, m = list(map(int, input().split()))
all = []
for i in range(n):
all.append(list(map(int, input().split())))
all.sort()
for i in range(n):
if m >= all[i][1]:
m -= all[i][1]
ans += all[i][0]*all[i][1]
else:
ans += all[i][0]*(m)
break
print(ans)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
def main():
ans = 0
n, m = list(map(int, input().split()))
all = []
for i in range(n):
all.append(list(map(int, input().split())))
all.sort()
for a,b in all:
if m >= b:
m -= b
ans += a*b
else:
ans += a*(m)
break
print(ans)
if __name__ == '__main__':
main()
|
p03103
|
N, M = list(map(int, input().split()))
A = []
B = []
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
if N != 1:
for n in range(N-1):
a, b = list(map(int, input().split()))
swi = 0
for j in range(len(A)):
if A[j] > a:
A.insert(j, a)
B.insert(j, b)
swi = 1
break
if swi == 0:
A.append(a)
B.append(b)
cntSum = 0
moneySum = 0
for n in range(N):
if cntSum + B[n] > M:
moneySum += A[n] * (M - cntSum)
cntSum += M - cntSum
break
else:
cntSum += B[n]
moneySum += A[n] * B[n]
print(moneySum)
|
n, m = list(map(int, input().split()))
abList = sorted([list(map(int, input().split())) for _ in range(n)])
abSum = 0
abNum = m
for i in range(n):
ab = abList[i]
a, b = ab[0], ab[1]
if b >= abNum:
abSum += abNum * a
break
else:
abSum += b * a
abNum -= b
print(abSum)
|
p03103
|
n, m = list(map(int, input().split()))
abList = sorted([list(map(int, input().split())) for _ in range(n)])
abSum = 0
abNum = m
for i in range(n):
ab = abList[i]
a, b = ab[0], ab[1]
if b >= abNum:
abSum += abNum * a
break
else:
abSum += b * a
abNum -= b
print(abSum)
|
n, m = list(map(int, input().split()))
abList = sorted([list(map(int, input().split())) for _ in range(n)])
abSum = 0
abNum = m
for ab in abList:
a, b = ab[0], ab[1]
if b >= abNum:
abSum += abNum * a
break
else:
abSum += b * a
abNum -= b
print(abSum)
|
p03103
|
n, m = list(map(int, input().split()))
abList = sorted([list(map(int, input().split())) for _ in range(n)])
abSum = 0
abNum = m
for ab in abList:
a, b = ab[0], ab[1]
if b >= abNum:
abSum += abNum * a
break
else:
abSum += b * a
abNum -= b
print(abSum)
|
n, m = list(map(int, input().split()))
abList = [list(map(int, input().split())) for _ in range(n)]
abList.sort()
abSum = 0
abNum = m
for ab in abList:
a, b = ab[0], ab[1]
if b >= abNum:
abSum += abNum * a
break
else:
abSum += b * a
abNum -= b
print(abSum)
|
p03103
|
N,M=list(map(int,input().split()))
sum=0
A=[int(i) for i in range(N)]
B=[int(i) for i in range(N)]
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
while True:
K=B[A.index(min(A))]
if K>=M:
print((sum+min(A)*M))
break
else:
sum+=K*min(A)
M-=K
A[A.index(min(A))]=max(A)+1
|
N,M=list(map(int,input().split()))
sum=0
A=[[int(i) for i in input().split()]for j in range(N)]
A.sort()
i=0
while True:
if A[i][1]>=M:
sum+=A[i][0]*M
break
else:
sum+=A[i][0]*A[i][1]
M-=A[i][1]
i+=1
print(sum)
|
p03103
|
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(n)]
ab.sort()
ans = 0
while m != 0:
tab = ab.pop(0)
ans += min(tab[1], m)* tab[0]
m = max(0, m - tab[1])
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 tab in ab:
if m < 0:
break
ans += min(tab[1], m)* tab[0]
m -= tab[1]
print(ans)
|
p03103
|
n, m = list(map(int, input().split()))
ab = []
for _ in range(n):
ab.append(list(map(int,input().split())))
#%%
# print(n, m, ab)
# n, m, ab = 4, 30, [[6, 18], [2, 5], [3, 10], [7, 9]]
#%%
ab.sort()
#%%
ans = 0
num = 0
while num < m:
a0 = ab[0][0]
b0 = ab[0][1]
if b0 >= m - num:
ans += a0 * (m - num)
break
else:
ans += a0 * b0
num += b0
ab.remove([a0, b0])
#%%
print(ans)
#%%
|
n, m = list(map(int, input().split()))
ab = []
prod = [0]
prod_cum = [0]
num_cum = [0]
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a,b])
#%%
ab.sort()
for i in range(n):
a, b = ab[i][0],ab[i][1]
# prod.append(a*b)
prod_cum.append(a*b + prod_cum[-1])
num_cum.append(b + num_cum[-1])
ab = [[0,0]] + ab
# print(ab)
# print(prod)
# print(prod_cum)
# print(num_cum)
# print(n, m, ab)
# n, m, ab = 4, 30, [[6, 18], [2, 5], [3, 10], [7, 9]]
#%%
ans = 0
prod = 0
for i in range(0, n+1):
if num_cum[i] >= m:
print((prod_cum[i] - ab[i][0] * (num_cum[i]-m)))
break
#%%
# ans = 0
# num = 0
# while num < m:
# a0 = ab[0][0]
# b0 = ab[0][1]
# if b0 >= m - num:
# ans += a0 * (m - num)
# break
# else:
# ans += a0 * b0
# num += b0
# ab.remove([a0, b0])
#%%
# print(ans)
#%%
|
p03103
|
#Energy Drink Collector
N, M = list(map(int, input().strip().split()))
A = []
B = []
for n in range(N):
a, b = list(map(int, input().strip().split()))
A.append(a)
B.append(b)
total = 0
collect = 0
while True:
min_i = A.index(min(A))
if collect + B[min_i] < M:
total += A[min_i]*B[min_i]
collect += B[min_i]
del A[min_i]
del B[min_i]
else:
total += A[min_i]*(M - collect)
collect = M
break
print(total)
|
#Energy Drink Collector
N, M = list(map(int, input().strip().split()))
list = [list(map(int, input().strip().split())) for i in range(N)]
list.sort(key = lambda x : x[0])
sum = 0
cnt = 0
for a, b in list:
if cnt + b < M:
sum += a*b
cnt += b
else:
sum += a*(M - cnt)
break
print(sum)
|
p03103
|
N_M = [int(x.strip()) for x in input().split()]
price_maxnum_list = [[int(i) for i in input().split()] for i in range(0, N_M [0])]
price_list = [i[0] for i in price_maxnum_list]
maxnum_list = [i[1] for i in price_maxnum_list]
if len(set(price_list)) ==1:
print((price_list[0]*N_M[1]))
else:
total = 0
nokori = N_M[1]
while nokori > 0:
ind = price_list.index(min(price_list))
total += min(price_list) * min(maxnum_list[ind], nokori)
nokori -= min(maxnum_list[ind], nokori)
price_list.pop(ind)
maxnum_list.pop(ind)
print(total)
|
N_M = [int(x.strip()) for x in input().split()]
price_l = [[int(i) for i in input().split()] for i in range(0, N_M[0])]
price_l.sort(key=lambda x: x[0])
total = 0
remain = N_M[1]
while remain > 0:
if len(price_l)<1:
break
price_n = price_l.pop(0)
total += price_n[0] * min(price_n[1], remain)
remain -= min(price_n[1], remain)
print(total)
|
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])
total = 0
remain = M
for x in A:
yen, num = x
purchase = min(num, remain)
total += (yen * purchase)
remain -= purchase
if remain == 0:
print(total)
exit()
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
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
for (yen, num) in AB:
if num <= M:
ans += (yen * num)
M -= num
else:
ans += (yen * M)
print(ans)
exit()
print(ans)
|
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], x[1]))
ct = 0
money = 0
for i in AB:
A, B = i[0], i[1]
for i in range(B):
money += A
ct += 1
if ct == M:
break
if ct == M:
break
print(money)
|
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], x[1]))
ct = 0
money = 0
for i in AB:
A, B = i[0], i[1]
money += A*B
ct += B
if ct >= M:
money -= (ct - M)*A
break
print(money)
|
p03103
|
N, M = (int(x) for x in input().split())
a, b, b2, p = [], [], [], []
for i in range(N):
o, t = (int(x) for x in input().split())
a.append(o)
b.append(t)
ans = 0
while M > 0:
idx = a.index(min(a))
n = b[idx]
if M - n >= 0:
ans += a[idx] * n
M -= n
else:
ans += a[idx] * M
M = 0
del a[idx]
del b[idx]
print(ans)
|
n, m = list(map(int, input().split()))
l = []
for _ in range(n): l.append([int(x) for x in input().split()])
l.sort()
s = cnt = 0
for a, b in l:
if cnt + b < m:
s += a*b
cnt += b
else:
s += a * (m - cnt)
break
print(s)
|
p03103
|
#!/usr/bin/python3
# abc121_c
"""
Energy Drink Collector
"""
test = False
def main():
"""
とにかく安い方からM本になるまで買い続ける。
"""
N, M = list(map(int, input().split()))
l = []
for _ in range(N):
# 安い順に、値段だけのリストをつくる。[100, 100, 100, 110, 120, 120, ...]
tempA, tempB = list(map(int, input().split()))
l.extend([tempA] * tempB)
# 安い順に並べる
l.sort()
if test:
print(l)
# 買う。
cost = sum(l[0:M])
# 合計金額を出力
print(cost)
if __name__ == '__main__':
main()
|
#!/usr/bin/python3
# abc121_c
"""
Energy Drink Collector
"""
test = False
def main():
"""
とにかく安い方からM本になるまで買い続ける。
"""
N, M = list(map(int, input().split()))
l = []
bottle = 0
cost = 0
for _ in range(N):
# [値段, 在庫本数] の2xNリストをつくる。
l.append(list(map(int, input().split())))
# 安い順に並べる
l.sort()
# 安い店の在庫を全部買って、M本を超えたら中断
for i in range(N):
bottle += l[i][1]
cost += l[i][0] * l[i][1]
# 買いすぎた分を返品
if bottle >= M:
cost -= (bottle - M) * l[i][0]
break
# 合計金額を出力
print(cost)
if __name__ == '__main__':
main()
|
p03103
|
n,m=list(map(int,input().split()))
dic={}
doll=0
AB=[list(map(int,input().split())) for _ in range(n)]
AB.sort()
for k,v in AB:
if v<m:
doll+=k*v
m-=v
else:
doll+=k*m
break
print(doll)
|
n,m=list(map(int,input().split()))
dic={}
doll=0
AB=[list(map(int,input().split())) for _ in range(n)]
AB.sort()
for k,v in AB:
if v<m:
doll+=k*v
m-=v
else:
doll+=k*m
print(doll)
exit()
|
p03103
|
n,m = list(map(int,input().split()))
a = []
b = []
for _ in range(n):
a1,b1 = list(map(int,input().split()))
a.append(a1)
b.append(b1)
ans = 0
cnt = 0
flag = 1
while flag:
flag = 0
for i in range(n-1,0,-1):
if a[i] < a[i-1]:
a[i],a[i-1] = a[i-1],a[i]
b[i],b[i-1] = b[i-1],b[i]
flag = 1
for i in range(n):
flag = 1
while b[i] > 0 and cnt < m:
ans += a[i]
cnt += 1
b[i] -= 1
flag = 0
if flag:
break
print(ans)
|
n,m = list(map(int,input().split()))
a = []
b = []
for _ in range(n):
a1,b1 = list(map(int,input().split()))
a.append(a1)
b.append(b1)
c = sorted(zip(a,b))
ans = 0
for i in range(n):
if m > c[i][1]:
ans += c[i][0]*c[i][1]
m -= c[i][1]
else:
ans += c[i][0]*m
break
print(ans)
|
p03103
|
n,m=list(map(int,input().split()))
ab=[]
for i in range(n):
a=list(map(int,input().split()))
ab.append(a)
ab=sorted(ab, key=lambda x:x[0])
cnt,ans,j=0,0,0
while cnt<m:
if ab[j][1]>=m-cnt:
ans+=ab[j][0]*(m-cnt)
cnt=m
else:
ans+=ab[j][0]*ab[j][1]
cnt+=ab[j][1]
j+=1
print(ans)
|
n,m=list(map(int,input().split()))
a=sorted([list(map(int,input().split())) for i in range(n)])
cnt,ans,j=0,0,0
while cnt<m:
cnt+=a[j][1]
ans+=a[j][0]*a[j][1]
j+=1
print((ans-(cnt-m)*a[j-1][0]))
|
p03103
|
a, b = list(map(int, input().split()))
A = []
B = []
for i in range(a):
c, d = list(map(int, input().split()))
A.append(c)
B.append(d)
ans = 0
for i in range(a*b + 1):
j = A.index(min(A))
if(b - B[j] >=0):
ans += A[j] * B[j]
b -= B[j]
A[j] = 1000000
else:
ans += A[j] * b
b = 0
if(b == 0):
break
print(ans)
|
a, b = list(map(int, input().split()))
A = []
for i in range(a):
c= list(map(int, input().split()))
A.append(c)
ans = 0
A.sort(key=lambda x:x[0])
for j in range(a+1):
if(b - A[j][1] >=0):
ans += A[j][0] * A[j][1]
b -= A[j][1]
else:
ans += A[j][0] * b
b = 0
if(b == 0):
break
print(ans)
|
p03103
|
n,m = list(map(int,input().split()))
drink = [list(map(int,input().split())) for _ in range(n)]
drink = sorted(drink, key=lambda drink:drink[0])
money = 0
total = 0
for i in range(n):
if total+drink[i][1]<m:
total += drink[i][1]
money += drink[i][1]*drink[i][0]
else:
money += drink[i][0]*(m-total)
print(money)
exit()
|
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(n)]
ab = sorted(ab, key=lambda ab:ab[0])
ans = 0
total = 0
for i in range(n):
num = m - total
if ab[i][1]<num:
total += ab[i][1]
ans += ab[i][0]*ab[i][1]
else:
total += num
ans += num*ab[i][0]
break
print(ans)
|
p03103
|
N,M=list(map(int, input().split()))
AB=[]
for i in range(N):
AB.append(list(map(int,input().split())))
AB.sort()
count=0
summary=0
for i in range(N):
for j in range(AB[i][1]):
summary+=AB[i][0]
count+=1
if count==M:
print(summary)
break
|
N,M=list(map(int, input().split()))
AB=[]
for i in range(N):
AB.append(list(map(int,input().split())))
AB.sort()
count=0
summary=0
for i in range(N):
for j in range(AB[i][1]):
summary+=AB[i][0]
count+=1
if count==M:
print(summary)
break
else:
continue
break
|
p03103
|
var = list(map(int, input().split()))
N = var[0]
M = var[1]
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
C = list(zip(A,B))
C = sorted(C)
A, B = list(zip(*C))
index = 0
count = 0
for i in range(N):
if(count<=M):
index = i
count += B[i]
count = 0
sum = 0
for i in range (index):
sum+=A[i]*B[i]
count+=B[i]
sum +=A[index]*(M-count)
print(sum)
|
N, M = list(map(int, input().split()))
A = []
B = []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
C = list(zip(A,B))
C = sorted(C)
A, B = list(zip(*C))
index = 0
count = 0
sum = 0
for i in range(N):
if(count<=M):
index = i
sum += A[i]*B[i]
count += B[i]
sum +=A[index]*(M-count)
print(sum)
|
p03103
|
n, m = list(map(int, input().split()))
money = 0
li = []
for i in range(n):
li.append(list(map(int, input().split())))
li.sort()
while 0 < m:
shop = li.pop(0)
if m < shop[1]:
money += m * shop[0]
break
money += shop[0] * shop[1]
m -= shop[1]
print(money)
|
n, m = list(map(int, input().split()))
money = 0
li = []
for i in range(n):
li.append(list(map(int, input().split())))
li.sort()
for j in range(n):
shop = li.pop(0)
if m < shop[1]:
money += m * shop[0]
break
money += shop[0] * shop[1]
m -= shop[1]
print(money)
|
p03103
|
from operator import itemgetter
n, m = list(map(int, input().split()))
money = 0
li = sorted([list(map(int, input().split())) for _ in range(n)])
for j in range(n):
shop = li.pop(0)
if m < shop[1]:
money += m * shop[0]
break
money += shop[0] * shop[1]
m -= shop[1]
print(money)
|
n, m = list(map(int, input().split()))
money = 0
li = [list(map(int, input().split())) for _ in range(n)]
li.sort()
for j in range(n):
shop = li[j]
if m < shop[1]:
money += m * shop[0]
break
money += shop[0] * shop[1]
m -= shop[1]
print(money)
|
p03103
|
N, M = list(map(int, input().split()))
A_list=[]
B_list=[]
for i in range(N):
A, B = list(map(int,input().split()))
A_list.append(A)
B_list.append(B)
cost = 0
total_num = 0
num = 0
while True:
index = A_list.index(min(A_list))
num = B_list[index]
if M > num:
total_num += num
cost += min(A_list)*num
A_list.pop(index)
B_list.pop(index)
M -= num
else:
cost += min(A_list)*M
break
print(cost)
|
N, M = list(map(int, input().split()))
AB_list=[]
for i in range(N):
A, B = list(map(int,input().split()))
AB_list.append([A, B])
AB_list = sorted(AB_list)
cost = 0
num = 0
for AB in AB_list:
num = AB[1]
if M > num:
cost += AB[0]*num
M -= num
else:
cost += AB[0]*M
break
print(cost)
|
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)
R,S=M,0
while R!=0:
mloc=A.index(min(A))
AA=A.pop(mloc)
BB=B.pop(mloc)
if BB>=R:
S+=AA*R;R=0
else:
S+=AA*BB;R-=BB
print(S)
|
N,M=list(map(int, input().split()))
A,B=[],[]
for i in range(N):
A.append(list(map(int, input().split())))
A.sort(key=lambda x:x[0])
R,S=M,0
for a in A:
if a[1]>=R:
S+=a[0]*R;R=0
else:
S+=a[0]*a[1];R-=a[1]
if R==0: break
print(S)
|
p03103
|
import sys
input = sys.stdin.readline
from collections import deque
def main():
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)
have = 0
price = 0
while M != have:
AB[0][1] -= 1
price += AB[0][0]
have += 1
if AB[0][1] == 0:
del AB[0]
print(price)
main()
|
import sys
input = sys.stdin.readline
from collections import deque
def main():
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)
have = 0
price = 0
for x, y in AB:
if M - have < y:
price += x * (M - have)
break
else:
price += x * y
have += y
print(price)
main()
|
p03103
|
from operator import itemgetter
N, M = list(map(int, input().split()))
A_list = []
for _ in range(N):
A, B = list(map(int, input().split()))
A_list.append([A, B])
A_list.sort(key=itemgetter(0))
dp = [0]*(M+1)
for i in range(1, M+1):
for j in range(len(A_list)):
if A_list[j][1]>0:
A_list[j][1]-=1
break
dp[i] = dp[i-1]+A_list[j][0]
print((dp[M]))
|
import sys
N,M = list(map(int, input().split()))
L = []
for _ in range(N):
A,B = list(map(int, input().split()))
L.append([A,B])
L = sorted(L, key=lambda x: x[0])
sum = 0
for i in range(len(L)):
l = L[i]
if l[1]<M:
M = M - l[1]
sum = sum + l[0]*l[1]
else:
sum = sum + l[0]*M
print(sum)
sys.exit()
print(sum)
|
p03103
|
import sys
N,M = list(map(int,input().split()))
A = []
B = []
for i in range(N):
tmp_a,tmp_b = list(map(int,input().split()))
A.append(tmp_a)
B.append(tmp_b)
sum_A,sum_B = 0,0
while(M-sum_B)>0:
min_index = A.index(min(A))
if (M-sum_B) > B[min_index]:
sum_A += min(A)*B[min_index]
sum_B += B[min_index]
A.pop(min_index)
B.pop(min_index)
else:
sum_A += min(A)*(M-sum_B)
print(sum_A)
sys.exit()
|
import sys
N,M = list(map(int,input().split()))
List =[]
for i in range(N):
tmp_a,tmp_b = list(map(int,input().split()))
List.append([tmp_a,tmp_b])
List.sort()
sum_a,sum_b = 0,0
for i in range(N):
if M-sum_b > List[i][1]:
sum_a += List[i][0]*List[i][1]
sum_b += List[i][1]
else:
sum_a += List[i][0]*(M-sum_b)
sum_b += M-sum_b
print(sum_a)
sys.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()))
index_list = []
a = A.copy()
for i in range(N):
index_list.append(a.index(min(a)))
a[a.index(min(a))] = 10 ** 9
sum = 0
num = 0
for i in index_list:
num += B[i]
if num >= M:
num -= B[i]
for j in range(B[i]):
sum += A[i]
num += 1
if num >= M:
print(sum)
exit()
else:
sum += A[i] * B[i]
|
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()))
AB = list(zip(A, B))
AB.sort()
A, B = list(zip(*AB))
sum = 0
num = 0
for i in range(N):
num += B[i]
if num >= M:
num -= B[i]
for j in range(B[i]):
num += 1
sum += A[i]
if num >= M:
print(sum)
exit()
else:
sum += A[i] * B[i]
|
p03103
|
import sys
stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
N,M = read_int()
price_howmany = {}
price_list = []
for _ in range(N):
tmp = read_int()
if tmp[0] not in price_list:
price_list.append(tmp[0])
if tmp[0] in price_howmany:
price_howmany[tmp[0]] += tmp[1]
else:
price_howmany[tmp[0]] = tmp[1]
price_list.sort()
def solve():
price = 0
global M
for low_price in price_list:
many = min(M,price_howmany.pop(low_price))
price += many * low_price
M -= many
if M == 0: break
print(price)
if __name__ == "__main__":
solve()
|
# from collections import defaultdict
# N,M = list(map(int,input().split()))
# price_howmany = defaultdict(int)
import sys
stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
N,M = read_int()
price_howmany = {}
# price_list = []
price_set = set()
for _ in range(N):
tmp = read_int()
# if tmp[0] not in price_set:
# price_list.append(tmp[0])
price_set.add(tmp[0])
if tmp[0] in price_howmany:
price_howmany[tmp[0]] += tmp[1]
else:
price_howmany[tmp[0]] = tmp[1]
# price_list.sort(reverse=True)
price_list = sorted(list(price_set))
# price_howmany = dict(price_howmany)
def solve():
price = 0
global M
# while M > 0:
# low_price = min(price_howmany.keys())
# low_price = price_list.pop()
# many = min(M,price_howmany.pop(low_price))
# price += many * low_price
# M -= many
for low_price in price_list:
many = min(M,price_howmany.pop(low_price))
price += many * low_price
M -= many
if M == 0: break
print(price)
if __name__ == "__main__":
solve()
|
p03103
|
N,M=list(map(int,input().split()))
S=[]
for i in range(N):
A,B=list(map(int,input().split()))
S.append([A,B])
S.sort()
m=0
for i in range(M):
for j in range(N):
if S[j][1]!=0:
m+=S[j][0]
S[j][1]-=1
break
print(m)
|
N,M=list(map(int,input().split()))
S=[]
for i in range(N):
A,B=list(map(int,input().split()))
S.append([A,B])
S.sort()
m=0
while M>0:
for i in range(N):
if S[i][1]<=M:
m+=S[i][0]*S[i][1]
M-=S[i][1]
else:
m+=S[i][0]*M
M=0
break
print(m)
|
p03103
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.