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()))
while m>0:
max=0
num=0
for i in range(n):
if A[i]>max:
max=A[i]
num=i
A[num]=A[num]/2
# print(num+1)
m+=-1
sum=0
for a in A:
#print(a)
sum+=(a//1)
print((int(sum)))
| import heapq
n,m=list(map(int,input().split()))
def func(x):
return -1*int(x)
A=list(map(func,input().split()))
#print(A)
heapq.heapify(A)
while m>0:
x=heapq.heappop(A)
x/=2
heapq.heappush(A,x)
m+=-1
sum=0
for a in A:
#print((-1*a)//1)
sum+=((-1*a)//1)
print((int(sum)))
| p02912 |
def main():
import bisect
import math
import sys
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
for i in range(m):
tmp=a[n-1]//2
bisect.insort_left(a,tmp)
a.pop(n)
print((sum(a)))
if __name__ == '__main__':
main()
| def main():
import bisect
import math
import sys
import heapq
def f(s):
return -int(s)
n,m=list(map(int,input().split()))
a=list(map(f,input().split()))
heapq.heapify(a)
for i in range(m):
tmp=heapq.heappop(a)
tmp=math.ceil(tmp/2)
heapq.heappush(a,tmp)
print((-sum(a)))
if __name__ == '__main__':
main() | p02912 |
from bisect import insort_left
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
for i in range(M):
A[-1] = A[-1]/2
k = A[-1]
A = A[:-1]
insort_left(A,k)
s = 0
for i in range(N):
s += int(A[i])
print(s) | import heapq
N,M = list(map(int,input().split()))
A = list([int(x)*(-1) for x in input().split()])
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a /= 2
heapq.heappush(A,a)
s = 0
for i in A:
i = int(i*(-1))
s += i
print(s) | p02912 |
import bisect
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for i in range(m):
test = a.pop(-1)
bisect.insort(a, test // 2)
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [-a[i] for i in range(n)]
heapq.heapify(a)
for i in range(m):
test = heapq.heappop(a)
heapq.heappush(a, -(-test // 2))
print((-sum(a))) | p02912 |
import math
N,M=list(map(int,input().split()))
alist=list(map(int,input().split()))
alist.sort(reverse=True)
alog0=math.log2(alist[0])
alist_log=[]
diff_list=[]
for i in range(N):
a=alist[i]
alogi=math.log2(a)
alist_log.append(alogi)
#print(alist)
#print(alist_log)
tlist=[0]*N
while(M>0):
max_value=max(alist_log)
max_index=alist_log.index(max_value)
alist_log[max_index]-=1
tlist[max_index]+=1
M-=1
#print(tlist)
answer=0
for i in range(N):
answer+=alist[i]//(2**tlist[i])
print(answer) | #from heapq import heappush, heappop
import heapq
N,M=list(map(int,input().split()))
alist=list(map(int,input().split()))
hq=[]
for a in alist:
heapq.heappush(hq,-a)
while(M>0):
target=-1*heapq.heappop(hq)
target//=2
heapq.heappush(hq,-target)
M-=1
answer_list=[heapq.heappop(hq) for i in range(len(hq))]
#print(answer_list)
print((-sum(answer_list))) | p02912 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
import bisect
def main():
MAX = 10**9
n, m = list(map(int, input().strip().split()))
As = sorted(list(map(int, input().strip().split())))
for _ in range(m):
x = As.pop(len(As)-1)
x >>= 1
As.insert(bisect.bisect_left(As, x), x)
print((sum(As)))
if __name__=='__main__':
main()
| #!/usr/bin/python3
# -*- coding:utf-8 -*-
import heapq
def main():
MAX = 10**9
n, m = list(map(int, input().strip().split()))
As = sorted(list([-int(x) for x in input().strip().split()]))
hq = heapq.heapify(As)
for _ in range(m):
x = heapq.heappop(As)
x = -(-x//2)
x = heapq.heappush(As, x)
print((-sum(As)))
if __name__=='__main__':
main()
| p02912 |
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(m):
A[A.index(max(A))]//=2
print((sum(A))) | import heapq
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[i*-1 for i in A]
heapq.heapify(A)
for i in range(m):
x=heapq.heappop(A)
if x%2==0:
heapq.heappush(A,x//2)
else:
heapq.heappush(A,x//2+1)
print((-1*sum(A))) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A = sorted(A,reverse=True)
for i in range(M):
A[0] =A[0]//2
m = max(A)
i = A.index(max(A))
if m != A[0]:
A[i] = A[0]
A[0] = m
print((sum(A)))
| #from operator import itemgetter
#from collections import Counter
import heapq
#N = int(input())
N, M = list(map(int, input().split()))
A = list([int(x)*(-1) for x in input().split()])
#A = [int(input()) for i in range(N)]
heapq.heapify(A)
for i in range(M):
max = heapq.heappop(A)
heapq.heappush(A, max*(-1)//2*(-1))
print((-sum(A))) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for _ in range(M):
a = A.pop()
a = a >> 1
for i in range(len(A)):
if A[i] > a:
A.insert(i, a)
break
else:
A.append(a)
sum = 0
for a in A: sum += a
print(sum) | import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
h = []
for a in A: heapq.heappush(h, -a)
for _ in range(M):
a = heapq.heappop(h) * -1
a //= 2
heapq.heappush(h, -a)
sum = 0
for _ in range(N):
sum -= heapq.heappop(h)
print(sum) | p02912 |
import bisect
N, M = list(map(int,input().split()))
al = list(map(int,input().split()))
al.sort()
for _ in range(M):
x = al.pop()
bisect.insort(al, x//2)
print((sum(al))) | import heapq
N, M = list(map(int,input().split()))
al = list(map(int,input().split()))
al = list([x*(-1) for x in al])
heapq.heapify(al)
for _ in range(M):
tmp_min = heapq.heappop(al)
heapq.heappush(al, -1*(-tmp_min//2))
print((-sum(al))) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
p = max(a)
index = a.index(p)
a[index] = a[index] // 2
print((sum(a))) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] *= -1
import heapq
heapq.heapify(a)
for i in range(m):
am = -1 * heapq.heappop(a)
am = am // 2
heapq.heappush(a, -am)
print((-1 * sum(a))) | p02912 |
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
maxi = 0
idx = 0
for i in range(M):
maxi = max(A)
idx = A.index(maxi)
A[idx] = maxi//2
print((sum(A))) | import sys
import os
import math
import heapq
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
#大きいものから取り出したいので-1倍してqueueに入れる
Q = []
for a in A:
heapq.heappush(Q,-a)
for i in range(M):
first = -heapq.heappop(Q)
first = first//2
heapq.heappush(Q,-first)
print((-sum(Q))) | p02912 |
def solve():
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
# 最大の値でチケットを使う
# まだ最大かどうか考慮Y：もう一度使うN:バイナリーサーチをかけてリストをソートする
for i in range(m):
a[len(a)-1] //= 2
if a[len(a)-1] < a[len(a)-2]:
a = binary_search(a, a[len(a)-1])
return sum(a)
def binary_search(lst, num):
lst.pop(len(lst)-1)
left, right = 0, len(lst)-1
while left <= right:
mid = (left + right)//2
if lst[mid] < num:
left = mid + 1
else:
right = mid-1
lst.insert(mid, num)
return lst
ans = solve()
print(ans)
| import heapq # 優先度付きキュー
# def solve(): # TLE
# n, m = map(int, input().split())
# # O(nlog(n))
# a = sorted(list(map(int, input().split())))
# # 最大の値でチケットを使う
# # まだ最大かどうか考慮Y：もう一度使うN:バイナリーサーチをかけてリストをソートする
# # O(m)
# for i in range(m):
# a[len(a)-1] //= 2
# if a[len(a)-1] < a[len(a)-2]:
# # O(log2m)
# a = binary_search(a, a[len(a)-1])
# return sum(a)
def solve():
n, m = list(map(int, input().split()))
a = list([int(x)*-1 for x in input().split()])
heapq.heapify(a) # aを優先度付きキューに変更
for _ in range(m): # _ iで注意が出ない(インスタンスを作らない)
tmp_min = heapq.heappop(a) # aの最大の値のpop
heapq.heappush(a, (-1)*(-tmp_min//2)) # 計算誤差が生じるため(//2の返り値はintのため)
return -sum(a)
def binary_search(lst, num):
lst.pop(len(lst)-1)
left, right = 0, len(lst)-1
while left <= right:
mid = (left + right)//2
if lst[mid] < num:
left = mid + 1
else:
right = mid-1
lst.insert(mid, num)
return lst
ans = solve()
print(ans)
| p02912 |
import sys
sys.setrecursionlimit(int(1e6))
import math
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
if N > M:
A.sort(reverse=True)
A1 = A[0:M]
A2 = A[M:]
for _ in range(M):
i = A1.index(max(A1))
A1[i] = A1[i] // 2
print((sum(A1 + A2)))
else:
for _ in range(M):
i = A.index(max(A))
A[i] = A[i] // 2
print((sum(A)))
| import sys
sys.setrecursionlimit(int(1e6))
import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
h_A = []
for a in A:
heapq.heappush(h_A, -a)
for _ in range(M):
x = heapq.heappop(h_A)
heapq.heappush(h_A, -(-x // 2))
prices = [- heapq.heappop(h_A) for _ in range(N)]
print((sum(prices)))
| p02912 |
from functools import reduce
from operator import add
n, m = list(map(int, input().split()))
alist = list(map(int, input().split()))
for i in range(m):
idx = alist.index(max(alist))
alist[idx] //= 2
print((reduce(add, alist)))
| import heapq
from functools import reduce
n, m = list(map(int, input().split()))
h = list([-int(a) for a in input().split()])
heapq.heapify(h) # input().split()))
for i in range(m):
mx = -(-heapq.heappop(h) // 2)
heapq.heappush(h, mx)
print((-reduce(lambda a, b: a+b, h)))
| p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
a[a.index(max(a))] //= 2
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = [-int(i) for i in input().split()]
heapq.heapify(a)
for _ in range(m):
mx = -heapq.heappop(a)
heapq.heappush(a, -(mx // 2))
print((-sum(a))) | p02912 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort(reverse = True)
for _ in range(M):
for i in range(N):
if A[i] == max(A):
A[i] = A[i]/2
break
for i in range(N):
A[i] = int(A[i])
print((sum(A))) | import heapq
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(N):
A[i] = -A[i]
heapq.heapify(A)
for _ in range(M):
hoge = -heapq.heappop(A)
hoge = hoge // 2
heapq.heappush(A, -hoge)
print((-sum(A))) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
from bisect import insort
while M>0:
a = A.pop()
a /= 2
insort(A,a)
M-=1
ans = 0
for a in A:
ans += int(a)
print(ans)
| N,M=list(map(int,input().split()))
A=list([-int(x) for x in input().split()])
import heapq
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a /= 2
heapq.heappush(A,a)
ans = 0
for a in A:
ans += int((-1)*a)
print(ans)
| p02912 |
n, m = list(map(int, input().split()))
a_list = list(map(int, input().split()))
for _ in range(m):
max_i = a_list.index(max(a_list))
a_list[max_i] = a_list[max_i] // 2
print((sum(a_list))) | import heapq
n, m = list(map(int, input().split()))
a_list = [a*(-1) for a in list(map(int, input().split()))]
heapq.heapify(a_list)
for _ in range(m):
min_n = heapq.heappop(a_list)
heapq.heappush(a_list, (min_n//2 if min_n%2 == 0 else min_n//2+1))
print((sum(a_list) * (-1))) | p02912 |
import math
N,M=list(map(int, input().split()))
A=list(map(int, input().split()))
for i in range(M):
A.sort()
A[N-1]=math.trunc(A[N-1]/2)
print((sum(A))) | import heapq
N,M=list(map(int, input().split()))
A=list(map(int, input().split()))
for i in range(N):
A[i]=-1*A[i]
heapq.heapify(A)
for i in range(M):
q=heapq.heappop(A)
q=q/2
heapq.heappush(A,q)
for i in range(N):
A[i]=-1*int(A[i])
print((sum(A))) | p02912 |
import heapq
N,M=list(map(int, input().split()))
A=list(map(int, input().split()))
for i in range(N):
A[i]=-1*A[i]
heapq.heapify(A)
for i in range(M):
q=heapq.heappop(A)
q=q/2
heapq.heappush(A,q)
for i in range(N):
A[i]=-1*int(A[i])
print((sum(A))) | import heapq
N,M=list(map(int, input().split()))
A=list(map(int, input().split()))
for i in range(N):
A[i]=-1*A[i]
heapq.heapify(A)
for i in range(M):
heapq.heappush(A,heapq.heappop(A)/2)
for i in range(N):
A[i]=-1*int(A[i])
print((sum(A))) | p02912 |
# coding: utf-8
n, m = list(map(int, input().split()))
s = list(map(int, input().split()))
for i in range(m):
index = s.index(max(s))
s[index] = s[index] // 2
sum = sum(s)
print(sum) | # coding: utf-8
import heapq
n, m = list(map(int, input().split()))
s = list([int(x)*(-1) for x in input().split()])
heapq.heapify(s)
for i in range(m):
maxi = heapq.heappop(s)
heapq.heappush(s, -(-maxi // 2))
print((-sum(s))) | p02912 |
import bisect
n, m = list(map(int, input().split()))
item = [int(a) for a in input().split()]
item.sort()
ans = 0
for _ in range(m):
item_max = item.pop()
bisect.insort_left(item, item_max / 2)
for i in item:
ans += int(i)
print(ans) | import heapq
n, m = list(map(int, input().split()))
item = [-1 * int(a) for a in input().split()]
heapq.heapify(item)
ans = 0
for _ in range(m):
item_max = heapq.heappop(item)
item_max = item_max / 2
heapq.heappush(item, item_max)
for i in item:
ans += int(i)
print((- ans)) | p02912 |
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(m):
a[a.index(max(a))] //= 2
print((sum(a))) | import sys
input = sys.stdin.readline
import heapq as hp
n,m = list(map(int,input().split()))
a = list([int(x)*(-1) for x in input().split()])
hp.heapify(a)
tmp = 0
for i in range(m):
tmp = hp.heappop(a)
hp.heappush(a,(-tmp//2)*(-1))
#
print((-sum(a)))
| p02912 |
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(M):
max_A = max(A)
ind = A.index(max_A)
A[ind] = max_A//2
print((sum(A))) | import heapq
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = list([x*(-1) for x in A])
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a = -(-a//2)
heapq.heappush(A,a)
print((-1*sum(A))) | p02912 |
import heapq
n,m=[int(i) for i in input().split()]
a=[-1*int(i) for i in input().split()]
for i in range(m):
heapq.heapify(a)
b=heapq.heappop(a)
b=b/2
heapq.heappush(a,b)
ans=0
for i in a:
ans-=int(i)
print(ans) | import heapq
n,m=[int(i) for i in input().split()]
a=[-1*int(i) for i in input().split()]
heapq.heapify(a)
for i in range(m):
b=heapq.heappop(a)
b=b/2
heapq.heappush(a,b)
ans=0
for i in a:
ans-=int(i)
print(ans) | p02912 |
from bisect import bisect_left as b
n,m= list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
while m>0:
i=a.pop(-1)//2
a.insert(b(a,i),i)
m-=1
print((sum(a))) | import heapq
N, M = list(map(int,input().split()))
A = list([int(x) * (-1) for x in input().split()])
heapq.heapify(A)
for _ in range(M):
tmp_min = heapq.heappop(A)
heapq.heappush(A, (-1) * (-tmp_min // 2))
print((-sum(A))) | p02912 |
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
while(m>0):
A=sorted(A,reverse=True)
if n>1:
while(A[0]>=A[1]):
A[0]=A[0]//2
m-=1
else:
A[0]=A[0]//2
m-=1
print((sum(A))) | from heapq import heappop,heappush,heapify
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
A_m=list([-x for x in A])
heapify(A_m)
pop=lambda: -heappop(A_m)
push=lambda x: heappush(A_m,-x)
for _ in range(m):
x=pop()
push(x//2)
print((-sum(A_m))) | p02912 |
#!/usr/bin/env python3
import bisect
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for i in range(m):
value = a.pop()
value //= 2
insert_index = bisect.bisect_left(a, value)
a.insert(insert_index, value)
print((sum(a)))
| #!/usr/bin/env python3
import heapq
# import bisect
n, m = list(map(int, input().split()))
a = list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for i in range(m):
value = heapq.heappop(a)
value = (value+1)//2
heapq.heappush(a, value)
# print(a)
print((-sum(a)))
| p02912 |
import sys, heapq
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
value = []
heapq.heapify(value)
for inp in input().split():
heapq.heappush(value, -int(inp))
for _ in range(M):
new_elem = -(- heapq.heappop(value) // 2)
heapq.heappush(value, new_elem)
print((- sum(value)))
if __name__=="__main__":
main() | import sys, heapq
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
value = [-int(inp) for inp in input().split()]
heapq.heapify(value)
for _ in range(M):
old_elem = heapq.heappop(value)
if old_elem == 0:
break
new_elem = -(- old_elem // 2)
heapq.heappush(value, new_elem)
print((- sum(value)))
if __name__=="__main__":
main() | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m): a.append(a.pop(a.index(max(a)))//2)
print((sum(a))) | import heapq as hq
n, m = list(map(int, input().split()))
a = []
for i in input().split(): hq.heappush(a, -int(i))
for i in range(m): hq.heappush(a, int(hq.heappop(a)/2))
print((-sum(a))) | p02912 |
def main():
n, m = list(map(int, input().split()))
a = [int(x) for x in input().split()]
a.sort(reverse=True)
ans = sum(a)
diff = 0
for i in range(1, m+1):
a_i = a[:i]
a_m = max(a_i)
diff += a_m - a_m // 2
a_m_i = a_i.index(a_m)
a[a_m_i] = a[a_m_i] // 2
ans -= diff
print(ans)
if __name__ == '__main__':
main() | from heapq import heapify, heappush, heappop
def main():
n, m = list(map(int, input().split()))
a = [int(x)*-1 for x in input().split()]
ans = sum(a)*-1
diff = 0
heapify(a)
for _ in range(1, m+1):
_h_a = heappop(a) * -1
diff += _h_a - _h_a // 2
heappush(a, (_h_a // 2)*-1)
ans -= diff
print(ans)
if __name__ == '__main__':
main() | p02912 |
import math
import bisect
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
while M > 0:
A.insert(bisect.bisect_left(A, A[-1]/2, hi=len(A)-1), A[-1]/2)
A.pop(-1)
M -= 1
A = list(map(math.floor, A))
print((sum(A)))
| import math
import bisect
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse = True)
def XX(A, M):
if M <= 0 or A[0]<1:
return
A[0] = A[0]/2
M -= 1
for i in range(1, len(A)):
if A[i] > A[0] and M > 0:
A[i] = A[i]/2
M -= 1
else:
break
A.sort(reverse = True)
XX(A, M)
XX(A, M)
A = list(map(math.floor, A))
print((sum(A)))
| p02912 |
import bisect
N, M = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
for i in reversed(list(range(M))):
bisect.insort(A, A.pop(-1)//2)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
heap = [-i for i in list(map(int, input().split()))]
heapq.heapify(heap)
for i in range(M):
heapq.heappush(heap, -(-heapq.heappop(heap)//2))
print((-sum(heap))) | p02912 |
import bisect
import copy
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
for _ in range(m):
a[n-1] //= 2
if a[n-1] < a[n-2]:
b = a[:n-1]
bisect.insort(b,a[n-1])
a = copy.deepcopy(b)
print((sum(a))) | import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n):
a[i] *= (-1)
heapq.heapify(a)
for i in range(m):
b = heapq.heappop(a)
b = - (b * (-1) // 2)
heapq.heappush(a, b)
print((-sum(a))) | p02912 |
import bisect
n,m=list(map(int,input().split()))
A=sorted(list(map(int,input().split())))
for i in range(m):
b=A.pop(n-1)//2
bisect.insort_left(A, b)
print((sum(A))) | import heapq
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
H=[]
for a in A:
heapq.heappush(H,-a)
for i in range(m):
heapq.heappush(H,-(-heapq.heappop(H)//2))
print((-sum(H))) | p02912 |
import bisect
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
aaa = list(map(int, input().split()))
aaa.sort()
for i in range(m):
a = aaa.pop() // 2
insert_index = bisect.bisect_right(aaa, a)
aaa.insert(insert_index, a)
print((sum(aaa))) | import heapq
n, m = list(map(int, input().split()))
aaa = [-1 * int(a) for a in input().split()]
heapq.heapify(aaa)
for i in range(m):
a = -heapq.heappop(aaa) // 2
heapq.heappush(aaa, -a)
print((-sum(aaa))) | p02912 |
from bisect import insort
n, m = list(map(int, input().split()))
a_s = sorted(list(map(int, input().split())))
for i in range(m):
new_amax = a_s[-1] // 2
a_s = a_s[:-1]
insort(a_s, new_amax)
res = sum(a_s)
print(res) | from math import ceil
from heapq import *
n, m = list(map(int, input().split()))
a_s = [-int(a) for a in input().split()]
heapify(a_s)
for _ in range(m):
amax = heappop(a_s)
heappush(a_s, ceil(amax / 2))
res = sum([-heappop(a_s) for _ in range(n)])
print(res) | p02912 |
from math import ceil
from heapq import *
n, m = list(map(int, input().split()))
a_s = [-int(a) for a in input().split()]
heapify(a_s)
for _ in range(m):
amax = heappop(a_s)
heappush(a_s, ceil(amax / 2))
res = sum([-heappop(a_s) for _ in range(n)])
print(res) | from math import ceil
from heapq import *
n, m = list(map(int, input().split()))
a_s = [-int(a) for a in input().split()]
heapify(a_s)
for _ in range(m):
amax = -heappop(a_s)
heappush(a_s, -(amax // 2))
res = -sum(a_s)
print(res)
| p02912 |
n,m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
for _ in range(m):
a.sort()
a[-1] = int(a[-1] / 2)
print((sum(a))) | import heapq
n,m = [int(x) for x in input().split()]
a = [int(x)*(-1) for x in input().split()]
heapq.heapify(a)
for _ in range(m):
tmp_min = heapq.heappop(a)
heapq.heappush(a, (-1)* (-tmp_min//2))
print((-sum(a))) | p02912 |
N,M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
for m in range(M):
A[A.index(max(A))] = A[A.index(max(A))] // 2
print((sum(A))) | N,M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
import heapq
heapA = []
for a in A:
heapq.heappush(heapA,-a)
for m in range(M):
tmp = -heapq.heappop(heapA)
tmp = tmp//2
tmp = -1 * tmp
heapq.heappush(heapA,tmp)
print((-sum(heapA))) | p02912 |
import math
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
max = 0
for j in range(n):
if max < a[j]:
max = a[j]
max_i = j
a[max_i] = math.floor(a[max_i] / 2)
### a[a.index(max(a))] = math.floor(a[a.index(max(a))] / 2)
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = [-int(x) for x in input().split()]
heapq.heapify(a)
for i in range(m):
t = -heapq.heappop(a)
heapq.heappush(a, (t // 2) * (-1))
print((-sum(a)))
| p02912 |
n = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n[1]):
a[a.index(max(a))] = int(max(a) / 2)
print((sum(a))) | import heapq
n = list(map(int,input().split()))
a = list(map(int,input().split()))
#heapqでは最小値しか取り出せないので，*(-1)することで最大値を取り出す
for i in range(len(a)):
a[i] *= -1
#リストを優先度付きキューにする
heapq.heapify(a)
for i in range(n[1]):
#最小値(実際には最大値であるはずの値)を取り出す
tmp = heapq.heappop(a)
#取り出した値を2で割って切り下げで優先度付きキューに挿入
heapq.heappush(a, int(tmp/2))
print((-sum(a)))
'''
max()はO(N)．heapqはO(logN)
これだと発想はあっているが，O(NM)となるので間に合わない
for i in range(n[1]):
a[a.index(max(a))] = int(max(a) / 2)
print(sum(a))
''' | p02912 |
def main():
n, m = list(map(int, input().split()))
a_list = list(map(int, input().split()))
for _ in range(m):
i = a_list.index(max(a_list))
a_list[i] = int(a_list[i]/2)
print((sum(a_list)))
if __name__ == '__main__':
main()
| import heapq
def main():
n, m = list(map(int, input().split()))
a_list = list([-int(x) for x in input().split()])
heapq.heapify(a_list)
for _ in range(m):
a = heapq.heappop(a_list)
heapq.heappush(a_list, -(-a // 2))
print((-sum(a_list)))
if __name__ == '__main__':
main()
| p02912 |
def solve():
import sys
import math
sys.setrecursionlimit(10**7)
readline=sys.stdin.readline
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
for i in range(m):
a += [a.pop()//2]
a.sort()
print((sum(a)))
if __name__ == '__main__':
solve() | def solve():
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
readline=sys.stdin.readline
n,m = list(map(int,input().split()))
a = [-int(i) for i in input().split()]
heapq.heapify(a)
t = heapq.heappop(a)
for i in range(m-1):
t = heapq.heappushpop(a,t/2)
heapq.heappush(a,t/2)
print((sum(int(-i) for i in a)))
if __name__ == '__main__':
solve() | p02912 |
import bisect
N , M = list(map(int,input().split()))
A = [int(i) for i in input().split()]
A.sort()
for _ in range(M):
a = A.pop(-1) >> 1
A.insert(bisect.bisect_left(A,a),a)
print((sum(A)))
| import heapq
N , M = list(map(int,input().split()))
A = [-int(i) for i in input().split()]
heapq.heapify(A)
for _ in range(M):
a = -heapq.heappop(A) >> 1
heapq.heappush(A,-a)
print((-sum(A))) | p02912 |
import heapq
N,M=list(map(int,input().split()))
a=list(map(int,input().split()))
heapq.heapify(a)
for _ in range(M):
a = list([x * (-1) for x in a]) # 各要素を-1倍
heapq.heapify(a) # リストを優先度付きキューへ
number=heapq.heappop(a) * (-1) # 最大値の取り出し
a = list([x * (-1) for x in a]) # 各要素を-1倍
heapq.heappush(a, number//2) # 要素の挿入
print((sum(a)))
| import heapq
N,M=list(map(int,input().split()))
a=list(map(int,input().split()))
a = list([x * (-1) for x in a]) # 各要素を-1倍
heapq.heapify(a) # リストを優先度付きキューへ
for _ in range(M):
number=heapq.heappop(a) # 最大値の取り出し
if number%2==0:
number=number//2
else:
number=number//2+1
heapq.heappush(a, number) # 要素の挿入
print((-sum(a)))
| p02912 |
N,M = list(map(int,input().split()))
value = list(map(int,input().split()))
for _ in range(M):
value[value.index(max(value))] = max(value)//2
print((sum(value))) | import heapq as hp
n, m = list(map(int, input().split()))
list_A = list(map(int, input().split()))
a_q = []
for i in list_A:
hp.heappush(a_q, -1*i)
for i in range(m):
tmp = hp.heappop(a_q)
tmp = hp.heappush(a_q, int(tmp/2))
print((-sum(a_q))) | p02912 |
import heapq
N,M = list(map(int,input().split()))
original_value = list(map(int,input().split()))
value = []
for v in original_value:
heapq.heappush(value,v*(-1))
for i in range(M):
num = (heapq.heappop(value)*(-1)//2)*(-1)
heapq.heappush(value,num)
print((sum(list([x*(-1) for x in value]))))
| import heapq
N,M = list(map(int,input().split()))
value = list(map(int,input().split()))
value = list([x*(-1) for x in value])
heapq.heapify(value)
for i in range(M):
num = (heapq.heappop(value)*(-1)//2)*(-1)
heapq.heappush(value,num)
print((sum(list([x*(-1) for x in value]))))
| p02912 |
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
A = sorted(A)
for _ in range(M):
A[-1] = int(A[-1] * 0.5)
A = sorted(A)
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
q = []
for a in A:
heapq.heappush(q, -a)
for _ in range(M):
tmp = -heapq.heappop(q)
heapq.heappush(q, -(tmp//2))
print((-sum(q))) | p02912 |
import heapq
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
for _ in range(m):
maximum = a.index(max(a))
a[maximum] = a[maximum] // 2
print((sum(a)))
| from heapq import heappop,heappush,heapify
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a_minus = [-x for x in a]
heapify(a_minus)
pop = lambda: -heappop(a_minus)
push = lambda x: heappush(a_minus,-x)
for _ in range(m):
x = pop()
push(x//2)
print((-sum(a_minus)))
| p02912 |
N, M = list(map(int, input().split()))
A = list([int(x) for x in input().split(' ')])
A.sort(reverse=True)
for _ in range(M):
A[0] = A[0] // 2
for i in range(N-1):
if A[i] < A[i+1]:
A[i+1], A[i] = A[i:i+2]
else:
break
print(('{}'.format(sum(A)))) | import heapq
N, M = list(map(int, input().split()))
A = input().split(" ")
neg_A = [-int(a) for a in A]
heapq.heapify(neg_A)
for t in range(M):
heapq.heappush(neg_A, -(-heapq.heappop(neg_A)//2))
print((-sum(neg_A))) | p02912 |
import bisect
n, m=list(map(int, input().split()))
a=[int(n) for n in input().split()]
ans=0
cha=[]
a.sort()
if len(a)>m:
for i in range(m):
cha.append(a.pop())
else:
for i in range(len(a)):
cha.append(a.pop())
cha.sort()
for i in range(m):
num=cha.pop()//2
cha.insert(bisect.bisect_left(cha,num),num)
print((sum(cha)+sum(a))) | import heapq
n, m=list(map(int, input().split()))
a=[-1*int(n) for n in input().split()]
heapq.heapify(a)
for i in range(m):
num=-1*(-1*heapq.heappop(a)//2)
heapq.heappush(a,num)
print((-1*sum(a))) | p02912 |
n, m = list(map(int,input().split()))
s = list(map(int, input().split()))
for i in range(m):
idx = s.index(max(s))
s[idx] = max(s)//2
print((sum(s))) | import heapq
n, m = list(map(int,input().split()))
s = list(map(int, input().split()))
s = list([x * (-1) for x in s])
heapq.heapify(s)
for i in range(m):
mx = heapq.heappop(s) * (-1)
mx = mx//2
heapq.heappush(s, mx*(-1))
print((sum(s)*(-1))) | p02912 |
import bisect
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for _ in range(m):
max_price = A.pop(-1) // 2
bisect.insort(A, max_price)
total = sum(A)
print(total)
| import heapq
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A = list([x*(-1) for x in A])
heapq.heapify(A)
for _ in range(m):
max_price = -heapq.heappop(A) // 2
heapq.heappush(A, -max_price)
total = -sum(A)
print(total)
| p02912 |
n,m = list(map(int,input().split()))
a_L = list(map(int,input().split()))
#a_L = list(sorted(a_L))
#max_num = a_L[0]
#a_L.append(max_num)
for val in range(0,m):
a_L = list(sorted(a_L))
a_L[-1] = a_L[-1] //2
print((sum(a_L)))
| import heapq
n,m = list(map(int,input().split()))
a_L = list([int(x) * -1 for x in input().split()])
heapq.heapify(a_L)
#a_L = list(sorted(a_L))
#max_num = a_L[0]
#a_L.append(max_num)
for val in range(0,m):
a_min = heapq.heappop(a_L)
a_min = (-1 * a_min)//2 * -1
heapq.heappush(a_L,a_min)
print((-sum(a_L)))
| p02912 |
import bisect
n,m = list(map(int,input().split()))
a = sorted(list(map(int,input().split())))
for i in range(m):
b = a[-1]
a.remove(b)
b = int(b/2)
bisect.insort(a,b)
print((sum(a))) | import heapq
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = list([x*(-1) for x in a]) # 各要素を-1倍することで，最小最大を逆転
heapq.heapify(a)#優先度付きキューに変換
for i in range(m):
tmp = heapq.heappop(a)
heapq.heappush(a,(-tmp//2)*(-1))#負の剰余では切り捨て方向が異なってしまうので，いったんプラスにする．
print((-sum(a))) | p02912 |
N, M = list(map(int,input().split()))
A = list(map(int, input().split()))
import heapq
def min_heapsort(iter):
h = []
for value in iter:
heapq.heappush(h, value)
return [heapq.heappop(h) for i in range(len(h))]
def max_heapsort(iter):
for i in reversed(list(range(len(iter)//2))):
max_heapify(iter,i)
def max_heapify(array,i):
left = 2*i+1
right = 2*i+2
length = len(array) - 1
biggest = i
if left <= length and array[i] < array[left]:
biggest = left
if right <= length and array[biggest] < array[right]:
biggest = right
if biggest != i:
array[i], array[biggest] = array[biggest], array[i]
max_heapify(array, biggest)
def waribiki(X,Y):
return X//(2**Y)
if len(A)==1:
while M>0:
A[0] = waribiki(A[0],1)
M -= 1
else:
while M>0:
#A.sort(reverse=True)
max_heapsort(A)
m=1
#while M>0 and waribiki(A[0],m)>A[1]:
# m+=1
A[0] = waribiki(A[0],m)
M -= m
print((sum(A)))
| N, M = list(map(int,input().split()))
def intm(x):
return int(x)*-1
A = list(map(intm, input().split()))
import heapq
heapq.heapify(A)
while M>0:
a = -heapq.heappop(A) // 2
heapq.heappush(A,-a)
M -= 1
print((-sum(A)))
| p02912 |
from heapq import heapify, heappush, heappop
N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
PQ = [-A for A in As]
heapify(PQ)
for _ in range(M):
A = -heappop(PQ)
heappush(PQ, -A/2)
ans = 0
while PQ:
A = -heappop(PQ)
ans += int(A)
print(ans)
| from heapq import heapify, heappush, heappop
N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
PQ = [-A for A in As]
heapify(PQ)
for _ in range(M):
A = -heappop(PQ)
heappush(PQ, -(A//2))
#print('PQ:', PQ)
print((-sum(PQ)))
| p02912 |
X = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(X[1]):
A[A.index(max(A))] = int(max(A)/2)
sum = 0
for a in A:
sum+=a
print(sum) | import heapq
X = list(map(int, input().split()))
# A = list(map(int, input().split()))
A = list([int(x)*(-1) for x in input().split()]) # 最大値を取るために各要素を-1倍
heapq.heapify(A)
for i in range(X[1]):
x = heapq.heappop(A) * (-1) # 最大値の取り出し
heapq.heappush(A, int(x/2) * (-1))
ans = 0
for i in range(X[0]):
ans -= A[i]
print(ans) | p02912 |
import sys
input = sys.stdin.readline
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
index = A.index(max(A))
A[index] = A[index]//2
print((sum(A)))
| import sys
from heapq import heappush, heappop
input = sys.stdin.readline
N,M = list(map(int, input().split()))
A = []
for a in input().split():
heappush(A,-int(a))
for _ in range(M):
tmp = heappop(A)
heappush(A, -(-tmp//2))
print((-sum(A)))
| p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
if n > 1:
f = True
else:
f = False
for i in range(m):
a[a.index(max(a))] //= 2
print((sum(a)))
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
a.append(0)
b = 0
if n > 1:
for i in range(m):
a[b] //= 2
if a[b] < a[0] or a[b] < a[b + 1]:
if a[0] > a[b + 1]:
b = 0
a.sort(reverse=True)
else:
b += 1
else:
for i in range(m):
a[0] //= 2
print((sum(a)))
| p02912 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def main():
# sys.stdin = open("sample.txt")
N, M = Scanner.map_int()
A = [-a for a in Scanner.map_int()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a = -(-a // 2)
heapq.heappush(A, a)
print((-sum(A)))
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
lower, upper = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
i += 1
return lower + upper[::-1]
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N ** 0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
N, M = Scanner.map_int()
A = Scanner.map_int()
A = [-a for a in A]
heapq.heapify(A)
for _ in range(M):
x = -heapq.heappop(A)
x //= 2
heapq.heappush(A, -x)
print((-sum(A)))
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| p02912 |
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
from queue import PriorityQueue
q = PriorityQueue()
for a in aa:
q.put(-a)
for i in range(m):
g = q.get()
q.put(-(-g // 2))
cost = 0
for a in aa:
cost -=q.get()
print(cost) | n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
import heapq
for i in range(len(aa)):
aa[i] = -aa[i]
heapq.heapify(aa)
for i in range(m):
v = heapq.heappop(aa)
heapq.heappush(aa,-(-v // 2))
cost = 0
for i in range(len(aa)):
cost -=heapq.heappop(aa)
print(cost) | p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
for m in range(M):
A[0] = A[0] // 2
for i in range(N - 1):
if A[i] < A[i + 1]:
A[i], A[i + 1] = A[i + 1], A[i]
else:
break
print((sum(A))) | def funcD():
import heapq
N, M = list(map(int, input().split()))
A = list([-1 * int(x) for x in input().split()])
A.sort(reverse=True)
heapq.heapify(A)
for m in range(M):
a = -(-heapq.heappop(A) // 2)
heapq.heappush(A, a)
print((-sum(A)))
funcD() | p02912 |
import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[-A[i] for i in range(N)]
heapq.heapify(A)
for i in range(M):
a=A[0]
heapq.heappop(A)
heapq.heappush(A,-(a//-2))
heapq.heapify(A)
print((-sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[-A[i] for i in range(N)]
heapq.heapify(A)
for i in range(M):
a=A[0]
heapq.heappop(A)
heapq.heappush(A,-(a//-2))
print((-sum(A))) | p02912 |
import bisect
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
for i in range(M):
B = A[-1]//2
del A[-1]
bisect.insort_left(A, B)
#print(A)
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list([int(x)*(-1) for x in input().split()])
heapq.heapify(A) #落としたりするのもO(N)かかってしまうのでHeapで実装
#A=[i for i in range(N)]
for i in range(M):
B = heapq.heappop(A)
heapq.heappush(A,-1*(-1*B//2))
#print(A)
print((-sum(A))) | p02912 |
from bisect import bisect_left
import sys
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
if N == 1:
for i in range(M):
A[0] = A[0] // 2
print((sum(A)))
sys.exit()
A.sort(reverse=True)
for i in range(M):
index = A.index(max(A))
A[index] = A[index] // 2
print((sum(A))) | import heapq
import sys
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
if N == 1:
for i in range(M):
A[0] = A[0] // 2
print((sum(A)))
sys.exit()
h = []
for i in range(N):
heapq.heappush(h, -A[i])
for i in range(M):
tmp = heapq.heappop(h)
tmp = -(-tmp // 2)
heapq.heappush(h, tmp)
print((-sum(h))) | p02912 |
import bisect
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A=sorted(A)
for i in range(M):
t=A[-1]//2
index=bisect.bisect_right(A,t)
A=A[0:len(A)-1]
A.insert(index,t)
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A=sorted(A)
que = []
for a in A:
heapq.heappush(que, -1*a)
for a in range(M):
maxvalue = -1 * heapq.heappop(que)
maxvalue /= 2
heapq.heappush(que, -1*maxvalue)
print((sum([int(-1*a) for a in que])))
| p02912 |
from heapq import heappush,heappop,heapify
from math import ceil
def main():
N, M = (int(i) for i in input().split())
A = [-int(i) for i in input().split()]
heapify(A)
for divcnt in range(M):
tmp = ceil(heappop(A)/2)
heappush(A,tmp)
print((-sum(A)))
if __name__ == "__main__":
main()
| def main():
from heapq import heappush,heappop,heapify
N, M = (int(i) for i in input().split())
A = [-int(i) for i in input().split()]
heapify(A)
for divcnt in range(M):
tmp = -heappop(A)
tmp //= 2
heappush(A,-tmp)
print((-sum(A)))
if __name__ == "__main__":
main()
| p02912 |
#141d
from collections import deque
import bisect
import math
N,M = list(map(int, input().split())) #1≤N,M≤10^5
A_list = list(map(int, input().split()))
#→高額なものに割引券を使った方が良い
if len(A_list) > 1:
A_list.sort(reverse=False)
highest = A_list.pop()
next_highest = A_list[-1]
discounted_deque = deque()
while 1:
#print(A_list,highest)
#highest/(pow(2,X)) <= next_highest に持っていきたい
#highest <= next_highest * pow(2,X)
#highest/next_highest <= 2**X
#log2(highest/next_highest) <= X
use_tickets = math.ceil(math.log(highest/next_highest)/math.log(2))
if use_tickets == 0:
use_tickets = 1
if use_tickets > M:
use_tickets = M
highest /= pow(2,use_tickets)
M -= use_tickets
#print(A_list,highest)
if M!= 0:
discounted_deque.appendleft(highest)
if len(A_list) > 0:
if A_list[-1] > discounted_deque[-1]:
highest = A_list.pop()
else:
highest = discounted_deque.pop()
if len(A_list) > 0 and len(discounted_deque) > 0:
if A_list[-1] > discounted_deque[-1]:
next_highest = A_list[-1]
else:
next_highest = discounted_deque[-1]
elif len(A_list) == 0 and len(discounted_deque) > 0:
next_highest = discounted_deque[-1]
elif len(A_list) > 0 and len(discounted_deque) == 0:
next_highest = A_list[-1]
else:
A_list.append(highest)
break
A_list = [int(A) for A in A_list]
discounted_list = [int(B) for B in list(discounted_deque)]
print((sum(A_list)+sum(discounted_list)))
else:
A_list[-1] = A_list[-1]//(pow(2,M))
print((A_list[-1]))
| #141d
from collections import deque
import bisect
import math
N,M = list(map(int, input().split())) #1≤N,M≤10^5
A_list = list(map(int, input().split()))
#→高額なものに割引券を使った方が良い
if len(A_list) > 1:
A_list.sort(reverse=False)
highest = A_list.pop()
next_highest = A_list[-1]
discounted_deque = deque()
while 1:
use_tickets = math.ceil(math.log(highest/next_highest)/math.log(2))
if use_tickets == 0:
use_tickets = 1
elif use_tickets > M:
use_tickets = M
highest /= pow(2,use_tickets)
M -= use_tickets
if M!= 0:
discounted_deque.appendleft(highest)
if len(A_list) > 0:
if A_list[-1] > discounted_deque[-1]:
highest = A_list.pop()
else:
highest = discounted_deque.pop()
else:
highest = discounted_deque.pop()
if len(A_list) > 0 and len(discounted_deque) > 0:
if A_list[-1] > discounted_deque[-1]:
next_highest = A_list[-1]
else:
next_highest = discounted_deque[-1]
elif len(A_list) == 0 and len(discounted_deque) > 0:
next_highest = discounted_deque[-1]
elif len(A_list) > 0 and len(discounted_deque) == 0:
next_highest = A_list[-1]
else:
A_list.append(highest)
break
A_list = [int(A) for A in A_list]
discounted_list = [int(B) for B in discounted_deque]
print((sum(A_list)+sum(discounted_list)))
else:
A_list[-1] = A_list[-1]//(pow(2,M))
print((A_list[-1]))
| p02912 |
import bisect
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
#print(A)
for _ in range(M):
a = int(A.pop()/2)
bisect.insort_left(A, a)
print((sum(A))) | import heapq #今回は優先度キューを使う
N, M = list(map(int, input().split()))
A = list([-int(x) for x in input().split()]) #優先度付きキューは最小値しか出せないので、×-1して最大値を最小値にしている
#A.sort() 今回は間に合わない
heapq.heapify(A) #優先度付きキューに変換
#print(A)
for _ in range(M):
a = heapq.heappop(A) #最小値取得
a = -a // 2 #負のまま計算すると切り捨てが違うところで起こる
heapq.heappush(A,-a) #優先度付きキューに挿入
print((-sum(A)))
| p02912 |
import sys
def main():
input = sys.stdin.readline
N, M = list(map(int,input().strip().split()))
A = list(map(int,input().strip().split()))
A.sort(reverse=True)
for i in range(M):
A[0] = A[0]/2
larger = -1
smaller = N-1
target = A.pop(0)
while larger-smaller!=-1:
ind = int((larger+smaller)/2)
if target>A[ind]:
smaller = ind
else:
larger = ind
A.insert(smaller,target)
# print(A)
# ind = 0
# if N!=1:
# while A[ind]<A[ind+1]:
# A[ind], A[ind+1] = A[ind+1], A[ind]
# ind = ind+1
# if ind==N-1:
# break
print((sum(map(int,A))))
if __name__ == "__main__":
main() | import sys
def main():
input = sys.stdin.readline
N, M = list(map(int,input().strip().split()))
A = list(map(int,input().strip().split()))
A.sort(reverse=True)
count = [0]*N
ind = [0]
for i in range(M):
maximum = 0
for j in ind:
if A[j]>maximum:
maxind = j
maximum = A[j]
if maximum==0: break
# print(maxind)
A[maxind] = A[maxind]/2
count[maxind] += 1
# print(count[maxind])
if count[maxind]==len(ind):
ind.append(0)
# ind[-2] += 1
ind[-2] = min(N-1,ind[-2]+1)
# if ind[-1]!=N-1:
else:
# ind[count[maxind]-1] += 1
ind[count[maxind]-1] = min(N-1,ind[count[maxind]-1]+1)
# print(ind)
print((sum(map(int,A))))
if __name__ == "__main__":
main() | p02912 |
import math
N, M = list(map(int, input().split()))
price = list(map(int, input().split()))
total = sum(price)
for i in range(M):
max_index = price.index(max(price))
discount = math.ceil(max(price) / 2)
total -= discount
price[max_index] -= discount
print(total) | import heapq
N, M = list(map(int, input().split()))
price = list([int(x) * (-1) for x in input().split()])
heapq.heapify(price)
for i in range(M):
max_price = -(heapq.heappop(price))
new_price = max_price // 2
heapq.heappush(price, -(max_price // 2))
print((-(sum(price)))) | p02912 |
import heapq
N, M = list(map(int, input().split()))
a = list([int(x)*(-1) for x in input().split()])
heapq.heapify(a)
for i in range(M):
tmp = heapq.heappop(a)
if tmp % 2 == 0:
tmp //= 2
else:
tmp //= 2
tmp += 1
heapq.heappush(a,tmp)
print((sum(a)*(-1))) | N, M = list(map(int, input().split()))
arr = list([int(x)*(-1) for x in input().split()])
import heapq
heapq.heapify(arr)
for _ in range(M):
tmp = heapq.heappop(arr)
heapq.heappush(arr,-(-tmp//2))
print((-sum(arr))) | p02912 |
def main():
N,M=list(map( int, input().split()))
A=list( map( int, input().split()))
for i in range(M):
A[A.index(max(A))] = A[A.index(max(A))]//2
print((sum(A)))
if __name__ == '__main__':
main() | import heapq
def main():
N,M=list(map( int, input().split()))
A=list( map( int, input().split()))
A = list([x*(-1) for x in A])
heapq.heapify(A)
for _ in range(M):
u = heapq.heappop(A)
heapq.heappush(A,int(u/2))
print((-sum(A)))
if __name__ == '__main__':
main()
| p02912 |
import math
n, m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
for i in range(m):
max = 0
for j in range(n):
if a[j] > max:
max = a[j]
maxIndex = j
a[maxIndex] /= 2
count = 0
for i in range(n):
count += math.floor(a[i])
print(count)
| import math
import heapq
n, m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a_minus = [a[i] * (-1) for i in range(n)]
heapq.heapify(a_minus)
for i in range(m):
value = heapq.heappop(a_minus)
value /= 2
heapq.heappush(a_minus, value)
count = 0
for i in range(n):
value = heapq.heappop(a_minus) * -1
count += math.floor(value)
print(count)
| p02912 |
import bisect
n, m = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
for i in range(m):
a = A.pop(-1)
a //= 2
bisect.insort_left(A, a)
print((sum(A)))
| import heapq
n, m = list(map(int, input().split()))
A = sorted(list([int(x)*(-1) for x in input().split()]))
heapq.heapify(A)
for i in range(m):
a = heapq.heappop(A)
a = a * (-1) // 2
heapq.heappush(A, -a)
print((-sum(A)))
| p02912 |
N,M = input().split()
N = int(N)
M = int(M)
price_list = input().split()
price_list = list(map(int, price_list))
for _ in range(M):
num = max(price_list)
price_list.remove(num)
price_list.append(int(num/2))
print((sum(price_list))) | import heapq
N,M = input().split()
N = int(N)
M = int(M)
price_list = input().split()
heap_list = []
for i in price_list:
heapq.heappush(heap_list, int(i) * (-1))
for _ in range(M):
max_num = heapq.heappop(heap_list)
heapq.heappush(heap_list, int(max_num /2))
print((sum(heap_list) * (-1))) | p02912 |
from math import ceil
import heapq
N, M = list(map(int, input().split()))
tmpA = list(map(int, input().split()))
A = [-a for a in tmpA]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| from math import ceil
import heapq
N, M = list(map(int, input().split()))
A = [-int(a) for a in input().split()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| p02912 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse = True)
for i in range(M):
a = A.index(max(A))
A[a] = int(A[a]/2)
print((sum(A))) | import sys
import heapq
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N):
A[i] = (-1)*A[i]
heapq.heapify(A)
for i in range(M):
a = heapq.heappop(A)
heapq.heappush(A, int(a/2))
print((abs(sum(A)))) | p02912 |
import bisect
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a_sorted = sorted(a)
while m > 0:
maximum = a_sorted.pop(-1)
if maximum % 2 == 0:
bisect.insort_left(a_sorted, maximum//2)
else:
bisect.insort_left(a_sorted, maximum//2)
m += -1
ans = sum(a_sorted)
print(ans) | import heapq
n, m = list(map(int, input().split()))
a = list([int(x) * (-1) for x in input().split()])
heapq.heapify(a)
for i in range(m):
maximum = heapq.heappop(a)
heapq.heappush(a, (-1)*(-maximum//2))
print((-sum(a))) | p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
for _ in range(M):
ma=max(A)
A[A.index(ma)]=ma//2
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list([-int(x) for x in input().split()])
heapq.heapify(A)
for _ in range(M):
ma=heapq.heappop(A)
heapq.heappush(A,-((-ma)//2))
print((-sum(A))) | p02912 |
import bisect
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
for w in range(M):
max2=A.pop(N-1)/2
#A[N-1]=A[N-1]/2
#max=A[N-1]
bisect.insort_left(A,max2)
#print(A)
B=list(map(int, A))
#print(B)
print((sum(B))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
#print(A)
A =[-a for a in A]
#print(A)
heapq.heapify(A)
for w in range(M):
max=heapq.heappop(A)
heapq.heappush(A,max/2)
B=list(map(int, A))
#print(B)
print((sum(B)*-1)) | p02912 |
n,m = list(map(int,input().split()))
item = list(map(int,input().split()))
item.sort(reverse=True)
s = 0
while s == 0:
for i in range(n):
if i == 0:
item[i] = int(item[i]/2)
m -= 1
temp = item[i]
if m == 0:
s = 1
break
continue
item.sort(reverse=True)
break
print((sum(item))) | n,m = list(map(int,input().split()))
item = list(map(int,input().split()))
#品物を高い順に並び替える
item.sort(reverse=True)
#割引券がなくなるまで操作を繰り返す
while m != 0:
#品物の高いものから順に割引券を使用していく
for i in range(n):
#一番高い品物の割引券を使用した後の値段はtempとして保持しておく
if i == 0:
item[i] = int(item[i]/2)
m -= 1
temp = item[i]
if m == 0:
break
continue
#tempよりも品物の値段が高い間は割引券を使用しながらfor文を回し続ける
if item[i] > temp:
item[i] = int(item[i]/2)
m -= 1
if m == 0:
break
continue
#tempよりも品物の値段が安くなったら、もう一度値段の高い順にソートし直して操作を繰り返す
item.sort(reverse=True)
break
#品物の値段を合計して出力
print((sum(item))) | p02912 |
n, m = list(map(int, input().split()))
items = list(map(int, input().split()))
for i in range(m):
max_val_i = items.index(max(items))
items[max_val_i] /= 2
print((sum(list(map(int, items))))) | import heapq as hq
n, m = list(map(int, input().split()))
items = [-int(i) for i in input().split()]
hq.heapify(items)
for _ in range(m):
max_val = hq.heappop(items)
hq.heappush(items, -(-max_val // 2))
print((-sum(items))) | p02912 |
import heapq
from collections import deque
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
#print(A)
for i in range(n):
A[i]*=-1
#print(A)
for i in range(m):
heapq.heapify(A)
x=heapq.heappop(A)
#print(x,A)
if x%2==0:
x//=2
else:
x=x//2 +1
heapq.heappush(A,x)
#print(A)
ans=-1*sum(A)
print(ans) | import heapq
from collections import deque
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(n):
A[i]*=-1
heapq.heapify(A)
for i in range(m):
x=heapq.heappop(A)
if x%2==0:
x//=2
else:
x=x//2 +1
heapq.heappush(A,x)
ans=-1*sum(A)
print(ans) | p02912 |
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
while M > 0:
A[-1] = A[-1] // 2
M -= 1
A = sorted(A)
print((sum(A))) | N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N):
A[i] *= -1
import heapq
heapq.heapify(A)
for i in range(M):
m = heapq.heappop(A)
heapq.heappush(A,-1*(-m//2))
print((-1*sum(A))) | p02912 |
n,m = list(map(int,input().split()))
As = list(map(int,input().split()))
for i in range(m):
a = max(As)
As[As.index(a)] = int(a/2)
print((sum(As)))
| import heapq
n,m = list(map(int,input().split()))
As = [-i for i in list(map(int,input().split()))]
heapq.heapify(As)
for i in range(m):
a = -heapq.heappop(As)
heapq.heappush(As,-int(a/2))
print((-sum(As)))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
while M > 0:
maxv = max(A)
max_index = A.index(maxv)
A[max_index] = A[max_index] // 2
M -= 1
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [a * -1 for a in A]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, (-a // 2) * (-1))
print((-sum(A)))
| p02912 |
n,m=list(map(int,input().split()))
c=list(map(int,input().split()))
i=m
while i>0:
ma=max(c)
ind=c.index(ma)
c[ind]=ma//2
i-=1
print((sum(c))) | import heapq
n,m=list(map(int,input().split()))
c=list([int(x)*-1 for x in input().split()])
#heapqでは最小値しか取り出せないので最大値をとるばあには－１をかけておく
heapq.heapify(c) #リストを優先度付きキューに
for i in range(m):
cmin=heapq.heappop(c) #最小値の取り出し
heapq.heappush(c,(-1)*(-cmin//2))#最小値を2で割った商をリストに追加
print((-sum(c)))
| p02912 |
n, m = list(map(int, input().split(" ")))
a = list(map(int,input().split(" ")))
for i in range(m):
maxIndex = 0
for j in range(n):
if a[maxIndex] < a[j]:
maxIndex = j
a[maxIndex] = a[maxIndex] >> 1
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] *= -1
heapq.heapify(a)
for _ in range(m):
x = heapq.heappop(a)
heapq.heappush(a, (-x//2)*(-1))
print((-sum(a))) | p02912 |
from collections import deque
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = deque(A)
A = sorted(A)
for i in range(M):
temp1 = A.index(max(A))
temp2 = A.pop(temp1) // 2
A.append(temp2)
print((sum(A))) | from heapq import heappop,heappush
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
H = []
for i in A:
heappush(H, -i)
for _ in range(M):
heappush(H, -((-heappop(H)//2)) )
print((-sum(H)))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for _ in range(M):
A.sort(reverse=True)
A[0] //= 2
print((sum(A)))
| import sys
from heapq import heappush, heappop
def input(): return sys.stdin.readline().strip()
N, M = list(map(int, input().split()))
A = []
for i in input().split():
heappush(A, -1 * int(i))
# print(A)
for _ in range(M):
val = heappop(A)
if val == 0:
break
heappush(A, (val+1)//2)
print((-1 * sum(A)))
| p02912 |
import bisect
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
while M:
m = A.index(max(A))
A[m] //= 2
M -= 1
print((sum(A)))
| import heapq
N, M = list(map(int, input().split()))
A = list([int(x)*(-1) for x in input().split()])
heapq.heapify(A)
while M:
m = heapq.heappop(A) * (-1)
heapq.heappush(A, (-1) * (m // 2))
M -= 1
print((sum(A) * (-1)))
| p02912 |
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
max_A = max(A)
num_A= A.index(max_A)
A[num_A] = max_A // 2
print((sum(A)))
| import heapq as hq
N,M = list(map(int, input().split()))
A =[-x for x in map(int, input().split())]
hq.heapify(A)
for i in range(M):
m = A[0]
hq.heappushpop(A, -((-m)//2))
print((-sum(A)))
| p02912 |
n,m=list(map(int,input().split()))
a=list(map(int, input().split()))
while m:
i = a.index(max(a))
a[i]//=2
m -= 1
print((sum(a))) | import heapq
n, m = list(map(int, input().split()))
lis = []
for i in input().split():
heapq.heappush(lis, -int(i))
for j in range(m):
tmp = -heapq.heappop(lis)
heapq.heappush(lis, -int((tmp/2)))
print((-sum(lis))) | p02912 |
N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())), reverse=True)
B = []
B.append(A.pop(0)//2)
for i in range(1,M):
if A == []:
B[0] = B[0]//2
B = sorted(B, reverse=True)
else:
if A[0] > B[0]:
B.append(A.pop(0)//2)
else:
B[0] = B[0]//2
B = sorted(B, reverse=True)
print((sum(A)+sum(B))) | N, M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())), reverse=True)
b = []
b.append(A.pop(0)//2)
for i in range(1,M):
if A == []:
b.append(b.pop(0)//2)
else:
if A[0] > b[0]:
b.append(A.pop(0)//2)
else:
b.append(b.pop(0)//2)
print((sum(A)+sum(b))) | p02912 |
n,m = list(map(int,input().split()))
alist = list(map(int,input().split()))
for i in range(m):
alist[alist.index(max(alist))] //= 2
print((sum(alist))) | import sys
input = sys.stdin.buffer.readline
from math import log
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
table = [[0]*(int(log(a[-1],2))+2) for i in range(n)]
for i in range(n):
for y in range(int(log(a[-1],2))+2):
table[i][y] = a[i]//pow(2,y)
if a[i]//pow(2,y) == 0:
break
s_table = [[0]*(int(log(a[-1],2))+2) for i in range(n)]
for i in range(n):
s_table[i][0] = table[i][0]
import heapq
hq = []
heapq.heapify(hq)
h_push = heapq.heappush
h_pop = heapq.heappop
for i in range(n):
for y in range(1,int(log(a[-1],2))+2):
s_table[i][y] = table[i][y]-table[i][y-1]
h_push(hq,table[i][y]-table[i][y-1])
if table[i][y]-table[i][y-1] == -1:
break
ans = sum(a)
for i in range(m):
if not hq:
print((0))
exit()
ans += h_pop(hq)
print(ans)
| p02912 |
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
maxim = max(a)
minim = min(a)
while(maxim>minim*2 and m>=1):
lmax=-1
maxid=-1
for i in range(n):
if(lmax<a[i]):
lmax=a[i]
maxid=i
maxim=lmax
if(maxim<=minim*2):
break
a[maxid] = a[maxid]//2
m-=1
if(a[maxid]<minim):
minim=a[maxid]
a.sort()
aa=a
a=[aa[n-1-i] for i in range(n)]
#print(a)
if(m>=1):
for i in range(m):
a[i%n] = a[i%n]//2
#print(a)
print((sum(a))) | import math
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
b=[]
for i in range(n):
for j in range(1+math.floor(math.log(a[i]+0.1)/math.log(2))):
b.append(a[i]//(2**j)-a[i]//(2**(j+1)))
b.sort()
bb=b
b=[bb[len(b)-1-i] for i in range(len(bb))]
print((sum(a)-sum(b[0:m]))) | p02912 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.