input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
info=[]
for i in range(m):
b,c=list(map(int,input().split()))
info.append([c,b])
a=sorted(a) #小さい順に
info=sorted(info,reverse=True)
b=[] #n枚まで、大きい順に変えられるやつを記録
total=0
def add(num,s):
global b
for i in range(s):
b.append(num)
for i in range(m):
total+=info[i][1]
if n<=total:
total-=info[i][1]
add(info[i][0],n-total)
add(info[i][0],info[i][1])
l=len(b)
ans=0
for i in range(n):
if i<=l-1:
ans+=max(a[i],b[i])
else:
ans+=a[i]
print(ans) | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
info=[]
for i in range(m):
b,c=list(map(int,input().split()))
info.append([c,b])
a=sorted(a) #小さい順に
info=sorted(info,reverse=True)
b=[] #n枚まで、大きい順に変えられるやつを記録
total=0
def add(num,s):
global b
for i in range(s):
b.append(num)
for i in range(m):
total+=info[i][1]
if n<=total:
total-=info[i][1]
add(info[i][0],n-total)
break
add(info[i][0],info[i][1])
l=len(b)
ans=0
for i in range(n):
if i<=l-1:
ans+=max(a[i],b[i])
else:
ans+=a[i]
print(ans) | p03038 |
n,m = list(map(int,input().split()))
a_list = list(map(int,input().split()))
for i in range(m):
b,c = list(map(int,input().split()))
for i in range(b):
a_list.append(c)
a_list.sort()
print((sum(a_list[::-1][0:n]))) | n,m = list(map(int,input().split()))
a_list = list(map(int,input().split()))
b_list = []
for i in range(m):
b_list.append(list(map(int,input().split())))
b_list.sort(key=lambda x: x[1],reverse=True)
cnt = 0
for i in range(m):
for j in range(b_list[i][0]):
if cnt > n:
break
a_list.append(b_list[i][1])
cnt += 1
a_list.sort()
print((sum(a_list[::-1][0:n]))) | p03038 |
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(m):
a, b = list(map(int, input().split()))
for _ in range(a):
A.append(b)
A = sorted(A)
print((sum(A[-n:]))) | n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = []
C = []
for i in range(m):
b, c = list(map(int, input().split()))
B.append(b)
C.append(c)
D = list(zip(C, B))
D = sorted(D)
C, B = list(zip(*D))
C = reversed(C)
B = reversed(B)
total = 0
for i, j in zip(C, B):
if total >= n:
break
else:
total += j
A.extend([i] * j)
A = sorted(A)
print((sum(A[-n:]))) | p03038 |
import bisect
n, m = list(map(int, input().split()))
arr = sorted(list(map(int, input().split())))
ope = []
d = []
for i in range(m):
ope.append(list(map(int,input().split())))
ope = sorted(ope,key = lambda x:-x[1])
for b,c in ope:
if len(d) == n:
break
elif len(d) + b > n:
for i in range(n-b):
d.append(c)
else:
for i in range(b):
d.append(c)
d.reverse()
arr = sorted(arr,reverse = True)
x = [0]*(n+1)
x[0] = sum(arr)
for i in range(1,n+1):
t_arr = arr.pop()
if d:
t_d = d.pop()
else:
t_d = t_arr
x[i] = x[i-1] + t_d - t_arr
if x[i] < x[i-1]:
break
print((max(x)))
| import bisect
n, m = list(map(int, input().split()))
arr = sorted(list(map(int, input().split())))
ope = []
d = []
for i in range(m):
ope.append(list(map(int,input().split())))
ope = sorted(ope,key = lambda x:-x[1])
i = 0
ok = True
for b,c in ope:
for rep in range(b):
if i >= n or arr[i] > c:
ok = False
break
arr[i] = c
i += 1
if ok:
continue
else:
break
print((sum(arr))) | p03038 |
import sys
import bisect
N, M = list(map(int, input().split()))
A = sorted(map(int, input().split()))
for _ in range(M):
b, c = list(map(int, sys.stdin.readline().split()))
x = bisect.bisect_left(A, c)
y = min(x, b)
A = [c] * y + A[y:]
if x != y:
A.sort()
print((sum(A))) | import sys
import bisect
N, M = list(map(int, input().split()))
A = sorted(map(int, input().split()))
CB = [None] * M
for i in range(M):
b, c = list(map(int, sys.stdin.readline().split()))
CB[i] = (c, b)
CB.sort(reverse=True)
i = 0
ans = 0
for c, b in CB:
x = bisect.bisect_left(A, c, i)
count = min(x - i, b)
ans += c * count
i += count
for j in range(i, N):
ans += A[j]
print(ans) | p03038 |
import heapq
import sys
input = sys.stdin.readline
def readlines(n):
for _ in range(n):
b, c = list(map(int, input().split()))
yield b, c
def main():
_, M = list(map(int, input().split()))
A = list(map(int, input().split()))
total = sum(A)
heapq.heapify(A)
for b, c in sorted(readlines(M), key=lambda x: -x[1]):
for _ in range(b):
o = heapq.heappushpop(A, c)
if o < c:
total += c - o
else:
break
print(total)
main() | import heapq
import sys
input = sys.stdin.readline
from operator import itemgetter
def readlines(n):
for _ in range(n):
b, c = list(map(int, input().split()))
yield b, c
def main():
_, M = list(map(int, input().split()))
A = list(map(int, input().split()))
total = sum(A)
heapq.heapify(A)
for b, c in sorted(readlines(M), key=itemgetter(1), reverse=True):
for _ in range(b):
o = heapq.heappushpop(A, c)
if o < c:
total += c - o
else:
break
print(total)
main() | p03038 |
from collections import Counter
from heapq import heapify, heappop, heappush
class Data:
def __init__(self, value, count):
self.value = value
self.count = count
def __lt__(self, other):
return self.value > other.value
# 降順に取り出す
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
q = list()
heapify(q)
for v, c in list(Counter(a).items()):
heappush(q, Data(v, c))
for _ in range(M):
c, v = list(map(int, input().split()))
heappush(q, Data(v, c))
ans = 0
cnt = 0
while cnt < N:
d = heappop(q)
# print(d.value, d.count)
chg = min(N - cnt, d.count)
ans += chg * d.value
cnt += chg
print(ans)
| from heapq import heapify, heappush, heappop
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
hq = list([(-x, 1) for x in a])
heapify(hq)
for _ in range(M):
b, c = list(map(int, input().split()))
heappush(hq, (-c, b))
rest = N
ans = 0
while rest > 0 and hq:
mv, b = heappop(hq)
mv *= -1
use = min(rest, b)
ans += mv * use
rest -= use
print(ans)
| p03038 |
from heapq import heapify, heappush, heappop
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
hq = list([(-x, 1) for x in a])
heapify(hq)
for _ in range(M):
b, c = list(map(int, input().split()))
heappush(hq, (-c, b))
rest = N
ans = 0
while rest > 0 and hq:
mv, b = heappop(hq)
mv *= -1
use = min(rest, b)
ans += mv * use
rest -= use
print(ans)
| from heapq import heappop, heappush
n, m = list(map(int, input().split()))
a = tuple(map(int, input().split()))
hq = []
for aa in a:
heappush(hq, (-aa, 1))
for _ in range(m):
b, c = list(map(int, input().split()))
heappush(hq, (-c, b))
rest = n
ans = 0
while rest > 0:
num, cnt = heappop(hq)
num *= (-1)
use = min(rest, cnt)
ans += use * num
rest -= use
print(ans)
| p03038 |
def main():
from collections import Counter
from operator import itemgetter
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
ctr = Counter(a)
for _ in range(M):
b, c = list(map(int, input().split()))
ctr[c] += b
ans = 0
rest = N
for integer, count in sorted(list(ctr.items()), key=itemgetter(0), reverse=True):
take = min(rest, count)
ans += take * integer
rest -= take
if not rest:
break
print(ans)
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
| def main():
from collections import defaultdict
from operator import itemgetter
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
ctr = defaultdict(int)
for x in A:
ctr[x] += 1
for _ in range(M):
num_of_cards, int_written_on_cards = list(map(int, input().split()))
ctr[int_written_on_cards] += num_of_cards
rest = N
total = 0
for int_written_on_cards, num_of_cards in sorted(list(ctr.items()), key=itemgetter(0), reverse=True):
take = min(rest, num_of_cards)
total += int_written_on_cards * take
rest -= take
if rest == 0:
break
print(total)
if __name__ == '__main__':
main()
| p03038 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [[int(i) for i in input().split()] for i in range(m)]
bc.sort(key = lambda x:x[1], reverse = True)
a.sort()
d = []
loop = 0
while True:
for b, c in bc:
d.extend([c] * b)
loop += 1
if len(d) > n:
break
elif loop == m:
break
while True:
if a[0] < d[0]:
a.append(d[0])
del a[0]
del d[0]
else:
break
if d == []:
break
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [[int(i) for i in input().split()] for i in range(m)]
bc.sort(key = lambda x:x[1], reverse = True)
a.sort()
for b, c in bc:
if c > a[0]:
for i in range(b):
if c > a[0]:
del a[0]
a.append(c)
else:
break
else:
break
print((sum(a))) | p03038 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [[int(i) for i in input().split()] for i in range(m)]
bc.sort(key = lambda x:x[1], reverse = True)
a.sort()
for b, c in bc:
if c > a[0]:
for i in range(b):
if c > a[0]:
del a[0]
a.append(c)
else:
break
else:
break
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [[int(i) for i in input().split()] for i in range(m)]
bc.sort(key = lambda x:x[1], reverse = True)
a.sort()
a_count = 0
for b, c in bc:
if c > a[a_count]:
for i in range(b):
if c > a[a_count]:
a[a_count] = c
a_count += 1
else:
break
if a_count == n:
break
else:
break
if a_count == n:
break
print((sum(a))) | p03038 |
from io import StringIO
from collections import *
from functools import *
import sys
def main(inputs):
# n = int(next(inputs))
# n, k = map(int, next(inputs).split())
# xs = list(map(int, next(inputs).split()))
n, m = list(map(int, next(inputs).split()))
an = list(map(int, next(inputs).split()))[:n]
an.sort()
bc = [ list(map(int, next(inputs).split())) for _ in range(m) ]
bc.sort(key=lambda bc: bc[1]) # sort by c
ans = 0
for b, c in bc:
for i in range(b):
if an[i] < c:
an[i] = c
pass
pass
an.sort()
pass
return sum(an)
def gen_inputs(str_=None):
inputs = StringIO(str_) if str_ else sys.stdin
while True:
a = inputs.readline().rstrip()
yield a
pass
pass
if __name__ == "__main__":
print((main(gen_inputs())))
pass
| from io import StringIO
from collections import *
from functools import *
import sys
def main(inputs):
# n = int(next(inputs))
# n, k = map(int, next(inputs).split())
# xs = list(map(int, next(inputs).split()))
n, m = list(map(int, next(inputs).split()))
an = list(map(int, next(inputs).split()))[:n]
an.sort()
bc = [ list(map(int, next(inputs).split())) for _ in range(m) ]
bc.sort(key=lambda bc: bc[1], reverse=True) # sort by c
x = 0
y = 0
ans = 0
for i in range(n):
if x < m and bc[x][1] >= an[i]:
ans += bc[x][1]
y += 1
if y >= bc[x][0]:
x += 1
y = 0
pass
pass
else:
ans += an[i]
pass
pass
return ans
def gen_inputs(str_=None):
inputs = StringIO(str_) if str_ else sys.stdin
while True:
a = inputs.readline().rstrip()
yield a
pass
pass
if __name__ == "__main__":
print((main(gen_inputs())))
pass
| p03038 |
from heapq import heapify,heappop,heappush
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = [list(map(int,input().split())) for _ in range(M)]
heapify(A)
for j in range(M):
B = []
for i in range(BC[j][0]):
b = heappop(A)
if b < BC[j][1]:
b = BC[j][1]
B.append(b)
for i in range(BC[j][0]):
heappush(A,B[i])
print((sum(A)))
| #要修正 方針は合っているようだが・・・
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = [list(map(int,input().split())) for _ in range(M)]
A.sort()
BC.sort(reverse=True,key = lambda x:x[1])
pt,card,index = 0,BC[0][1],0
while True:
for i in range(BC[index][0]):
if pt < N:
A[pt] = max(A[pt],card)
else:
break
pt += 1
index += 1
if index < M:
card = BC[index][1]
else:
break
print((sum(A)))
| p03038 |
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=sorted(a)
k=[[int(i) for i in input().split()] for i in range(m)]
k=sorted(k,key=lambda x:-x[1])
now=0
flag=True
for x,y in k:
if flag:
for i in range(x):
if flag and i+now<n:
if y>a[i+now]:
a[i+now]=y
else:
flag=False
now+=x
print((sum(a))) | def main():
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a=sorted(a)
k=[[int(i) for i in input().split()] for i in range(m)]
k=sorted(k,key=lambda x:-x[1])
now=0
flag=True
for x,y in k:
if flag:
for i in range(x):
if i+now>=n:
print((sum(a)))
exit()
if flag:
if y>a[i+now]:
a[i+now]=y
else:
flag=False
now+=x
print((sum(a)))
if __name__=="__main__":
main() | p03038 |
n,m = list(map(int,input().split()))
a = [i for i in map(int,input().split())]
bc = [[i for i in map(int,input().split())] for j in range(m)]
a.sort(reverse=True)
bc.sort(key=lambda x: x[1], reverse=True)
arr = []
j = 0
for i in range(n):
arr.append(bc[j][1])
bc[j][0]-=1
if bc[j][0]==0:
j += 1
if j >= m:
break
while len(arr) < n:
arr.append(a.pop(0))
arr.sort()
for i in range(len(a)):
if arr[0] < a[0]:
arr[0] = a.pop(0)
arr.sort()
print((sum(arr))) | n,m = list(map(int,input().split()))
a = [i for i in map(int,input().split())]
bc = [[i for i in map(int,input().split())] for j in range(m)]
a.sort()
bc.sort(key=lambda x: x[1], reverse=True)
j = 0
for i in range(n):
if a[i] < bc[j][1]:
a[i]=bc[j][1]
bc[j][0]-=1
if bc[j][0]==0:
j += 1
if j >= m:
break
print((sum(a))) | p03038 |
N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
A_list.sort()
BC_list = [list(map(int, input().split())) for _ in range(M)]
BC_list = [BC_list[i][1] for i in range(M) for _ in range(BC_list[i][0])]
A_list.extend(BC_list)
A_list.sort()
print((sum(A_list[-N:])))
| N, M = list(map(int, input().split()))
A_list = list(map(int, input().split()))
A_list.sort()
BC_list = [list(map(int, input().split())) for _ in range(M)]
BC_list = sorted(BC_list, key=lambda x: x[1])
ans = 0
count = 0
i = N-1
m = M-1
while count < N:
if A_list[i] < BC_list[m][1]:
for _ in range(BC_list[m][0]):
ans += BC_list[m][1]
count += 1
if count >= N:
break
m -= 1
else:
ans += A_list[i]
count += 1
i -= 1
if m < 0:
break
for _ in range(count, N):
ans += A_list[i]
i -= 1
print(ans)
| p03038 |
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
for _ in range(M):
B, C = list(map(int,input().split()))
A += [C]*B
A.sort(reverse=True)
print((sum(A[:N]))) | N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
for _ in range(M):
B, C = list(map(int,input().split()))
A += [C]*B
A.sort(reverse=True)
A = A[:N]
print((sum(A))) | p03038 |
import copy
n, m = [int(i) for i in input().split()]
ans = []
a = list(map(int, input().split()))
for i in range(len(a)):
ans.append([1, a[i]])
b = []
c = []
for i in range(m):
d, e = [int(i) for i in input().split()]
ans.append([d, e])
ans1 = sorted(ans, key=lambda x: x[1], reverse = True)
ans2 = []
for i in range(len(ans1)):
for j in range(ans1[i][0]):
ans2.append(ans1[i])
ans3 = []
for i in range(n):
ans3.append(ans2[i][1])
print((sum(ans3))) | import copy
n, m = [int(i) for i in input().split()]
ans = []
a = list(map(int, input().split()))
for i in range(len(a)):
ans.append([1, a[i]])
for i in range(m):
d, e = [int(i) for i in input().split()]
ans.append([d, e])
ans1 = sorted(ans, key=lambda x: x[1], reverse = True)
cnt = 0
ans2 = 0
k = 0
while cnt < n:
ans2 += ans1[k][0] * ans1[k][1]
cnt += ans1[k][0]
k += 1
ans2 -= (cnt - n) * ans1[k-1][1]
print(ans2) | p03038 |
from operator import itemgetter
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [list(map(int, input().split())) for i in range(m)]
bc = sorted(bc, key=itemgetter(1))
for i in range(m):
k = 0
a.sort()
while k<bc[i][0] and a[k]<bc[i][1]:
a[k] = bc[i][1]
k += 1
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
cb=[]
for i in range(m):
b, c = list(map(int, input().split()))
cb.append([c,b])
cb.sort(reverse=True)
k=0
for i in range(m):
j=0
while j<cb[i][1] and k+j<n and a[k+j]<cb[i][0]:
a[k+j] = cb[i][0]
j+=1
k+=j
if k==n:
break
print((sum(a)))
| p03038 |
n,m=list(map(int,input().split()))
a = list(map(int, input().split()))
d=[]
for i in range(m):
b,c = list(map(int, input().split()))
d.extend([c]*b)
d.sort(reverse=True)
if len(d)>n:d=d[:n]
a.extend(d)
a.sort(reverse=True)
print((sum(a[:n]))) | n,m=list(map(int,input().split()))
a = list(map(int, input().split()))
bc=[list(map(int,input().split())) for _ in range(m)]
#print(bc)
bc=sorted(bc,key= lambda x:x[1],reverse=True)
#print(bc)
bc2=[]
for i in range(m):
bc2.extend([bc[i][1]]*bc[i][0])
if len(bc2)>n: break
#print(bc2)
a.extend(bc2)
a.sort(reverse=True)
print((sum(a[:n]))) | p03038 |
#7 Integer Cards
n,m = list(map(int,input().split()))
a = list( map(int,input().split()))
bc=[[0]*2 for _ in range(m)]
for i in range(m):
bc[i] = list(map(int,input().split()))
a.sort()
bc.sort(reverse=True,key=lambda x:x[1])
import bisect
ans=[]
for (bb,cc) in bc:
idx = bisect.bisect(a,cc)
n_replace = min(idx,bb)
ans.extend([cc]*n_replace)
a=a[n_replace:]
print((sum(ans)+sum(a)))
| n,m = list(map(int,input().split()))
a = list( map(int,input().split()))
bc=[[0]*2 for _ in range(m)]
for i in range(m):
bc[i] = list(map(int,input().split()))
a.sort()
bc.sort(reverse=True,key=lambda x:x[1])
nokori=n
bc2=[]
for (bb,cc) in bc:
if bb<=nokori:
bc2.extend([cc]*bb)
nokori-=bb
else:
bc2.extend([cc]*nokori)
nokori=0
break
ans=sum(a)
for i in range(0,min(n,len(bc2))):
if bc2[i]>a[i]:
ans+=bc2[i]-a[i]
else:
break
print(ans) | p03038 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
bc=[]
import heapq
heapq.heapify(a)
for _ in range(m):
b,c=list(map(int,input().split()))
for _ in range(b):
temp=heapq.heappop(a)
if temp<c:
heapq.heappush(a,c)
else:
heapq.heappush(a,temp)
break
#print(a)
print((sum(list(a)))) | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
#bc=[]
import heapq
heapq.heapify(a)
bc=[]
for _ in range(m):
b,c=list(map(int,input().split()))
bc.append((c,b))
bc.sort(reverse=True)
for item in bc:
b=item[1]
c=item[0]
for _ in range(b):
temp=heapq.heappop(a)
if temp<c:
heapq.heappush(a,c)
else:
heapq.heappush(a,temp)
print((sum(list(a))))
exit()
#print(a)
print((sum(list(a)))) | p03038 |
from bisect import bisect_left, bisect_right
def readinput():
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
c=[]
for _ in range(m):
bb,cc=list(map(int,input().split()))
b.append(bb)
c.append(cc)
return n,m,a,b,c
def main(n,m,a,b,c):
a.sort()
for i in range(m):
#print(a)
bi=b[i]
ci=c[i]
j=bisect_left(a,ci)-1
if j<0:
continue
if j>bi-1:
save=a[bi:j+1]
l=j-bi+1
r=j
a[l:r+1]=[ci]*(r-l+1)
a[0:l]=save
else:
l=0
r=j
a[l:r+1]=[ci]*(r-l+1)
sum=0
for i in range(n):
sum+=a[i]
return sum
if __name__=='__main__':
n,m,a,b,c=readinput()
ans=main(n,m,a,b,c)
print(ans)
| from bisect import bisect_left, bisect_right
def readinput():
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
c=[]
for _ in range(m):
bb,cc=list(map(int,input().split()))
b.append(bb)
c.append(cc)
return n,m,a,b,c
def main(n,m,a,b,c):
a.sort()
for i in range(m):
#print(a)
bi=b[i]
ci=c[i]
j=bisect_left(a,ci)-1
if j<0:
continue
if j>bi-1:
save=a[bi:j+1]
l=j-bi+1
r=j
a[l:r+1]=[ci]*(r-l+1)
a[0:l]=save
else:
l=0
r=j
a[l:r+1]=[ci]*(r-l+1)
sum=0
for i in range(n):
sum+=a[i]
return sum
def main2(n,m,a,b,c):
all=[]
for i in range(n):
all.append((a[i],1))
for i in range(m):
all.append((c[i],b[i]))
all.sort(reverse=True, key=lambda x:x[0])
#print(all)
count=n
sum=0
i=0
while(count>0):
ni=all[i][1]
if ni<=count:
sum+=all[i][0]*ni
count-=ni
else:
sum+=all[i][0]*count
count=0
i+=1
#print(sum,count)
return sum
if __name__=='__main__':
n,m,a,b,c=readinput()
ans=main2(n,m,a,b,c)
print(ans)
| p03038 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
cards = []
for _ in range(m):
b, c = list(map(int, input().split()))
cards.append([c, b])
cards.sort()
ans = 0
for i, num in enumerate(a):
if not cards:
break
c, b = cards.pop()
if c > num:
a[i] = c
b -= 1
else:
break
if b:
cards.append([c, b])
print((sum(a)))
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
x = []
for _ in range(m):
b, c = list(map(int, input().split()))
x.append([b, c])
x.sort(key=lambda p: p[1], reverse=True)
ret = 0
for b, c in x:
if not a:
break
if c > a[-1]:
while c > a[-1]:
ret += c
a.pop()
b -= 1
if b == 0:
break
if not a:
break
else:
break
print((ret + sum(a)))
| p03038 |
from operator import itemgetter
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = []
for i in range(M):
tmp = list(map(int,input().split()))
BC.append(tmp)
A.sort(reverse=True)
BC.sort(key=itemgetter(1),reverse=True)
l = 0
r = N-1
flg = False
for k in range(M):
# l tansaku
for p in range(N):
if BC[k][1] > A[p]:
l = p
break
elif p == N-1:
flg = True
#break
if flg or r < l: break
tmpC = BC[k][1]
#chikan
for o in range(BC[k][0]):
if r < l or r == -1:
flg = True
break
A[r] = tmpC
r -= 1
print((sum(A))) | from operator import itemgetter
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = []
for i in range(M):
tmp = list(map(int,input().split()))
BC.append(tmp)
A.sort(reverse=True)
BC.sort(key=itemgetter(1),reverse=True)
l = 0
r = N-1
flg = False
for k in range(M):
# l tansaku
for p in range(l,N):
if BC[k][1] > A[p]:
l = p
break
elif p == N-1:
flg = True
#break
if flg or r < l: break
tmpC = BC[k][1]
#chikan
for o in range(BC[k][0]):
if r < l or r == -1:
flg = True
break
A[r] = tmpC
r -= 1
print((sum(A)))
| p03038 |
N,M = list(map(int,input().split(' ')))
A = list(map(int,input().split(' ')))
B =[]
C =[]
l = [list(map(int,input().split())) for i in range(M)]
A.sort()
l = sorted(l,key = lambda x:x[1])
flag =False
for i in l[::-1]:
for j in A[:i[0]]:
k = i[1]
if j<k:
if len(A)>1:
A = A[1:]
A.append(k)
else:
A[0] = k
else:
flag = True
break
if flag:
break
print((sum(A))) | N,M = list(map(int,input().split(' ')))
A = list(map(int,input().split(' ')))
l = [list(map(int,input().split())) for i in range(M)]
A.sort()
l = sorted(l,key = lambda x:x[1])
ind =0
for b,c in l[::-1]:
mx = min(N,ind+b)
for i in range(ind,mx):
if c>A[i]:
A[i] = c
if mx==N:
break
ind += b
print((sum(A))) | p03038 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
A.sort()
BC.sort(key=lambda bc: bc[1], reverse=True)
update_bc = [0 for _ in range(N)]
cnt = 0
for b, c in BC:
for i in range(b):
if cnt < N:
update_bc[cnt] = c
cnt += 1
for i in range(N):
if A[i] < update_bc[i]:
A[i] = update_bc[i]
else:
break
print((sum(A)))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
A.sort()
BC.sort(key=lambda bc: bc[1], reverse=True)
update_bc = [0 for _ in range(N)]
cnt = 0
for b, c in BC:
for i in range(b):
if cnt < N:
update_bc[cnt] = c
cnt += 1
else:
break
if cnt >= N:
break
for i in range(N):
if A[i] < update_bc[i]:
A[i] = update_bc[i]
else:
break
print((sum(A)))
| p03038 |
import bisect
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b, c = [], []
heapq.heapify(a)
for i in range(m):
v1, v2 = list(map(int, input().split()))
b.append(v1)
c.append(v2)
for i in range(m):
cnt = 0
while True:
if cnt == b[i]:
break
minV = heapq.heappop(a)
#print('# minV: ' + str(minV))
if minV >= c[i]:
heapq.heappush(a, minV)
break
else:
heapq.heappush(a, c[i])
cnt += 1
#print(a)
print((sum(a)))
| import bisect
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
#b, c = [], []
bc = []
heapq.heapify(a)
for i in range(m):
bc.append(list(map(int, input().split())))
# v1, v2 = map(int, input().split())
# b.append(v1)
# c.append(v2)
bc.sort(key = lambda x: x[1], reverse=True)
for i in range(m):
cnt = 0
while True:
if cnt == bc[i][0]:
break
minV = heapq.heappop(a)
#print('# minV: ' + str(minV))
if minV >= bc[i][1]:
heapq.heappush(a, minV)
break
else:
heapq.heappush(a, bc[i][1])
cnt += 1
#print(a)
print((sum(a)))
| p03038 |
from bisect import bisect_left
from operator import itemgetter
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = []
X = []
for _ in range(M):
b, c = list(map(int, input().split()))
X.append((b, c))
X = sorted(X, key=itemgetter(1), reverse=True)
for b, c in X:
BC.extend([c] * b)
if len(BC) >= N:
break
Y = A + BC
Y.sort(reverse=True)
answer = sum(Y[:N])
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()
A = lr()
BC = [lr() for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
D = []
count = 0
for b, c in BC:
x = [c] * b
D.extend(x)
count += b
if count >= N:
break
E = A + D
E.sort(reverse=True)
answer = sum(E[:N])
print(answer)
| p03038 |
# 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()
A = lr()
BC = [lr() for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
D = []
count = 0
for b, c in BC:
D += [c] * b
count += b
if count >= N:
break
A += D
A.sort(reverse=True)
answer = sum(A[:N])
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()
A = lr()
BC = [lr() for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
D = []
count = 0
for b, c in BC:
A.extend([c] * b)
count += b
if count >= N:
break
A.sort(reverse=True)
answer = sum(A[:N])
print(answer)
| p03038 |
import heapq
n, m = list(map(int,input().split()))
a = [(-x, x) for x in map(int,input().split())]
heapq.heapify(a)
sum_a = 0
for i in range(m):
b,c = list(map(int,input().split()))
for j in range(b):
heapq.heappush(a,(-c, c))
for i in range(n):
sum_a += heapq.heappop(a)[1]
print(sum_a) | import heapq
n, m = list(map(int,input().split()))
a = list(map(int,input().split()))
heapq.heapify(a)
for i in range(m):
b,c = list(map(int,input().split()))
for j in range(b):
heapq.heappush(a,c)
if min(a) > c:
break
print((sum(heapq.nlargest(n, a)))) | p03038 |
import heapq
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
hq = []
for i in range(N):
heapq.heappush(hq, A[i])
for bc in BC:
for i in range(bc[0]):
tmp = heapq.heappop(hq)
if tmp < bc[1]:
heapq.heappush(hq, bc[1])
else:
heapq.heappush(hq, tmp)
print((sum(hq))) | import heapq
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
BC = list(reversed(sorted(BC, key=lambda x:x[1])))
#print(BC)
hq = []
for i in range(N):
heapq.heappush(hq, A[i])
flag = False
for bc in BC:
for i in range(bc[0]):
tmp = heapq.heappop(hq)
if tmp < bc[1]:
heapq.heappush(hq, bc[1])
else:
heapq.heappush(hq, tmp)
flag = True
break
if flag:
break
print((sum(hq))) | p03038 |
# N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort(reverse=True)
CB = []
for i in range(M):
b, c = [int(x) for x in input().split()]
CB.append((c, b))
CB.sort(reverse=True)
cnt = 0
L = []
for cb in CB:
if cnt >= N:
break
L.extend([cb[0]] * cb[1])
newA = A + L
newA.sort(reverse=True)
newA = newA[0:N]
ans = sum(newA)
print(ans)
| # N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
A.sort(reverse=True)
CB = []
for i in range(M):
b, c = [int(x) for x in input().split()]
CB.append((c, b))
CB.sort(reverse=True)
L = []
for cb in CB:
if len(L) >= N:
break
L.extend([cb[0]] * cb[1])
newA = A + L
newA.sort(reverse=True)
newA = newA[0:N]
ans = sum(newA)
print(ans)
| p03038 |
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b > 0: a, b = b, a % b
return b
def solve():
N, M = list(map(int, line_input()))
A = [int(a) for a in line_input()]
change = [None] * M
for i in range(M):
b, c = list(map(int, line_input()))
change[i] = [c, b]
A.sort()
change.sort(reverse = True)
sum = 0
index = 0
for c, b in change:
bleft = b
while bleft > 0:
if c > A[index]:
sum += c
index += 1
bleft -= 1
if index == N: break
else: break
if index == N: break
if index < N:
for i in range(index, N):
sum += A[i]
print(sum)
return 0
if __name__ == "__main__":
solve() | import sys
from operator import itemgetter
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A.sort()
C = [[int(i) for i in input().split()] for _ in range(M)]
C.sort(key=itemgetter(1), reverse = True)
counter = 0
for b, c in C:
end = False
for j in range(b):
if counter > N - 1:
end = True
break
if A[counter] < c:
A[counter] = c
counter += 1
else:
end = True
break
if end: break
print((sum(A)))
return 0
if __name__ == "__main__":
solve() | p03038 |
import sys
input = sys.stdin.readline
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
BC = [[int(x) for x in input().split()] for _ in range(M)]
BC = sorted(BC, reverse = True, key = lambda x:x[1])
N2 = N
D = []
for i in BC:
temp = min(N2,i[0])
D += [i[1]] * temp
N2 -= temp
if not N2:
break
A += D
A.sort()
print((sum(A[len(A) - N:]))) | import sys
input = lambda : sys.stdin.readline().rstrip()
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = []
for _ in range(m):
bc.append(list(map(int, input().split())))
bc = sorted(bc, reverse=True, key=lambda x: x[1])
cnt = n
for b, c in bc:
if cnt <= b:
for i in range(cnt):
a.append(c)
break
else:
for i in range(b):
a.append(c)
cnt -= b
a = sorted(a, reverse=True)
print((sum(a[:n])))
| p03038 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
cards = A.copy()
for b, c in BC:
cards += [c] * b
print((sum((sorted(cards)[::-1])[:N])))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
cards = {}
for a in A:
if not a in cards:
cards[a] = 1
else:
cards[a] += 1
for b, c in BC:
if not c in cards:
cards[c] = b
else:
cards[c] += b
count, sum_card = 0, 0
for key in sorted(cards)[::-1]:
value = cards[key]
if count + value < N:
sum_card += key * value
count += value
else:
sum_card += key * (N - count)
break
print(sum_card)
| p03038 |
import itertools
N,M = (int(i) for i in input().split())
A = sorted([int(i) for i in input().split()])
accum = list(itertools.accumulate(A))
e = []
for k, v in sorted([[int(i) for i in input().split()] for i in range(M)], key=lambda x: -x[1]):
for _ in range(k):
e.append(v)
for i in range(min(len(e),len(A))):
if A[i]<e[i]:
A[i]=e[i]
else:
break
print((sum(A)))
| N,M = (int(i) for i in input().split())
A = sorted([int(i) for i in input().split()])
e,p = [(0,0)],0
for k, v in sorted([[int(i) for i in input().split()] for i in range(M)], key=lambda x: -x[1]):
e.append((e[p][0]+k,v))
p+=1
p = 1
for i in range(min(e[-1][0],len(A))):
B,C = e[p]
if A[i]<C:
A[i]=C
else:
break
if i == B-1:
p+=1
print((sum(A)))
| p03038 |
import sys
from heapq import merge
N, M = list(map(int, sys.stdin.readline().split()))
A = sorted([-i for i in list(map(int, sys.stdin.readline().split()))])
BC = sorted([list(map(int, sys.stdin.readline().split())) for _ in range(M)], key=lambda x: x[1], reverse=True)
card_list1 = []
for i in range(M):
tmp_list = [-1 * BC[i][1]] * BC[i][0]
card_list1.extend(tmp_list)
sorted_cards = list(merge(A, card_list1))
ans = sum(sorted_cards[:N]) * -1
print(ans) | import sys
N, M = list(map(int, sys.stdin.readline().split()))
A = [[1, i] for i in list(map(int, sys.stdin.readline().split()))]
BC = [list(map(int, sys.stdin.readline().split())) for _ in range(M)]
card_list = A + BC
sorted_cards = sorted(card_list, key=lambda x: x[1], reverse=True)
n = 0
cards_sum = 0
for i in range(N):
if sorted_cards[i][0] + n <= N:
cards_sum += sorted_cards[i][1] * sorted_cards[i][0]
n += sorted_cards[i][0]
elif n < N and sorted_cards[i][0] + n > N:
cards_sum += sorted_cards[i][1] * (N - n)
n = N
break
else:
break
print(cards_sum) | p03038 |
import sys
def intinput():
return list(map(int,sys.stdin.readline().split()))
n,m=intinput()
a = list(intinput())
a.sort()
l = []
for i in range(m):
b,c=intinput()
for j in range(b):
l.append(c)
l.sort(reverse=1)
sum=0
for i in range(len(a)):
try:
sum += max(a[i],l[i])
except:
sum += a[i]
print(sum) | import sys
def intinput(): return list(map(int,sys.stdin.readline().split()))
n,m=intinput()
a = list(intinput())
a = [(a[x],1) for x in range(n)]
for i in range(m):
b,c=intinput()
a.append((c,b))
a.sort(reverse=1)
res,cnt=0,n
for (x,y) in a:
k = min(cnt,y)
res += k*x
cnt -= k
print(res) | p03038 |
import sys
from heapq import heappush, heappop
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
heap = []
ans = 0
for a in map(int, input().split()):
heappush(heap, a)
ans += a
BC = []
for _ in range(M):
B, C = list(map(int, input().split()))
BC.append((B, C))
BC = sorted(BC, key=lambda x: -x[1])
for B, C in BC:
for _ in range(B):
a = heappop(heap)
if a < C:
heappush(heap, C)
ans += C - a
else:
heappush(heap, a)
break
return ans
if __name__ == '__main__':
print((main()))
| import sys
from heapq import heappush, heappop
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
heap = []
ans = 0
for a in map(int, input().split()):
heappush(heap, a)
BC = []
for _ in range(M):
B, C = list(map(int, input().split()))
BC.append((B, C))
BC = sorted(BC, key=lambda x: -x[1])
for B, C in BC:
for _ in range(B):
a = heappop(heap)
if a < C:
heappush(heap, C)
else:
heappush(heap, a)
break
return sum(heap)
if __name__ == '__main__':
print((main()))
| p03038 |
import sys
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(M):
b, c = list(map(int, input().split()))
A += [c] * b
A = sorted(A, key=lambda x: -x)
return sum(A[:N])
if __name__ == '__main__':
print((main()))
| import sys
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = []
for _ in range(M):
b, c = list(map(int, input().split()))
BC.append((b, c))
BC = sorted(BC, key=lambda x: -x[1])
n = 0
for b, c in BC:
n += b
A += [c] * b
if n >= N:
break
A = sorted(A, key=lambda x: -x)
return sum(A[:N])
if __name__ == '__main__':
print((main()))
| p03038 |
N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
D = [list(map(int,input().split())) for k in range(M)]
D = sorted(D, key = lambda x: -x[1])
now = 0
for d in D:
for k in range(now,now+d[0]):
if now == N:
break
if A[k] < d[1]:
A[k] = d[1]
now += 1
else:
now = k
break
print((sum(A))) | N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
L = [list(map(int,input().split())) for k in range(M)]
L = sorted(L,key=lambda x: -x[1])
now = 0
for e in L:
if now == N:
break
while True:
if A[now] < e[1] and e[0] > 0:
A[now] = e[1]
now += 1
e[0] -= 1
if now == N:
break
else:
break
print((sum(A)))
| p03038 |
N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
L = []
for k in range(M):
B, C = list(map(int,input().split()))
L.append([B,C])
L = sorted(L,key=lambda x: -x[1])
ans = 0
i = 0
for k in range(N):
if i < M:
if A[k] < L[i][1]:
L[i][0] -= 1
ans += L[i][1]
if L[i][0] == 0:
i += 1
else:
ans += A[k]
else:
ans += A[k]
print(ans)
| N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
D = [list(map(int,input().split())) for k in range(M)]
D = sorted(D, key = lambda x: -x[1])
D.append([10**9+1,-1])
t = 0
ans = 0
for k in range(N):
if A[k] < D[t][1]:
ans += D[t][1]
D[t][0] -= 1
if D[t][0] == 0:
t += 1
else:
ans += A[k]
print(ans)
| p03038 |
from collections import Counter
def merge_dict_add_values(d1, d2):
return dict(Counter(d1) + Counter(d2))
n,m=(int(i) for i in input().split())
a=[int(i) for i in input().split()]
mydict={}
mydict[a[0]]=1
for i in range(1,len(a)):
d2={}
d2[a[i]]=1
mydict=merge_dict_add_values(mydict, d2)
#print(mydict)
#list_bc=[]
b,c=(int(i) for i in input().split())
mydict[c]=b
for i in range(1,m):
b,c=(int(i) for i in input().split())
d2={}
d2[c]=b
mydict=merge_dict_add_values(mydict, d2)
#print(n,m,a,mydict_bc)
mylist = sorted(list(mydict.items()), key=lambda x: -x[0])
#print(mylist)
cnt=0
cnt0=0
i=0
while cnt <= n:
cnt0+=mylist[i][0]*mylist[i][1]
v=mylist[i][0]
cnt+=mylist[i][1]
i+=1
#print(cnt0,v,cnt)
print((cnt0-v*(cnt-n)))
| import heapq
h = []
n,m=(int(i) for i in input().split())
a=[int(i) for i in input().split()]
for i in a:
heapq.heappush(h, [(-1)*i,1])
for i in range(m):
b,c=(int(i) for i in input().split())
heapq.heappush(h, [(-1)*c,b])
num=0
data=0
while num <= n:
v=heapq.heappop(h)
data+=v[0]*v[1]
num+=v[1]
print(((-1)*(data-v[0]*(num-n))))
| p03038 |
import sys
from heapq import heapify, heappush, heappop
N,M=list(map(int, sys.stdin.readline().split()))
A=list(map(int, sys.stdin.readline().split()))
heapify(A)
for _ in range(M):
b,c=list(map(int, sys.stdin.readline().split()))
for i in range(b):
if A[0]<c:
heappop(A)
heappush(A, c)
else:
break
print(sum(A))
| import sys
N,M=list(map(int, sys.stdin.readline().split()))
A=list(map(int, sys.stdin.readline().split()))
A.sort()
B=[ list(map(int, sys.stdin.readline().split())) for _ in range(M)]
B.sort(key=lambda x: x[1], reverse=True)
i=0
for b,c in B:
for i in range(i,N):
if A[i]<c and 0<b:
A[i]=c
b-=1
if b==0:
break
i+=1
print(sum(A))
| p03038 |
# -*- coding: utf-8 -*-
import sys
from heapq import heappush, heappop, heapify
from collections import Counter,defaultdict
dp=defaultdict(lambda: 0)
N,M=list(map(int, sys.stdin.readline().split()))
A=list(map(int, sys.stdin.readline().split()))
BC=defaultdict(lambda: 0)
for _ in range(M):
b,c=list(map(int, sys.stdin.readline().split()))
BC[c]+=b
C=Counter(A)
A=list(C.items())
heapify(A) #(カードの数字、カード枚数)
for c,b in list(BC.items()):
while A[0][0]<c and 0<b:
value=A[0][0]
cards=A[0][1]
heappop(A)
if cards<=b: #取った枚数以上に手元の枚数を持っていれば、カードを全交換できる
heappush(A,(c,cards))
else: #手元の方が少ない場合
heappush(A,(c,b)) #新しいカードの値を挿入
heappush(A,(value,cards-b)) #取ったカードも一部元に戻す
b-=cards
ans=0
for a,cards in A:
ans+=a*cards
print(ans)
| # -*- coding: utf-8 -*-
import sys
N,M=list(map(int, sys.stdin.readline().split()))
A=list(map(int, sys.stdin.readline().split()))
B=[ list(map(int, sys.stdin.readline().split())) for _ in range(M) ]
B.sort(key=lambda x:-x[1] )
n=N
L=[] #Bから降順でN個選ぶ
for cards,value in B:
if cards<=n: #カード全てがn枚に収まる場合
L+=[ value for _ in range(cards) ]
n-=cards
else: #カード全てがn枚に収まさらない場合
L+=[ value for _ in range(n) ]
n=0
break
A+=L
A.sort(reverse=True)
print(sum(A[:N])) | p03038 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def sieves_of_e(n):
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5)+1):
if not is_prime[i]: continue
for j in range(i * 2, n+1, i): is_prime[j] = False
return is_prime
N,M = imn()
A = list([int(x)*-1 for x in input().split()])
for i in range(M):
bc = iln()
for j in range(bc[0]):
A.append(-1*bc[1])
heapq.heapify(A)
ans = 0
for i in range(N):
ans += -1*heapq.heappop(A)
print(ans)
| import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def sieves_of_e(n):
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5)+1):
if not is_prime[i]: continue
for j in range(i * 2, n+1, i): is_prime[j] = False
return is_prime
N,M = imn()
A = iln()
D = []
for a in A:
D.append((-1*(a), 1))
for i in range(M):
t = iln()
D.append((-1*(t[1]), t[0]))
heapq.heapify(D)
cnt = 0
ans = 0
while cnt < N:
tmp = heapq.heappop(D)
for _ in range(tmp[1]):
ans += -1*(tmp[0])
cnt += 1
if cnt >= N:
break
print(ans) | p03038 |
import sys
import bisect
from collections import defaultdict
ans=0
#n=int(input())
n,m=list(map(int,input().split()))
a=[(1,int(i)) for i in input().split()]
b=[0]*m
c=[0]*m
for i in range(m):
b[i],c[i]=list(map(int,input().split()))
a.append((b[i],c[i]))
#a=sorted(a,reverse=True,key=lambda x:x[1])
a=sorted(a,key=lambda x:x[1])
#print(a)
t=0
while t<n:
k,x=a.pop()
if t+k<n:
ans+=x*k
else:
ans+=x*(n-t)
t+=k
print(ans) | ans=0
n,m=list(map(int,input().split()))
a=[(1,int(i)) for i in input().split()]
for i in range(m):
b,c=list(map(int,input().split()))
a.append((b,c))
a=sorted(a,key=lambda x:x[1])
t=0
while t<n:
k,x=a.pop()
ans+=x*min(k,n-t)
t+=k
print(ans) | p03038 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
#print(N,M)
#print(A)
#print(BC)
#print("---")
A = sorted(A)
times = [bc[0] for bc in BC]
values = [bc[1] for bc in BC]
values, times = list(zip(*sorted(zip(values, times),reverse=True)))
#print(values)
#print(times)
#values.sort(reverse=True)
for i, v in enumerate(values) :
tmp = [n for n,i in enumerate(A) if i > v]
if len(tmp) == N :
break
elif len(tmp) == 0 :
ind = N + 1
else :
ind = tmp[0]
if times[i] < ind :
A[0:times[i]] = [v] * times[i]
else :
A[0:ind] = [v] * ind
#print(A)
A = sorted(A)
print((sum(A)))
#for i, v in enumerate(values) :
# for t in range(times[i]) :
# min_A = min(A)
# if v > min_A :
# A[A.index(min(A))] = v
# print(A)
# else :
# break
# else:
# continue
# break
#print(sum(A))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
#print(N,M)
#print(A)
#print(BC)
#print("---")
A = sorted(A)
BC = sorted(BC, key = lambda x: -x[1])
D = []
for bc in BC :
for i in range(bc[0]) :
if len(D) < N :
D.append(bc[1])
else :
break
else :
continue
break
if N > len(D) :
S = len(D)
else :
S = N
for i in range(S) :
if A[i] < D[i] :
A[i] = D[i]
else :
break
print((sum(A)))
#times = [bc[0] for bc in BC]
#values = [bc[1] for bc in BC]
#values, times = zip(*sorted(zip(values, times),reverse=True))
#print(values)
#print(times)
#values.sort(reverse=True)
# for i, v in enumerate(values) :
# tmp = [n for n,i in enumerate(A) if i > v]
# if len(tmp) == N :
# break
# elif len(tmp) == 0 :
# ind = N + 1
# else :
# ind = tmp[0]
#
# if times[i] < ind :
# A[0:times[i]] = [v] * times[i]
# else :
# A[0:ind] = [v] * ind
# #print(A)
# A = sorted(A)
# print(sum(A))
#for i, v in enumerate(values) :
# for t in range(times[i]) :
# min_A = min(A)
# if v > min_A :
# A[A.index(min(A))] = v
# print(A)
# else :
# break
# else:
# continue
# break
#print(sum(A))
| p03038 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
L = []
# cnt_sum = 0
# min_num = BC[0][1]
# for i in range(M):
# cnt = BC[i][0]
# for j in range(N):
# if cnt_sum <= N:
# L.append(BC[i][1])
# cnt_sum += 1
# cnt -= 1
# if BC[i][1] < min_num:
# min_num = BC[i][1]
# else:
# if BC[i][1] < min_num:
# break
# if L[j] < BC[i][1]:
# L[j] = BC[i][1]
# cnt -= 1
# if cnt <= 0:
# break
len_L = 0
for i in range(M):
# for j in range(BC[i][0]):
# L.append(BC[i][1])
L.extend([BC[i][1] for j in range(BC[i][0])])
len_L += BC[i][0]
L.sort(reverse=True)
A.sort()
# ans = sum(A)
ans = 0
flag = True
for k in range(N):
if k <= len_L-1:
if flag and L[k] > A[k]:
ans += L[k]
else:
flag = False
ans += A[k]
else:
ans += A[k]
print(ans)
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
L = []
BC.sort(key=lambda x:x[1], reverse=True)
A.sort()
# ans = sum(A)
ans = 0
# flag = False
cnt = 0
# for k in range(N):
# if k <= len_L-1:
# if flag and L[k] > A[k]:
# ans += L[k]
# else:
# flag = False
# ans += A[k]
# else:
# ans += A[k]
for i in range(M):
for j in range(BC[i][0]):
if cnt < N and A[cnt] < BC[i][1]:
ans += BC[i][1]
cnt += 1
else:
break
else:
continue
break
if cnt < N:
ans += sum(A[cnt::])
print(ans) | p03038 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [0] * (m)
c = [0] * (m)
for i in range(m):
b[i], c[i] = list(map(int, input().split()))
d = []
for i in range(m):
for j in range(b[i]):
d.append(c[i])
a.extend(d)
a.sort(reverse=True)
print((sum(a[:n])))
| n, m = list(map(int, input().split()))
a = [(1, int(i)) for i in input().split()]
for _ in range(m):
b, c = list(map(int, input().split()))
a.append((b, c))
a = sorted(a, key=lambda x: x[1])
res = 0
idx = 0
while idx < n:
b, c = a.pop()
p = min(b, n-idx)
res += p * c
idx += p
print(res)
| p03038 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
dic = defaultdict(int)
n, m = li()
a = list(li())
key = set()
for ai in a:
dic[ai] += 1
key.add(ai)
for _ in range(m):
bi, ci = li()
dic[ci] += bi
key.add(ci)
res = n
ans = 0
for ki in sorted(list(key), reverse=True):
if res - dic[ki] >= 0:
ans += ki*dic[ki]
res -= dic[ki]
else:
ans += ki*res
res = 0
if res == 0:
break
print(ans)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
n, m = li()
a = list(li())
dic = defaultdict(int)
for ai in a:
dic[ai] += 1
for _ in range(m):
b, c = li()
dic[c] += b
keys = sorted(list(dic.keys()), reverse=True)
rest = n
ans = 0
for ki in keys:
if dic[ki] > rest:
ans += ki * rest
rest = 0
elif dic[ki] == rest:
ans += ki * dic[ki]
rest = 0
else:
ans += ki * dic[ki]
rest -= dic[ki]
if rest <= 0:
break
print(ans)
| p03038 |
from heapq import heappop, heappush, heapify
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
List = [list(map(int, input().split())) for _ in range(M)]
List = sorted(List, reverse=True, key=lambda x: x[1])
heapify(A)
i = 0
while i<M:
m = min(A)
tmp = List[i][1]
cnt = List[i][0]
while (0<cnt) and (m<tmp):
m = heappop(A)
heappush(A, tmp)
tmp = List[i][1]
cnt-=1
i+=1
print((sum(A))) | from heapq import heappop, heappush, heapify
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
List = [list(map(int, input().split())) for _ in range(M)]
List = sorted(List, reverse=True, key=lambda x: x[1])
heapify(A)
i = 0
while i<M:
m = heappop(A)
heappush(A, m)
tmp = List[i][1]
cnt = List[i][0]
while (0<cnt) and (m<tmp):
m = heappop(A)
heappush(A, tmp)
tmp = List[i][1]
cnt-=1
i+=1
print((sum(A))) | p03038 |
from bisect import bisect_left
from collections import deque
from itertools import islice
N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
cards = {}
for i in range(N):
cards[As[i]] = cards.get(As[i], 0) + 1
# sorted_keys = deque(sorted(cards.keys()))
sorted_keys = list(sorted(cards.keys()))
for i in range(M):
b, c = list(map(int, input().split()))
cnt = 0
# for k in islice(sorted_keys,0,bisect_left(sorted_keys, c)):
for k in sorted_keys[0:bisect_left(sorted_keys, c)]:
for _ in range(cards.get(k,0)):
cards[k] = cards[k] - 1
if cards[k] == 0:
del(cards[k])
sorted_keys.remove(k)
cards[c] = cards.get(c, 0) + 1
if c not in sorted_keys:
sorted_keys.insert(bisect_left(sorted_keys, c),c )
cnt += 1
if cnt >= b:
break
if cnt >= b:
break
print((sum([k * cnt for k,cnt in list(cards.items())])))
| N, M = list(map(int,input().split()))
As = sorted(list(map(int,input().split())))
di = {}
for i in range(M):
b, c = list(map(int,input().split()))
di[c] = di.get(c, 0) + b
keys = list(sorted(list(di.keys()), reverse=True))
ichi = 0
for i in range(N):
try:
if keys[ichi] > As[i]:
As[i] = keys[ichi]
di[keys[ichi]] -= 1
else:
break
if di[keys[ichi]] == 0:
ichi += 1
except:
pass
print((sum(As)))
| p03038 |
from collections import Counter
import heapq
n,m = list(map(int,input().split()))
l = list(map(int,input().split()))
hq = sorted(tuple(Counter(l).items()), key=lambda x:x[0])
heapq.heapify(hq)
# print(hq)
BC = [list(map(int, input().split())) for i in range(m)]
BC = sorted(BC,key = lambda x:-x[1])
for b,c in BC:
while b > 0:
x,y = heapq.heappop(hq)
if x < c:
if b < y:
heapq.heappush(hq,(c,b))
heapq.heappush(hq,(x,y-b))
b = 0
else:
heapq.heappush(hq,(c,y))
b -= y
else:
heapq.heappush(hq,(x,y))
break
# print(hq)
ans = 0
for i in range(len(hq)):
ans += hq[i][0]*hq[i][1]
print(ans) | import sys
import heapq
input = sys.stdin.readline
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
heapq.heapify(A)
BC = [list(map(int, input().split())) for i in range(m)]
BC = sorted(BC,key = lambda x:-x[1])
for b,c in BC:
for i in range(b):
a = heapq.heappop(A)
if a < c:
heapq.heappush(A,c)
else:
heapq.heappush(A,a)
break
print((sum(A))) | p03038 |
import sys
import heapq
input = sys.stdin.readline
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
heapq.heapify(A)
BC = [list(map(int, input().split())) for i in range(m)]
BC = sorted(BC,key = lambda x:-x[1])
for b,c in BC:
for i in range(b):
a = heapq.heappop(A)
if a < c:
heapq.heappush(A,c)
else:
heapq.heappush(A,a)
break
print((sum(A))) | import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = [tuple(map(int,input().split())) for i in range(m)]
BC = sorted(BC,key=lambda x:-x[1])
cnt = 0
flag = True
while True:
for b,c in BC:
A += [c]*b
cnt += b
if cnt > n:
break
break
A = sorted(A,reverse=True)
print((sum(A[:n]))) | p03038 |
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(m):
b,c=list(map(int,input().split()))
A += [c]*b
print((sum(sorted(A,reverse=True)[:n]))) | n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
bc = [list(map(int,input().split())) for _ in range(m)]
bc = sorted(bc,key=lambda x:-x[1])
sub = []
for i in range(m):
sub += [bc[i][1]] * bc[i][0]
if len(sub) > n:
break
A += sub
print((sum(sorted(A,reverse=True)[:n]))) | p03038 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def main():
n,m = LI()
a = sorted(LI())
aa = sorted([LI() for _ in range(m)], key=lambda x: -x[1])
ai = 0
for b,c in aa:
for j in range(b):
if ai >= n:
break
if a[ai] < c:
a[ai] = c
ai += 1
if ai >= n:
break
return sum(a)
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def main():
n,m = LI()
a = sorted(LI())
aa = sorted([LI() for _ in range(m)], key=lambda x: -x[1])
ai = 0
for b,c in aa:
for j in range(b):
if ai >= n:
break
if a[ai] < c:
a[ai] = c
ai += 1
else:
break
if ai >= n:
break
return sum(a)
print(main())
| p03038 |
from heapq import heapify, heappush, heappop
class HeapQue(object):
def __init__(self, iterable, max_heap=False):
self.sign = -1 if max_heap else 1
sequence = [self.sign * number for number in iterable]
heapify(sequence)
self.heapque = sequence
def push(self, item):
heappush(self.heapque, item * self.sign)
def pop(self):
return heappop(self.heapque) * self.sign
def dump(self):
return [heappop(self.heapque) * self.sign for _ in range(len(self.heapque))]
N, M = list(map(int, input().split()))
q = HeapQue(list(map(int, input().split())))
pairs = sorted((tuple(map(int, input().split())) for _ in range(M)), key=lambda t: t[1], reverse=True)
for b, c in pairs:
for _ in range(b):
x = q.pop()
if x < c:
q.push(c)
else:
q.push(x)
print((sum(q.dump())))
quit()
print((sum(q.dump()))) | from heapq import heapify, heappush, heappop
N, M = list(map(int, input().split()))
q = list(map(int, input().split()))
heapify(q)
pairs = sorted((tuple(map(int, input().split())) for _ in range(M)), key=lambda t: t[1], reverse=True)
for b, c in pairs:
for _ in range(b):
x = heappop(q)
if x < c:
heappush(q, c)
else:
heappush(q, x)
print((sum(q)))
quit()
print((sum(q)))
| p03038 |
from heapq import heappush, heappop
# input
N,M =list(map(int,input().split()))
A = [0]*N
B = [0]*M
C = [0]*M
A = list(map(int, input().split()))
A.sort()
for i in range(M):
B[i],C[i] = list(map(int,input().split()))
def solve():
pairs = list(zip(C, B))
sortedpairs = sorted(pairs, key=lambda x: x[0])
for i in range(M):
B[i]=sortedpairs[i][1]
C[i]=sortedpairs[i][0]
ansA=[0]*N
for j in range(N):
ansA[j] = A[j]
p = int(0)
j = int(0)
while j<N and M>=1+p :
jd = int(0)
if ansA[j] >= C[M - 1 - p]:
break
while B[M-1-p]-jd>0 :
if j==N : break
if ansA[j]>=C[M-1-p] :
break
else:
ansA[j]=C[M-1-p]
jd +=1
j +=1
p +=1
ans = int(0)
for j in range(N):
ans += ansA[j]
print(ans)
solve()
| import heapq
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = []
N, M = LI()
A = LI()
BC = [LI() for _ in range(M)]
A = list([x*(-1) for x in A])
heapq.heapify(A)
BC = sorted(BC, key=lambda x: x[1])[::-1]
#print(BC)
#print(A)
k = int(0)
ansC = int(0)
ansA = heapq.heappop(A)*(-1)
for i in range(N):
if k<M and BC[k][0]==0:
k +=1
if k<M and BC[k][1]>ansA:
ansC = BC[k][1]
BC[k][0] -=1
else:
ansC = ansA
if A!=[]:
ansA = heapq.heappop(A)*(-1)
ans.append(ansC)
#print(ans)
print((sum(ans)))
| p03038 |
import bisect
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
BC = []
for i in range(M):
BC.append(list(map(int,input().split())))
BC = sorted(BC, key=lambda x: x[1])
BC.reverse()
for i in range(M):
B, C = BC[i]
in_idx = bisect.bisect_right(A,C)
if B >= in_idx:
A = [C]*in_idx + A[in_idx:]
break
else:
A = A[B:in_idx] + [C]*B + A[in_idx:]
print((sum(A))) | N, M = list(map(int,input().split()))
A = [-1]
A += list(map(int,input().split()))
A.sort()
BC = [[1,-1]]
for i in range(M):
BC.append(list(map(int,input().split())))
BC = sorted(BC, key=lambda x: x[1])
x = 0
for i in range(N):
if A[-1] > BC[-1][1]:
x += A.pop()
else:
x += BC[-1][1]
BC[-1][0] -= 1
if BC[-1][0] == 0:
BC.pop()
print(x) | p03038 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
l = []
all_set = a
for _ in range(m):
# l.append(list(map(int, input().split())))
bi, ci = list(map(int, input().split()))
for _ in range(bi):
all_set.append(ci)
print((sum(sorted(all_set, reverse=True)[:n]))) | # coding: utf-8
# Your code here!
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
l = []
for _ in range(m):
l.append(list(map(int, input().split())))
l = sorted(l, key=lambda x:x[1], reverse=True)
top_n = []
flag = False
for bi, ci in l:
for _ in range(bi):
if len(top_n) < n:
top_n.append(ci)
else:
flag = True
if flag:
break
a.extend(top_n)
print((sum(sorted(a, reverse=True)[:n]))) | p03038 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
bc = []
for i in range(M):
bc.append(list(map(int,input().split())))
A = sorted(A,reverse=True)
bc = sorted(bc,key=lambda x : x[1],reverse=True)
AA = []
for i in range(M):
l = [bc[i][1]]*bc[i][0]
AA += l
AA = sorted(AA)
AAA = []
for i in range(1,min(len(A),len(AA))+1):
if A[-i] < AA[-i]:
AAA.append(AA[-i])
else:
AAA.append(A[-i])
if len(A) >= len(AA):
AAA += A[:N-len(AAA)]
print((sum(AAA)))
| N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A = sorted(A)
bc = []
for i in range(M):
bc.append(list(map(int,input().split())))
bc = sorted(bc,key=lambda x : -x[1])
i = 0
for b,c in bc:
for j in range(i,min(N,i+b)):
if A[j] < c:
A[j] = c
i += b
print((sum(A)))
| p03038 |
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
B = sorted([list(map(int,input().split())) for _ in range(M)],key=lambda x:x[1],reverse=True)
cur = 0
cnt = 0
for i in range(N):
if A[i]<B[cur][1] and cnt<B[cur][0]:
A[i]=B[cur][1]
cnt += 1
elif A[i]>=B[cur][1]:break
elif cnt>=B[cur][0]:
cur += 1
cnt = 0
if cur>=M:break
if A[i]<B[cur][1]:
A[i] = B[cur][1]
cnt += 1
print((sum(A))) | N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
B = sorted([list(map(int,input().split())) for _ in range(M)],key=lambda x:x[1],reverse=True)
cur = 0
cnt = B[0][0]
for i in range(N):
a = A[i]
if cur<M and B[cur][1]>a:
if cnt>0:
A[i] = B[cur][1]
cnt -= 1
else:
cur += 1
if cur<M:
cnt = B[cur][0]
if B[cur][1]>a:
A[i] = B[cur][1]
cnt -= 1
print((sum(A))) | p03038 |
"""
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = [list(map(int, input().split())) for _ in range(m)]
b.sort(key = lambda x : x[1], reverse = True)
a.sort()
i = 0
j = 0
c = 1
ans = sum(a)
while True:
if i >= m:
break
for _ in range(b[i][0]):
if j >= n:
c = 0
break
if a[j] < b[i][1]:
ans += b[i][1] - a[j]
j += 1
else:
c = 0
break
i += 1
if c == 0:
break
print(ans)
"""
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [list(map(int, input().split())) for _ in range(m)]
b.sort(key = lambda x : x[1], reverse = True)
c = n
for i in range(m):
if c - b[i][0] >= 0:
a = a + ([b[i][1]] * b[i][0])
c -= b[i][0]
else:
a = a + ([b[i][1]] * c)
break
a.sort(reverse = True)
print((sum(a[0 : n]))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = []
for _ in range(m):
b, c = list(map(int, input().split()))
bc.append([c, b])
a.sort()
bc.sort(reverse = True)
x = [0] * n
i, j = 0, 0
while i < n:
for _ in range(bc[j][1]):
x[i] = bc[j][0]
i += 1
if i == n:
break
j += 1
if j == m:
break
ans = 0
for i in range(n):
ans += max(a[i], x[i])
print(ans) | p03038 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m = inpl()
a = inpl()
a.sort()
bc = [inpl() for _ in range(m)]
bc.sort(key = lambda x:x[1], reverse = True)
lm = sum(x[1] for x in bc)
now = 0
alt = 0
while now < n and alt < m:
c,b = bc[alt]
if a[now] > b:
break
else:
a[now] = b
bc[alt][0] -= 1
if bc[alt][0] == 0:
alt += 1
now += 1
print((sum(a)))
| from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m = inpl()
a = inpl()
a.sort()
bc = [inpl() for _ in range(m)]
bc.sort(key=lambda x:x[1], reverse = True)
ind = -1
now = -1
cnt = 0
for i in range(n):
if cnt == 0:
ind += 1
if ind >= m: break
cnt, now = bc[ind]
if a[i] >= now:
break
a[i] = now
cnt -= 1
print((sum(a))) | p03038 |
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
d = []
for i in range(m):
b, c = list(map(int, input().split()))
d.extend([c]*b)
d.sort(reverse=True)
for i in range(min(n, len(d))):
if a[i] >= d[i]:
break
a[i] = d[i]
print((sum(a))) | n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
op = []
for i in range(m):
b, c = list(map(int, input().split()))
op.append((c, b))
op.sort(reverse=True)
j = 0
k = 0
for i in range(n):
if a[i] >= op[j][0]:
break
a[i] = op[j][0]
k += 1
if k >= op[j][1]:
j += 1
k = 0
if j >= m:
break
print((sum(a))) | p03038 |
import heapq
def solve():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
A.sort()
BC.sort(key=lambda x: x[1], reverse=True)
BC2 = []
for bc in BC:
for i in range(bc[0]):
BC2.append(bc[1])
BC_idx = 0
for i in range(N):
if BC_idx >= len(BC2):
break
if A[i] < BC2[BC_idx]:
A[i] = BC2[BC_idx]
BC_idx += 1
print((sum(A)))
if __name__ == '__main__':
solve() | def solve():
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
operate = []
for _ in range(M):
b, c = list(map(int,input().split()))
operate.append([b,c])
operate.sort(reverse=True, key=lambda x:x[1])
rewrite = [0] * N
idx = 0
for b,c in operate:
for i in range(b):
rewrite[idx] = c
idx += 1
if idx == N:
break
if idx == N:
break
ans = 0
for i in range(N):
ans += max(A[i],rewrite[i])
print(ans)
if __name__ == '__main__':
solve() | p03038 |
def main():
from bisect import bisect_left
n,m=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
for _ in range(m):
b,c=list(map(int,input().split()))
index = bisect_left(a,c)
b=index if b>=index else b
a=[c]*b+a[b:]
a.sort()
print((sum(a)))
if __name__=='__main__':
main() | def main():
n,m=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
bc=[list(map(int,input().split())) for _ in range(m)]
for i in range(n):
bc.append([1,a[i]])
bc.sort(key=lambda x:x[1],reverse=True)
ans,cnt=0,0
for i in range(n):
ans+=bc[i][0]*bc[i][1]
cnt+=bc[i][0]
if cnt>=n:
ans-=(cnt-n)*bc[i][1]
break
print(ans)
if __name__=='__main__':
main() | p03038 |
import heapq
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A.sort()
A.append(0)
S = []
heapq.heapify(S)
c = A[0]
cnt = 1
for i in range(1, N + 1):
if A[i] == c:
cnt += 1
else:
heapq.heappush(S, (A[i - 1], cnt))
cnt = 1
c = A[i]
for i in range(M):
B, v = list(map(int, input().split()))
while len(S) > 0 and S[0][0] < v:
x = heapq.heappop(S)
if B <= x[1]:
heapq.heappush(S, (v, B))
if not B == x[1] : heapq.heappush(S, (x[0], x[1] - B))
break
else:
B -= x[1]
heapq.heappush(S, (v, x[1]))
sumS = 0
while len(S) > 0:
x = heapq.heappop(S)
sumS += x[0] * x[1]
print(sumS) | import heapq
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A.sort()
A.append(0)
S = []
heapq.heapify(S)
c = A[0]
cnt = 1
for i in range(1, N + 1):
if A[i] == c:
cnt += 1
else:
heapq.heappush(S, (A[i - 1], cnt))
cnt = 1
c = A[i]
for i in range(M):
B, v = list(map(int, input().split()))
flag = False #Sからの取り出し比較を1度以上終えているか
b = B # 残りカード
while len(S) > 0 and S[0][0] < v:
x = heapq.heappop(S)
if b <= x[1]:
heapq.heappush(S, (v, B))
if not b == x[1] : heapq.heappush(S, (x[0], x[1] - b))
flag = False
break
else:
flag = True
b -= x[1]
if flag: #交換しきらないで、途中で終わっているのでこの分は挿入する
heapq.heappush(S, (v, B - b))
sumS = 0
while len(S) > 0:
x = heapq.heappop(S)
sumS += x[0] * x[1]
print(sumS)
| p03038 |
import heapq
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A.sort()
A.append(0)
S = []
heapq.heapify(S)
c = A[0]
cnt = 1
for i in range(1, N + 1):
if A[i] == c:
cnt += 1
else:
heapq.heappush(S, (A[i - 1], cnt))
cnt = 1
c = A[i]
for i in range(M):
B, v = list(map(int, input().split()))
flag = False #Sからの取り出し比較を1度以上終えているか
b = B # 残りカード
while len(S) > 0 and S[0][0] < v:
x = heapq.heappop(S)
if b <= x[1]:
heapq.heappush(S, (v, B))
if not b == x[1] : heapq.heappush(S, (x[0], x[1] - b))
flag = False
break
else:
flag = True
b -= x[1]
if flag: #交換しきらないで、途中で終わっているのでこの分は挿入する
heapq.heappush(S, (v, B - b))
sumS = 0
while len(S) > 0:
x = heapq.heappop(S)
sumS += x[0] * x[1]
print(sumS)
| N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
D = []
for i in range(M):
b, c = list(map(int, input().split()))
D.append((c, b))
A.sort()
D.sort(reverse=True)
i = 0
for c, b in D:
for j in range(i, min(i + b, N)):
A[j] = max(c, A[j])
i += b
print((sum(A)))
| p03038 |
def read_input():
n, m = list(map(int, input().split()))
alist = list(map(int, input().split()))
clist = []
for i in range(m):
b, c = list(map(int, input().split()))
clist.extend([c]*b)
return alist, clist
def submit():
alist, clist = read_input()
alist.sort(reverse=False)
clist.sort(reverse=True)
j = 0
result = 0
for a in alist:
if j >= len(clist):
result += a
elif a >= clist[j]:
result += a
else:
result += clist[j]
j += 1
print(result)
if __name__ == '__main__':
submit()
|
def read_input():
n, m = list(map(int, input().split()))
alist = list(map(int, input().split()))
clist = []
for i in range(m):
b, c = list(map(int, input().split()))
clist.append([c, b])
return alist, clist
def submit():
alist, clist = read_input()
alist.sort(reverse=False)
clist.sort(key=lambda x: x[0], reverse=True)
j = 0
result = 0
for a in alist:
if j >= len(clist):
result += a
elif a >= clist[j][0]:
result += a
else:
if clist[j][1] > 0:
result += clist[j][0]
clist[j][1] -= 1
if clist[j][1] == 0:
j += 1
print(result)
if __name__ == '__main__':
submit()
| p03038 |
#!/usr/bin/env python3.4
# abc127_d
import collections
import itertools
import functools
def find_index(iterable, func, from_i):
i = from_i
l = len(iterable)
while i<l and not func(iterable[i]):
i += 1
return i
def insert(deq, i, x):
l = len(deq)
if i < l/2:
deq.rotate(-i)
deq.appendleft(x)
deq.rotate(i)
else:
k = l-i
deq.rotate(k)
deq.append(x)
deq.rotate(-k)
def main():
# Input
_, m = [int(s) for s in input().split()]
cards = [int(s) for s in input().split()]
acts = [[int(s) for s in input().split()] for _ in range(m)]
# Get ans
cards = collections.deque(sorted(cards))
acts.sort(key=lambda a: a[1])
i = 0
for b, c in acts:
i = find_index(cards, lambda card: card>=c, i)
#print(i, cards[:i], cards[i:])
change_num = min(b, i)
#cards = cards[:i][change_num:] + [c]*change_num + cards[i:]
for _ in range(change_num):
insert(cards, i, c)
cards.popleft()
#print(cards)
ans = sum(cards)
# Output
print(ans)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3.4
# abc127_d
import collections
import itertools
import functools
def main():
# Input
_, m = [int(s) for s in input().split()]
cards = [int(s) for s in input().split()]
acts = [[int(s) for s in input().split()] for _ in range(m)]
# Get ans
cards = collections.deque(sorted(cards))
acts.sort(key=lambda a: a[1], reverse=True)
for b, c in acts:
for _ in range(b):
if cards[0] >= c:
break
cards.popleft()
cards.append(c)
ans = sum(cards)
# Output
print(ans)
if __name__ == '__main__':
main()
| p03038 |
#!/usr/bin/env python3.4
# abc127_d
import collections
import itertools
import functools
def main():
# Input
_, m = [int(s) for s in input().split()]
cards = [int(s) for s in input().split()]
acts = [[int(s) for s in input().split()] for _ in range(m)]
# Get ans
cards = collections.deque(sorted(cards))
acts.sort(key=lambda a: a[1], reverse=True)
for b, c in acts:
for _ in range(b):
if cards[0] >= c:
break
cards.popleft()
cards.append(c)
ans = sum(cards)
# Output
print(ans)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3.4
# abc127_d
import collections
def main():
# Input
n, m = [int(s) for s in input().split()]
cards = [int(s) for s in input().split()]
acts = [[int(s) for s in input().split()] for _ in range(m)]
# Get ans
cards = collections.deque(sorted(cards), n)
acts.sort(key=lambda a: a[1], reverse=True)
for b, c in acts:
for _ in range(b):
if cards[0] >= c:
break
cards.append(c)
ans = sum(cards)
# Output
print(ans)
if __name__ == '__main__':
main()
| p03038 |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heapq.heapify(A)
for i in range(M):
b, c = list(map(int, input().split()))
for j in range(b):
a = heapq.heappop(A)
if a < c:
heapq.heappush(A, c)
else:
heapq.heappush(A, a)
break
print((sum(A))) | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
B = []
for i in range(M):
b, c = list(map(int, input().split()))
B.append([c, b])
B.sort(reverse=True)
i = 0
f = 0
for j in range(M):
while B[j][1]:
if A[i] < B[j][0]:
A[i] = B[j][0]
B[j][1] -= 1
i += 1
if i >= N:
f = 1
break
else:
f = 1
break
if f == 1:
break
print((sum(A))) | p03038 |
import heapq
N, M = list(map(int, input().split()))
nums = list(map(int, input().split()))
n = len(nums)
heap = []
for i in range(M):
B, C = list(map(int, input().split()))
heap.append([-C, B])
for num in nums:
heap.append([-num, 1])
s = 0
heapq.heapify(heap)
while n > 0:
num, cnt = heapq.heappop(heap)
num = num * -1
s += num * min(cnt, n)
n -= min(cnt, n)
print(s) | def getInput():
return [int(x) for x in input().split()]
N, M = getInput()
nums = getInput()
nums = sorted(nums)
rep = []
for i in range(M):
b, c = getInput()
rep.append((b, c))
rep = sorted(rep, key=lambda x: x[1], reverse=True)
ans = 0
minIndex = 0
isFinished = False
for b, c in rep:
for _ in range(b):
if minIndex < len(nums) and nums[minIndex] < c:
ans += c
minIndex += 1
else:
isFinished = True
break
if isFinished:
break
if minIndex < len(nums):
ans += sum(nums[minIndex:])
print(ans) | p03038 |
import bisect
n,m = list(map(int,input().split()))
lst = list(map(int,input().split()))
lst.sort()
for i in range(m):
b,c = list(map(int,input().split()))
pos = bisect.bisect_left(lst,c)
for j in range(min(b,pos)):
lst[j] = c
lst.sort()
print((sum(lst))) | n,m = list(map(int,input().split()))
l_a = sorted(list(map(int,input().split())))
l_bc = [list(map(int,input().split())) for _ in range(m)]
l_bc.sort(key = lambda x:x[1],reverse = True)
for b,c in l_bc:
l_a.extend([c]*b)
if len(l_a) > 2*n:
break
l_a.sort(reverse = True)
print((sum(l_a[:n]))) | p03038 |
n,m = list(map(int,input().split()))
a = [int(i) for i in input().split()]
bc = [[int(i) for i in input().split()] for i in range(m)]
ans = 0
cnt = 0
d = {}
for i in range(n):
d[a[i]] = d.get(a[i],0)+1
for k in d:
bc.append([d[k],k])
bc.sort(key= lambda x:x[1],reverse=True)
for i in range(len(bc)):
if cnt < n:
ans += bc[i][1]*bc[i][0]
cnt += bc[i][0]
else:
ans -= (cnt-n)*bc[i-1][1]
break
else:
ans -= (cnt-n)*bc[i][1]
print(ans)
| n,m = list(map(int,input().split()))
a = [int(i) for i in input().split()]
bc = [[int(i) for i in input().split()] for i in range(m)]
a.sort()
bc.sort(key=lambda x:x[1],reverse=True)
d = []
cnt1 = 0
cnt2 = 0
x = 0
for lst in bc:
cnt2 = 0
while cnt1 < n and cnt2 < lst[0]:
d.append(lst[1])
cnt1 += 1
cnt2 += 1
for i in range(len(d)):
if d[i] - a[i] < 0:
x = i
break
else:
x += i+1
print((sum(d[:x]+a[x:]))) | p03038 |
n,m = list(map(int,input().split()))
a = [int(i) for i in input().split()]
bc = [[int(i) for i in input().split()] for i in range(m)]
a.sort()
bc.sort(key=lambda x:x[1],reverse=True)
d = []
cnt1 = 0
cnt2 = 0
x = 0
for lst in bc:
cnt2 = 0
while cnt1 < n and cnt2 < lst[0]:
d.append(lst[1])
cnt1 += 1
cnt2 += 1
for i in range(len(d)):
if d[i] - a[i] < 0:
x = i
break
else:
x += i+1
print((sum(d[:x]+a[x:]))) | n,m = list(map(int,input().split()))
a = [int(i) for i in input().split()]
bc = [[int(i) for i in input().split()] for i in range(m)]
a.sort()
bc.sort(key=lambda x:x[1],reverse=True)
d = []
cnt1 = 0
cnt2 = 0
x = 0
for lst in bc:
cnt2 = 0
while cnt1 < n and cnt2 < lst[0]:
d.append(lst[1])
cnt1 += 1
cnt2 += 1
if cnt1 == n:
break
for i in range(len(d)):
if d[i] - a[i] < 0:
x = i
break
else:
x += i+1
print((sum(d[:x]+a[x:]))) | p03038 |
from operator import itemgetter
n, m = [int(i) for i in input().split()]
a = sorted([int(i) for i in input().split()])
#print(a)
bc = []
for _ in range(m):
bc.append([int(i) for i in input().split()])
bc = sorted(bc, key=itemgetter(1), reverse=True)
#print(bc)
ans = 0
for b,c in bc:
#print(a,b,c)
lower_c_num = 0
for a_i in a:
if a_i < c:
lower_c_num += 1
if lower_c_num > b:
lower_c_num = b
break
else:
break
change = min(b, lower_c_num)
a = a[change:]
ans += c * change
if len(a) == 0:
break
if change != b:
break
ans += sum(a)
print(ans)
| from operator import itemgetter
n, m = [int(i) for i in input().split()]
a = sorted([int(i) for i in input().split()])
#print(a)
bc = []
for _ in range(m):
bc.append([int(i) for i in input().split()])
bc = sorted(bc, key=itemgetter(1), reverse=True)
#print(bc)
change = []
for b,c in bc:
len_change = len(change)
b_up = b
if n - len_change < b:
b_up = n - len_change
#print(b_up)
change += [c]*b_up
if b_up != b:
break
change += [0]*(n-len(change))
ans = 0
for i in range(n):
#print(ans)
#print(i)
if a[i] < change[i]:
ans += change[i]
else:
ans += sum(a[i:])
break
print(ans) | p03038 |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for i in range(M)]
if N == 1:
print((max(A[0], BC[0][1])))
quit()
heapq.heapify(A)
for b, c in BC:
a = A[0]
if a >= c:
continue
else:
curPopped = 0
while curPopped < b:
a = heapq.heappop(A)
if a >= c:
heapq.heappush(A, a)
break
curPopped += 1
for i in range(curPopped):
heapq.heappush(A, c)
print((sum(A))) |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = sorted([list(map(int, input().split())) for i in range(M)], key=lambda x: x[1], reverse=True)
if N == 1:
print((max(A[0], BC[0][1])))
quit()
heapq.heapify(A)
for b, c in BC:
a = A[0]
if a >= c:
continue
else:
curPopped = 0
while curPopped < b:
a = heapq.heappop(A)
if a >= c:
heapq.heappush(A, a)
break
curPopped += 1
for i in range(curPopped):
heapq.heappush(A, c)
print((sum(A)))
"""
import bisect
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
BC = [list(map(int, input().split())) for i in range(M)]
if N == 1:
print(max(A[0], BC[0][1]))
quit()
for b, c in BC:
a = A[0]
if a >= c:
continue
else:
l = bisect.bisect_left(A, c)
print(l)
l = min(b, l)
A = A[l:] + [c] * l
print(l, A)
print(sum(A))
""" | p03038 |
from collections import deque
N, M = list(map(int, input().split()))
A = deque(list(map(int, input().split())))
for i in range(M):
B, C = list(map(int, input().split()))
A.extend([C]*B)
E = list(A)
E.sort(reverse = True)
print((sum(E[:N]))) | from collections import deque
N, M = list(map(int, input().split()))
A = deque(list(map(int, input().split())))
for i in range(M):
B, C = list(map(int, input().split()))
if C >= min(A):
A.extend([C]*B)
E = list(A)
E.sort(reverse = True)
print((sum(E[:N]))) | p03038 |
import heapq
n, m = list(map(int, input().split()))
queue = []
for a in map(int, input().split()):
heapq.heappush(queue, a)
for _ in range(m):
b, c = list(map(int, input().split()))
for _ in range(b):
if queue[0] < c:
heapq.heapreplace(queue, c)
else:
break
print((sum(queue))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
cb = [list(map(int, input().split()[::-1])) for _ in range(m)]
a.sort()
cb.sort()
summation = 0
a_tmp = a.pop()
cb_tmp = cb.pop()
for i in range(n):
if a_tmp >= cb_tmp[0]:
summation += a_tmp
if a:
a_tmp = a.pop()
else:
summation += cb_tmp[0]
cb_tmp[1] -= 1
if cb_tmp[1] == 0:
if cb:
cb_tmp = cb.pop()
else:
cb_tmp = [0, n]
print(summation) | p03038 |
from bisect import bisect_left
from heapq import heappop, heappush
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
BC = []
for i in range(M):
b, c = list(map(int, input().split()))
heappush(BC, (-c, b))
for i in range(M):
mc, b = heappop(BC)
c = -mc
index = bisect_left(A, c)
if index == 0:
continue
if index <= b:
A = [c for _ in range(index) ] + A[index:]
else:
A = [c for _ in range(b)] + A[b:]
A.sort()
print((sum(A))) | from heapq import heappop, heappush, heapify
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heapify(A)
BC = []
for i in range(M):
b, c = list(map(int, input().split()))
heappush(BC, (-c, b))
for i in range(M):
mc, b = heappop(BC)
c = -mc
end = False
for j in range(b):
min = heappop(A)
if c <= min:
heappush(A, min)
end = True
break
else:
heappush(A, c)
if end:
break
print((sum(A))) | p03038 |
import heapq
push, pop = heapq.heappush, heapq.heappop
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
for _ in range(m):
b,c = list(map(int, input().split()))
for _ in range(b):
p = pop(a)
if p < c:
push(a, c)
else:
# キューに戻す
push(a, p)
break
print((sum(a))) | import heapq
push, pop = heapq.heappush, heapq.heappop
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
def modify():
heapq.heapify(a)
bc = [list(map(int, input().split())) for _ in range(m)]
bc.sort(key=lambda x:x[1], reverse=True)
for b,c in bc:
for _ in range(b):
p = pop(a)
if p < c:
push(a, c)
else:
# キューに戻す
push(a, p)
return
modify()
print((sum(a))) | p03038 |
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
mat = []
for _ in range(m):
b, c = list(map(int, input().split()))
mat.extend([c] * b)
mat = sorted(mat, reverse=True)[:n]
for i, t in enumerate(a):
if i == len(mat):
break
if t < mat[i]:
a[i] = mat[i]
else:
break
print((sum(a)))
| n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
bc = [[0] * 2 for _ in range(m)]
for i in range(m):
bc[i] = list(map(int, input().split()))
bc = sorted(bc, key=lambda x: x[1], reverse=True)
mat = []
for b, c in bc:
if len(mat) + b > n:
mat.extend([c] * (n - len(mat)))
break
else:
mat.extend([c]*b)
for i, t in enumerate(a):
if i == len(mat):
break
if t < mat[i]:
a[i] = mat[i]
else:
break
print((sum(a)))
| p03038 |
N,M = list(map(int,input().split()))
A= list(map(int,input().split()))
for i in range(M):
B,C = list(map(int,input().split()))
A.extend([C]*B)
b=sorted(A)
print((sum(b[-N:]))) | import sys
input = sys.stdin.readline
N,M = list(map(int,input().split()))
A= list(map(int,input().split()))
for i in range(M):
B,C = list(map(int,input().split()))
A.extend([C]*B)
b=sorted(A)
print((sum(b[-N:]))) | p03038 |
import bisect
import sys
input = sys.stdin.readline
def main():
N,M = list(map(int,input().split()))
A= list(map(int,input().split()))
A = sorted(A)
BC=[list(map(int,input().split())) for i in range(M)]
BC = sorted(BC, key=lambda x: x[1],reverse=True)
for B,C in BC:
index = bisect.bisect_right(A,C)
if index==0:
break
if index > B:
A = A[B:index] + [C] *B + A[index:]
else:
A = [C]*index + A[index:]
print((sum(A)))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
N,M = list(map(int,input().split()))
A= list(map(int,input().split()))
A = sorted(A)
BC=[list(map(int,input().split())) for i in range(M)]
BC = sorted(BC, key=lambda x: x[1],reverse=True)
index=0
max_index=len(A)
for B,C in BC:
temp = [C]*B
for t in temp:
if max_index>index and t>A[index]:
A[index] = t
else:
return A
index+=1
return A
if __name__ == '__main__':
A=main()
print((sum(A)))
| p03038 |
import heapq
n, m = list(map(int, input().split()))
al = list(map(int, input().split()))
h = []
ad = {}
for a in al:
if a not in ad:
ad[a] = 1
else:
ad[a] += 1
for i in range(m):
b, c = list(map(int, input().split()))
if c not in ad:
ad[c] = b
else:
ad[c] += b
keys = list( ad.keys() )
keys.sort(reverse=True)
for k in keys:
for i in range(ad[k]):
heapq.heappush(h, k)
if len(h) >= n:
break
ans = sum( heapq.nlargest(n, h) )
print(ans) | import heapq
n, m = list(map(int, input().split()))
al = list(map(int, input().split()))
h = []
ad = {}
for a in al:
if a not in ad:
ad[a] = 1
else:
ad[a] += 1
for i in range(m):
b, c = list(map(int, input().split()))
if c not in ad:
ad[c] = b
else:
ad[c] += b
keys = list( ad.keys() )
keys.sort(reverse=True)
for k in keys:
for i in range(ad[k]):
heapq.heappush(h, k)
if len(h) >= n:
break
ans = sum( heapq.nlargest(n, h) )
print(ans) | p03038 |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
origin = sum(A)
heapq.heapify(A)
for _ in range(M):
b, c = list(map(int, input().split()))
for _ in range(b):
smallest = heapq.heappop(A)
tmp = c - smallest
if tmp <= 0:
heapq.heappush(A, smallest)
break
else:
heapq.heappush(A, c)
origin += tmp
print(origin)
| import sys
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
origin = sum(A)
heapq.heapify(A)
BC = [list(map(int, input().split())) for _ in range(M)]
BC = sorted(BC, reverse=True, key=lambda x: x[1])
count = 0
for i in range(M):
b = BC[i][0]
c = BC[i][1]
for _ in range(b):
smallest = heapq.heappop(A)
tmp = c - smallest
if tmp <= 0:
heapq.heappush(A, smallest)
break
else:
heapq.heappush(A, c)
origin += tmp
count += 1
if count >= N:
print(origin)
sys.exit()
print(origin)
| p03038 |
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
bc = [list(map(int, input().split())) for _ in range(m)]
for b, c in bc:
for _ in range(b):
x = heapq.heappop(a)
if c > x:
heapq.heappush(a, c)
else:
heapq.heappush(a, x)
print((sum(a)))
| import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
bc = [list(map(int, input().split())) for _ in range(m)]
bc = sorted(bc, key=lambda x: -x[1])
for b, c in bc:
for _ in range(b):
x = heapq.heappop(a)
if c > x:
heapq.heappush(a, c)
else:
heapq.heappush(a, x)
break
print((sum(a))) | p03038 |
# sys.stdin.readline()
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
for _ in range(m):
b, c= list(map(int, input().split()))
if a[n-1] < c:
for i in range(min(b,n)):
a.append(c)
a.sort(reverse=True)
print((sum(a[:n]))) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, m = list(map(int, readline().split()))
a = sorted(list(map(int, readline().split())))
bc = [tuple(map(int, readline().split())) for i in range(m)]
bc.sort(key=lambda x: x[1], reverse=True)
index = 0
cnt = 0
for i in range(n):
if a[i] > bc[index][1]:
break
a[i] = bc[index][1]
cnt += 1
if cnt == bc[index][0]:
cnt = 0
index += 1
if index == m:
break
print((sum(a)))
| p03038 |
n,m=list(map(int,input().split()))
a=[int(i) for i in input().split()]
for i in range(m):
a.sort()
b,c=list(map(int, input().split()))
for i in range(b):
if a[i] < c:
a[i] = c
else:
break
print((sum(a))) | n,m=list(map(int,input().split()))
l=[[int(x),1] for x in input().split()]
for i in range(m):
b,c=list(map(int,input().split()))
l.append([c,b])
s = sorted(l, key=lambda x:x[0], reverse=True)
c=n
t=0
i=0
while c>0:
n = s[i][1] if c>=s[i][1] else c
t += s[i][0] * n
c -= n
i += 1
print(t)
| p03038 |
from collections import defaultdict
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
d=defaultdict(int)
a.sort()
for i in range(m):
b,c=list(map(int,input().split()))
d[c]+=b
d_sorted=sorted(list(d.items()),reverse=True, key=lambda x:x[0])
l=[]
for i,j in d_sorted:
for k in range(j):
l.append(i)
if len(l)>=n:
break
for i in range(min(n, len(l))):
a[i]=max(a[i],l[i])
print((sum(a))) | from collections import defaultdict
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
d=defaultdict(int)
a.sort()
for i in range(m):
b,c=list(map(int,input().split()))
d[c]+=b
d_sorted=sorted(list(d.items()),reverse=True, key=lambda x:x[0])
l=[]
for i,j in d_sorted:
for k in range(j):
l.append(i)
if len(l)>n:
break
else:
continue
break
for i in range(min(n, len(l))):
a[i]=max(a[i],l[i])
print((sum(a))) | p03038 |
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = []
C = []
BC = []
A.sort()
for i in range(M):
b, c = list(map(int, input().split()))
B.append(b)
C.append(c)
BC.append([b, c])
sorted(BC, key=lambda x: x[1])
BC = BC[::-1]
C = C.sort()
heapq.heapify(A)
# print(A)
# print(BC)
buff = []
counter = 0
for i in range(M):
# if counter > N*2:
# break
for j in range(BC[i][0]):
# buff.append(BC[i][1])
# counter += 1
heapq.heappush(A, BC[i][1])
heapq.heappop(A)
if counter > N*2:
break
# A = A + buff
# A.sort()
# A = A[::-1]
# print(A)
print((sum(A))) | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = []
C = []
BC = []
A.sort()
for i in range(M):
b, c = list(map(int, input().split()))
B.append(b)
C.append(c)
BC.append([b, c])
BC = sorted(BC, key=lambda x: x[1])
BC = BC[::-1]
C = C.sort()
# print(A)
# print(BC)
buff = []
counter = 0
for i in range(M):
if counter > N*2:
break
for j in range(BC[i][0]):
buff.append(BC[i][1])
counter += 1
if counter > N*2:
break
A = A + buff
A.sort()
A = A[::-1]
print((sum(A[:N]))) | p03038 |
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
for i in range(m):
b, c = list(map(int, input().split()))
for j in range(b):
if c > a[0]:
heapq.heapreplace(a, c)
else:
break
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
cnt = {}
for i in range(n):
if a[i] in cnt:
cnt[a[i]] += 1
else:
cnt[a[i]] = 1
for i in range(m):
b, c = list(map(int, input().split()))
if c in cnt:
cnt[c] += b
else:
cnt[c] = b
cnts = sorted(cnt.items())
cnt = 0
tot = 0
last = (0, 0)
while cnt < n:
last = cnts.pop()
tot += last[0] * last[1]
cnt += last[1]
tot -= (cnt-n)*last[0]
print(tot) | p03038 |
import heapq
h = []
h2 = []
N, M = [int(i) for i in input().split()]
count = dict()
for i in input().split():
if not count.get(i):
count[i] = 0
count[i] += 1
for k, v in list(count.items()):
heapq.heappush(h, (int(k), v))
for _ in range(M):
B, C = [int(i) for i in input().split()]
heapq.heappush(h2, (C, B))
for i in range(M - 1, -1, -1):
C, B = h2[i]
while B > 0:
if h[0][0] >= C:
break
m = h[0][0]
mc = h[0][1]
if mc > B:
heapq.heappush(h, (C, B))
h[0] = (m, mc - B)
else:
heapq.heappop(h)
heapq.heappush(h, (C, mc))
B -= mc
print((sum([i[0] * i[1] for i in h])))
| import heapq
h = []
h2 = []
N, M = [int(i) for i in input().split()]
count = dict()
count2 = dict()
for i in input().split():
if not count.get(i):
count[i] = 0
count[i] += 1
for k, v in list(count.items()):
heapq.heappush(h, (int(k), v))
for _ in range(M):
B, C = [int(i) for i in input().split()]
if not count2.get(C):
count2[C] = 0
count2[C] += B
for k, v in list(count2.items()):
heapq.heappush(h2, (-k, v))
while len(h2) > 0:
C, B = heapq.heappop(h2)
C = -C
while B > 0:
if h[0][0] >= C:
break
m = h[0][0]
mc = h[0][1]
if mc > B:
heapq.heappush(h, (C, B))
h[0] = (m, mc - B)
else:
heapq.heappop(h)
heapq.heappush(h, (C, mc))
B -= mc
print((sum([i[0] * i[1] for i in h])))
| p03038 |
import sys
input = sys.stdin.readline
n,m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a.sort()
bc=[]
for i in range(m):
b,c = list(map(int, input().split(" ")))
bc = bc + [c]*b
bc.sort(reverse=True)
for i in range(n):
if len(bc) <= i or bc[i] <= a[i]:
break
a[i] = bc[i]
print((sum(a))) | import sys
input = sys.stdin.readline
n,m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a.sort()
bc=[None]*m
for i in range(m):
bc[i] = list(map(int, input().split(" ")))
bc.sort(reverse=True, key=lambda x:x[1])
l=[]
for [b,c] in bc:
l.extend([c]*b)
if n < len(l):
break
for i in range(n):
if len(l) <= i or l[i] <= a[i]:
break
a[i] = l[i]
print((sum(a)))
| p03038 |
import sys
input = sys.stdin.readline
n,m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a.sort()
bc=[None]*m
for i in range(m):
bc[i] = list(map(int, input().split(" ")))
bc.sort(reverse=True, key=lambda x:x[1])
l=[]
for [b,c] in bc:
l.extend([c]*b)
if n < len(l):
break
for i in range(n):
if len(l) <= i or l[i] <= a[i]:
break
a[i] = l[i]
print((sum(a)))
| import sys
from itertools import zip_longest
input = sys.stdin.readline
n,m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a.sort()
bc=[None]*m
for i in range(m):
bc[i] = list(map(int, input().split(" ")))
bc.sort(reverse=True, key=lambda x:x[1])
l=[]
for [b,c] in bc:
l.extend([c]*b)
if n < len(l):
l = l[0:n]
break
print((sum(list([x[1] if x[0] < x[1] else x[0] for x in zip_longest(a,l,fillvalue=0)]))))
| p03038 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = [list(map(int,input().split())) for i in range(M)]
B = []
C = []
for i in range(M):
B.append(BC[i][0])
C.append(BC[i][1])
for i in range(M):
A.sort()
card = 0
for j in range(N):
if A[j] < C[i]:
A[j] = C[i]
card += 1
if card == B[i]:
break
print((sum(A))) | from operator import itemgetter
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
BC = []
for i in range(M):
B,C = list(map(int,input().split()))
BC.append([B,C])
BC.sort(key = itemgetter(1),reverse=True)
change = []
for b,c in BC:
change += [c] * b
if len(change) > N:
break
A += change
A.sort(reverse=True)
answer = sum(A[:N])
print(answer) | p03038 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.